Revert PR-tier coverage; keep coverage canonical in nightly

The PR-tier coverage instrumentation introduced in b80b090 turned out to
add ~600% wall to the unit run on the GitHub ubuntu-latest 2-vCPU
runner, not the ~30% that motivated option 3. Coverage's sys.settrace
collides with JAX's own tracing inside compute_mlt / compute_fluxes /
the JIT-compiled RHS path; the ubuntu + py3.12 cell ran for >18 min
versus 3 min for the same suite without --cov on py3.13. The
fast-feedback rationale for PR-side coverage is dead at that wall.

ci_tests.yml: drop pytest-cov from the pip install, drop the COV_FLAGS
env var and the --cov-report flags from the pytest invocation, drop the
"Upload coverage to Codecov" step, drop the "Download last nightly
coverage artifact" step, drop the "Estimate combined coverage union"
step, drop the actions:read permission (only needed for gh run download
which is gone). PR tier returns to ~3 min wall on every cell.

nightly.yml: drop --cov-report=json:coverage.json, drop the timestamp
stamp, drop the upload-artifact step. The artifact had no consumer
after removing the union-estimation step. Coverage to Codecov continues
via --cov-report=xml under the `nightly` flag; the canonical 95% gate
stays enforced via [tool.coverage.report].fail_under in pyproject.toml.

Element 4 of the PROTEUS Ecosystem Testing Standard is satisfied for
this repo by Codecov's own server-side patch coverage check (which
compares each PR diff against the most recent successful nightly upload
on main). The local union estimation step was redundant for repos
where the PR tier is a strict subset of the nightly tier (PR runs unit
only; nightly already includes the same unit tests in its full sweep).

Author: timlichtenberg

.github/workflows/ci_tests.yml

@@ -34,9 +34,6 @@ on:
 
 permissions:
   contents: read
-  # actions:read enables `gh run download` to fetch the previous
-  # nightly's coverage artifact for the union estimation step.
-  actions: read
 
 # Cancel superseded runs on the same ref so a stack of feature-branch
 # pushes does not pile up macOS runners (free-tier concurrency is tight).
@@ -79,7 +76,7 @@ jobs:
 
       - name: Install pip-only test deps (scikits-odes-sundials builds against conda SUNDIALS)
         run: |
-          pip install pytest pytest-cov pytest-xdist pytest-dependency ruff
+          pip install pytest pytest-xdist pytest-dependency ruff
           # Install scikits-odes-sundials directly (skip the scikits-odes
           # metapackage). This avoids scikits-odes-daepack, which is a
           # transitive Fortran dep with f2py incompatibility with numpy
@@ -180,21 +177,9 @@ jobs:
           PY
 
       - name: Run unit tests
-        env:
-          # Coverage instrumentation slows pytest by ~30 %. The Codecov
-          # upload + union-estimation steps below only run on the
-          # ubuntu + py3.12 cell, so the other five matrix cells gain
-          # nothing from emitting coverage. Gate --cov flags to that one
-          # cell to keep the rest of the matrix on the original ~3 min
-          # wall. --cov-fail-under=0 overrides the 95 % floor in
-          # pyproject.toml for this tier (unit-only is around 83 %; the
-          # canonical 95 % gate is enforced in nightly.yml where the
-          # full unit + smoke + slow tier reaches ~96 %).
-          COV_FLAGS: ${{ (matrix.os == 'ubuntu-latest' && matrix.python-version == '3.12') && '--cov=src/aragog --cov-report=xml --cov-report=json:coverage.json --cov-fail-under=0' || '' }}
         run: |
           pytest -m "unit and not slow" -n auto -o "addopts=" \
-            -o "junit_family=legacy" --junitxml=junit.xml \
-            $COV_FLAGS
+            -o "junit_family=legacy" --junitxml=junit.xml
 
       - name: Upload test results to Codecov
         if: ${{ !cancelled() && matrix.os == 'ubuntu-latest' && matrix.python-version == '3.12' }}
@@ -203,222 +188,3 @@ jobs:
           token: ${{ secrets.CODECOV_TOKEN }}
           slug: FormingWorlds/Aragog
           files: junit.xml
-
-      - name: Upload coverage to Codecov
-        if: ${{ !cancelled() && matrix.os == 'ubuntu-latest' && matrix.python-version == '3.12' }}
-        uses: codecov/codecov-action@v5
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          slug: FormingWorlds/Aragog
-          files: coverage.xml
-          flags: ci
-          fail_ci_if_error: false
-
-      - name: Download last nightly coverage artifact
-        id: download-nightly
-        if: ${{ !cancelled() && matrix.os == 'ubuntu-latest' && matrix.python-version == '3.12' }}
-        continue-on-error: true
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          # First-party-only path to cross-workflow artifact download:
-          # query the latest successful nightly run on main, then use
-          # `gh run download`. Failures here do not break the PR (the
-          # union step downgrades to "nightly missing" warning).
-          set +e
-          mkdir -p nightly-coverage
-          RUN_ID=$(gh run list \
-              --workflow=nightly.yml \
-              --branch=main \
-              --status=success \
-              --limit=1 \
-              --json databaseId \
-              --jq '.[0].databaseId' \
-              -R ${{ github.repository }})
-          if [ -z "$RUN_ID" ]; then
-            echo "No successful nightly run found on main."
-            echo "nightly_missing=true" >> "$GITHUB_OUTPUT"
-            exit 0
-          fi
-          echo "Downloading artifact from nightly run $RUN_ID"
-          gh run download "$RUN_ID" \
-              --name nightly-coverage \
-              --dir nightly-coverage \
-              -R ${{ github.repository }}
-          if [ ! -f nightly-coverage/coverage.json ]; then
-            echo "Artifact missing coverage.json; treating as missing."
-            echo "nightly_missing=true" >> "$GITHUB_OUTPUT"
-            exit 0
-          fi
-          echo "nightly_missing=false" >> "$GITHUB_OUTPUT"
-          echo "nightly_run_id=$RUN_ID" >> "$GITHUB_OUTPUT"
-
-      - name: Estimate combined coverage union
-        id: coverage-union
-        if: ${{ !cancelled() && matrix.os == 'ubuntu-latest' && matrix.python-version == '3.12' }}
-        env:
-          NIGHTLY_MISSING: ${{ steps.download-nightly.outputs.nightly_missing }}
-        run: |
-          python - <<'PY'
-          import json
-          import os
-          import pathlib
-          import sys
-          import tomllib
-          from datetime import datetime, timezone
-
-          GRACE_PERIOD = 0.3  # percent; coverage drops below this do not block
-          STALE_HOURS = 48
-
-          def read_totals(path):
-              try:
-                  with open(path) as fh:
-                      data = json.load(fh)
-                  t = data.get('totals', {})
-                  return (
-                      t.get('percent_covered', 0.0),
-                      t.get('covered_lines', 0),
-                      t.get('num_statements', 0),
-                  )
-              except Exception:
-                  return 0.0, 0, 0
-
-          def norm_path(p):
-              p = p.replace('\\', '/')
-              if 'src/' in p:
-                  return p.split('src/', 1)[-1]
-              return p
-
-          def line_set_executed(data):
-              out = set()
-              for path, fd in data.get('files', {}).items():
-                  n = norm_path(path)
-                  for line in fd.get('executed_lines', []) or []:
-                      out.add((n, line))
-              return out
-
-          def line_set_executable(data):
-              out = set()
-              for path, fd in data.get('files', {}).items():
-                  n = norm_path(path)
-                  exec_ = fd.get('executed_lines', []) or []
-                  miss_ = fd.get('missing_lines', []) or []
-                  for line in exec_ + miss_:
-                      out.add((n, line))
-              return out
-
-          # Threshold: source of truth is pyproject.toml.
-          full_threshold = 95.0
-          try:
-              data = tomllib.loads(pathlib.Path('pyproject.toml').read_text())
-              full_threshold = float(
-                  data['tool']['coverage']['report']['fail_under']
-              )
-          except Exception as exc:
-              print(f'WARN: could not read fail_under from pyproject.toml: {exc}')
-
-          # Unit-tier coverage from this PR.
-          u_pct, u_covered, u_total = read_totals('coverage.json')
-          u_data = {}
-          if pathlib.Path('coverage.json').exists():
-              try:
-                  u_data = json.loads(pathlib.Path('coverage.json').read_text())
-              except Exception:
-                  pass
-
-          # Nightly full-suite coverage.
-          n_path = pathlib.Path('nightly-coverage/coverage.json')
-          n_pct, n_covered, n_total = read_totals(n_path)
-          n_data = {}
-          if n_path.exists():
-              try:
-                  n_data = json.loads(n_path.read_text())
-              except Exception:
-                  pass
-
-          # Staleness check.
-          ts_path = pathlib.Path('nightly-coverage/nightly-timestamp.txt')
-          stale = False
-          stale_hours = None
-          if ts_path.exists():
-              try:
-                  ts_str = ts_path.read_text().strip().replace('Z', '+00:00')
-                  ts = datetime.fromisoformat(ts_str)
-                  age = datetime.now(timezone.utc) - ts
-                  stale_hours = age.total_seconds() / 3600.0
-                  stale = stale_hours > STALE_HOURS
-              except Exception:
-                  pass
-
-          missing = os.environ.get('NIGHTLY_MISSING', 'false') == 'true'
-          missing = missing or not n_data
-
-          # Union estimate.
-          est_pct = None
-          est_covered = 0
-          est_total = 0
-          if u_data.get('files') and n_data.get('files'):
-              union_exec = line_set_executed(u_data) | line_set_executed(n_data)
-              union_all = line_set_executable(u_data) | line_set_executable(n_data)
-              if union_all:
-                  est_covered = len(union_exec)
-                  est_total = len(union_all)
-                  est_pct = min(100.0, 100.0 * est_covered / est_total)
-
-          # Status: ok / warn / fail relative to full threshold + grace.
-          status = 'ok'
-          drop = 0.0
-          if est_pct is not None:
-              drop = full_threshold - est_pct
-              if drop > GRACE_PERIOD:
-                  status = 'fail'
-              elif drop > 0:
-                  status = 'warn'
-
-          summary_lines = [
-              '## Coverage estimate (PR vs nightly union)',
-              '',
-              f'- Unit (this PR): **{u_pct:.2f}%** ({u_covered}/{u_total} stmts)',
-          ]
-          if missing:
-              summary_lines.append('- Nightly artifact: **MISSING** (no successful nightly on main)')
-          else:
-              age_str = f' ({stale_hours:.1f}h old)' if stale_hours is not None else ''
-              tag = ' [STALE]' if stale else ''
-              summary_lines.append(
-                  f'- Nightly: **{n_pct:.2f}%** ({n_covered}/{n_total}){age_str}{tag}'
-              )
-          if est_pct is not None:
-              summary_lines.append(
-                  f'- Estimated union: **{est_pct:.2f}%** ({est_covered}/{est_total})'
-              )
-              summary_lines.append(f'- Threshold: {full_threshold:.2f}% | drop: {drop:+.2f}% | status: **{status}**')
-          else:
-              summary_lines.append('- Union estimate unavailable (one or both JSONs missing).')
-          if missing or stale:
-              summary_lines.append('')
-              summary_lines.append('> Nightly missing or stale; union number is informational only and does not gate this PR.')
-
-          summary_md = '\n'.join(summary_lines) + '\n'
-          print(summary_md)
-          step_summary = os.environ.get('GITHUB_STEP_SUMMARY')
-          if step_summary:
-              with open(step_summary, 'a') as fh:
-                  fh.write(summary_md)
-
-          out = os.environ.get('GITHUB_OUTPUT')
-          if out:
-              with open(out, 'a') as fh:
-                  fh.write(f'unit_pct={u_pct:.2f}\n')
-                  fh.write(f'nightly_pct={n_pct:.2f}\n')
-                  fh.write(f'est_pct={est_pct:.2f}\n' if est_pct is not None else 'est_pct=\n')
-                  fh.write(f'est_covered_union={est_covered}\n')
-                  fh.write(f'est_total_union={est_total}\n')
-                  fh.write(f'coverage_status={status}\n')
-                  fh.write(f'coverage_drop={drop:.2f}\n')
-                  fh.write(f'nightly_stale={"true" if stale else "false"}\n')
-                  fh.write(f'nightly_missing={"true" if missing else "false"}\n')
-
-          # Informational only on this branch; never fails the job.
-          # Future tightening can flip to sys.exit(1) when status == 'fail'.
-          PY

.github/workflows/nightly.yml

@@ -98,27 +98,7 @@ jobs:
           # FAILED list entirely if there are no other final messages,
           # making post-mortem on cancelled runs near-impossible.
           pytest -m "unit or smoke or integration or slow" -n auto -o "addopts=" -ra \
-            --cov=src/aragog --cov-report=term-missing --cov-report=xml \
-            --cov-report=json:coverage.json
-
-      - name: Stamp nightly artifact timestamp
-        if: ${{ !cancelled() }}
-        run: |
-          # ISO 8601 UTC; consumed by ci_tests.yml's staleness check (>48 h
-          # since this stamp triggers a warning, not a hard fail).
-          date -u +"%Y-%m-%dT%H:%M:%SZ" > nightly-timestamp.txt
-
-      - name: Upload nightly coverage artifact
-        if: ${{ !cancelled() }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: nightly-coverage
-          path: |
-            coverage.xml
-            coverage.json
-            nightly-timestamp.txt
-          retention-days: 14
-          if-no-files-found: warn
+            --cov=src/aragog --cov-report=term-missing --cov-report=xml
 
       - name: Upload coverage to Codecov
         if: ${{ !cancelled() }}