Repository navigation
build(frontend): upgrade Vite 8, React 19, react-router 7 and TypeScript 7 together #951
Workflow file for this run
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| name: CI | |
| on: | |
| push: | |
| branches: [main] | |
| pull_request: | |
| branches: [main] | |
| permissions: | |
| contents: read | |
| # Pushes to main queue so each merge gets a test result; PR updates cancel the | |
| # run for the superseded head. | |
| concurrency: | |
| group: ${{ github.workflow }}-${{ github.ref }} | |
| cancel-in-progress: ${{ github.event_name != 'push' }} | |
| jobs: | |
| # Restore the required relevance contexts removed by the baseline sync (#178). | |
| # A failed comparison fails its gate; a docs-only diff can skip expensive jobs. | |
| gate: | |
| name: Code relevance | |
| runs-on: ubuntu-24.04 | |
| timeout-minutes: 10 | |
| outputs: | |
| relevant: ${{ steps.push.outputs.relevant || steps.pr.outputs.relevant }} | |
| steps: | |
| # A push only starts this workflow on main (the branch filter above), so | |
| # the gate has nothing to decide: every push is relevant. | |
| - name: A push is already branch-filtered | |
| id: push | |
| if: github.event_name == 'push' | |
| run: echo 'relevant=true' >> "$GITHUB_OUTPUT" | |
| # Full history, because the three-dot diff names the merge base of the | |
| # PR's base tip and its merge commit, and a stacked PR's merge base sits | |
| # further back still. | |
| - name: Checkout the change | |
| if: github.event_name == 'pull_request' | |
| uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 | |
| with: | |
| persist-credentials: false # nothing here pushes | |
| fetch-depth: 0 | |
| # The diff logic is scripts/ci/classify-change.sh, shared with the occupancy | |
| # gate: a diff to a file, --no-renames -z, and a failed diff fails the gate | |
| # (an unreadable comparison must never read as "nothing relevant", because | |
| # a skipped job satisfies a required check). The base SHA travels through | |
| # env, not template interpolation into the script. Every pattern is quoted, | |
| # so the glob fires at match time, against the diff, and is not expanded | |
| # against the checkout the runner happens to be standing in. | |
| - name: Does the change touch anything the suite exercises? | |
| id: pr | |
| if: github.event_name == 'pull_request' | |
| env: | |
| BASE_SHA: ${{ github.event.pull_request.base.sha }} | |
| run: | | |
| bash "$GITHUB_WORKSPACE/scripts/ci/classify-change.sh" \ | |
| 'src/*' 'test/*' 'scripts/*' 'frontend/*' 'config/*' \ | |
| 'bench/*' 'data/*' 'proofs/*' 'R/*' 'renv/*' 'Project.toml' \ | |
| 'Manifest.toml' 'renv.lock' '.Rprofile' 'install.sh' 'install.jl' \ | |
| 'start.sh' 'docs/occupancy/*' 'docs/occupancy-2026-10.adoc' \ | |
| '.github/workflows/*' | |
| # The classifier's own fail-closed controls, so a change to it cannot | |
| # quietly turn a failed diff into a pass. | |
| - name: Check the classifier fails closed | |
| if: github.event_name == 'pull_request' | |
| run: bash scripts/tests/test-classify-change.sh | |
| occupancy_gate: | |
| name: Occupancy relevance | |
| runs-on: ubuntu-24.04 | |
| timeout-minutes: 10 | |
| outputs: | |
| relevant: ${{ steps.push.outputs.relevant || steps.pr.outputs.relevant }} | |
| steps: | |
| # All pushes to main are relevant; PRs use the path classification below. | |
| - name: A push to main is relevant | |
| id: push | |
| if: github.event_name == 'push' | |
| run: echo 'relevant=true' >> "$GITHUB_OUTPUT" | |
| # Full history, because the three-dot diff names the merge base of the | |
| # PR's base tip and its merge commit -- a shallow checkout does not have | |
| # both, and a stacked PR's merge base sits further back still. | |
| - name: Checkout the change | |
| if: github.event_name == 'pull_request' | |
| uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 | |
| with: | |
| persist-credentials: false # nothing here pushes | |
| fetch-depth: 0 | |
| # Same classifier as the code gate (scripts/ci/classify-change.sh). The base | |
| # SHA is GitHub-supplied, but it travels through env all the same: zizmor | |
| # flags template expressions interpolated into run scripts, and the | |
| # script is easier to run locally with the value in the environment. | |
| - name: Does the change touch the occupancy reading? | |
| id: pr | |
| if: github.event_name == 'pull_request' | |
| env: | |
| BASE_SHA: ${{ github.event.pull_request.base.sha }} | |
| run: | | |
| bash "$GITHUB_WORKSPACE/scripts/ci/classify-change.sh" \ | |
| 'src/core/memory_probe.jl' 'src/core/provenance.jl' 'src/pipeline/tools.jl' \ | |
| 'src/server/routes/pipeline.jl' 'test/occupancy_disagreement_test.jl' \ | |
| 'test/unit/test_occupancy_grade.jl' 'scripts/check-occupancy-grades.jl' \ | |
| 'scripts/lint-occupancy-readings.sh' 'docs/occupancy/*' \ | |
| 'docs/occupancy-2026-10.adoc' 'scripts/check-occupancy.sh' \ | |
| 'scripts/fetch-siblings.sh' 'scripts/install-ci-julia.sh' \ | |
| 'Project.toml' 'Manifest.toml' 'renv.lock' 'config/defaults/tool_versions.yml' \ | |
| '.github/workflows/*' | |
| test: | |
| # The name is a fixed string, it carries no version, and the job has NO matrix. | |
| # Both are required, and the first without the second is a trap that has already | |
| # been sprung here once. | |
| # | |
| # A branch ruleset matches a required status check by the DISPLAY NAME GitHub posts | |
| # for the job. A renamed check does not fail -- it is simply absent, and an absent | |
| # required check can never be satisfied, so every pull request deadlocks until an | |
| # admin bypasses the rule, triggered by nothing more alarming than editing a version | |
| # number. | |
| # | |
| # MEASURED on hyperpolymath/MetaManifold-WebUI#39 (2026-09-21): this job, named exactly `Julia tests` but still | |
| # carrying a 1x1 `strategy.matrix`, posted `Julia tests (1.12.5, ubuntu-24.04)`. | |
| # GitHub appends the matrix combination whenever the name does not already reference | |
| # the matrix, so a 1x1 matrix is still a matrix and the pins were still embedded in | |
| # the check name. The matrix was therefore removed rather than merely renamed around: | |
| # it selected exactly one combination and bought nothing. | |
| # | |
| # The two values it held are literals below, each keeping its own reasoning. | |
| # `test/unit/test_install_pins.jl` asserts, for EVERY job in this file, that the name | |
| # interpolates nothing AND that the job has no matrix -- so this cannot regress | |
| # silently. If a matrix is ever genuinely wanted here, the required context must move | |
| # to a matrix-free aggregator job first. | |
| name: Julia tests | |
| # R/Julia setup and integration tests are expensive, but may not hang for 6h. | |
| timeout-minutes: 90 | |
| needs: gate | |
| if: needs.gate.outputs.relevant == 'true' | |
| # Explicit, not ubuntu-latest: the R pin below names an apt package revision built | |
| # for 24.04, and a runner that silently rolled to the next LTS would take that pin | |
| # with it. `runs-on` cannot read `env`, so this is a literal. | |
| runs-on: ubuntu-24.04 | |
| # The repository's root .Rprofile sources renv/activate.R, so R started from | |
| # the checkout auto-activates renv and rewrites the library paths. renv is a | |
| # local-development convenience; CI installs into the system library and | |
| # reaches it through R_LIBS_SITE, so the autoloader is switched off here. | |
| # This variable covers the unprivileged R that Julia embeds through RCall. | |
| # It cannot cover the installs themselves, which run under sudo: sudo resets | |
| # the environment, so those commands pass --no-init-file instead. | |
| env: | |
| RENV_CONFIG_AUTOLOADER_ENABLED: "FALSE" | |
| # The unit files the early step runs. The full suite skips exactly these | |
| # (--exclude), so no file runs twice; the early step still fails first. | |
| VALIDATED_STATISTICS_TESTS: >- | |
| validated_statistics numeric_policy exact_summaries high_precision | |
| derived_analyses method_catalogue statistics_boundaries | |
| statistics_adversarial statistics_properties statistics_ui | |
| steps: | |
| - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 | |
| with: | |
| persist-credentials: false # nothing here pushes | |
| # The required "SonarCloud Code Analysis" check is the GitHub App's | |
| # automatic analysis -- nothing in this repository configures or runs it, | |
| # so its rules cannot be read here and its failure arrives only after the | |
| # push. This script reproduces the rule that failed the gate and the one | |
| # that came with it, needs no toolchain, and runs in about 0.1s: first, | |
| # before anything is installed, so the message beats the wait. | |
| - name: Check the Sonar reliability rules the gate enforces | |
| run: bash scripts/lint-sonar-reliability.sh | |
| - name: Set up Julia | |
| timeout-minutes: 10 | |
| run: bash scripts/install-ci-julia.sh | |
| - name: Parse Julia sources before dependency setup | |
| run: julia scripts/check-julia-syntax.jl | |
| # The gate once printed "Julia parse failed" and exited 0. This plants an | |
| # unparsable file and requires the gate to fail on it. | |
| - name: Check the syntax gate can fail | |
| run: bash scripts/tests/test-check-julia-syntax.sh | |
| # Every external version CI installs is read from the committed pin file, so CI | |
| # and a developer's machine cannot drift apart. yq is already on the runner, so | |
| # no Julia (and no package install) is needed just to read a YAML file. A pin | |
| # that is missing or null fails the step here instead of exporting an empty | |
| # value that a later step would install around. | |
| - name: Read pinned versions | |
| run: | | |
| set -euo pipefail | |
| pins=config/defaults/tool_versions.yml | |
| pin() { | |
| local value | |
| value="$(yq -r "$1" "$pins")" | |
| if [[ -z "$value" || "$value" == null ]]; then | |
| echo "::error::no value for $1 in $pins" >&2 | |
| return 1 | |
| fi | |
| printf '%s' "$value" | |
| } | |
| julia_version="$(pin '.runtimes.julia.version')" | |
| r_apt_version="$(pin '.runtimes.r.apt_version')" | |
| bun_version="$(pin '.toolchain.bun.version')" | |
| cutadapt_version="$(pin '.tools.cutadapt.version')" | |
| multiqc_version="$(pin '.tools.multiqc.version')" | |
| fastqc_url="$(pin '.tools.fastqc.archives.any.url')" | |
| fastqc_sha256="$(pin '.tools.fastqc.archives.any.sha256')" | |
| vsearch_version="$(pin '.tools.vsearch.version')" | |
| vsearch_url="$(pin '.tools.vsearch.archives."linux-x86_64".url')" | |
| vsearch_sha256="$(pin '.tools.vsearch.archives."linux-x86_64".sha256')" | |
| swarm_version="$(pin '.tools.swarm.version')" | |
| swarm_url="$(pin '.tools.swarm.archives."linux-x86_64".url')" | |
| swarm_sha256="$(pin '.tools.swarm.archives."linux-x86_64".sha256')" | |
| { | |
| echo "JULIA_VERSION=$julia_version" | |
| echo "R_APT_VERSION=$r_apt_version" | |
| echo "BUN_VERSION=$bun_version" | |
| echo "CUTADAPT_SPEC=cutadapt==$cutadapt_version" | |
| echo "MULTIQC_SPEC=multiqc==$multiqc_version" | |
| echo "FASTQC_URL=$fastqc_url" | |
| echo "FASTQC_SHA256=$fastqc_sha256" | |
| echo "VSEARCH_VERSION=$vsearch_version" | |
| echo "VSEARCH_URL=$vsearch_url" | |
| echo "VSEARCH_SHA256=$vsearch_sha256" | |
| echo "SWARM_VERSION=$swarm_version" | |
| echo "SWARM_URL=$swarm_url" | |
| echo "SWARM_SHA256=$swarm_sha256" | |
| } >> "$GITHUB_ENV" | |
| # Bun and the frontend need nothing from R or Julia, so they run first: a | |
| # broken frontend fails in about a minute, not after the R and Julia setup. | |
| - name: Set up Bun | |
| uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2.2.0 | |
| with: | |
| bun-version: ${{ env.BUN_VERSION }} | |
| - name: Build frontend | |
| working-directory: frontend | |
| timeout-minutes: 10 | |
| run: | | |
| bun install --frozen-lockfile --ignore-scripts | |
| bun run build | |
| - name: Audit frontend dependencies | |
| working-directory: frontend | |
| # Moderate advisories remain visible in `bun audit`; upgrading Router | |
| # across a major version needs a separate routing/SSR review. | |
| run: bun audit --audit-level high | |
| - name: Frontend unit tests | |
| working-directory: frontend | |
| run: bun run test | |
| # Packages, artifacts and the precompiled caches. The compiled caches are | |
| # valid only for the Julia that wrote them, and RCall's image is built | |
| # against the installed R, so the key names the Julia pin, the R apt pin | |
| # and the Manifest. The job's own name is in the key so the standards job | |
| # does not race this one to save the same entry. | |
| - name: Cache Julia packages and compiled caches | |
| uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0 | |
| with: | |
| path: | | |
| ~/.julia/artifacts | |
| ~/.julia/packages | |
| ~/.julia/registries | |
| ~/.julia/compiled | |
| key: julia-test-${{ runner.os }}-J${{ env.JULIA_VERSION }}-R${{ env.R_APT_VERSION }}-${{ hashFiles('Manifest.toml') }} | |
| # R + required packages (needed by RCall) | |
| # Install R directly via apt to avoid r-lib/actions/setup-r mangling | |
| # R_HOME and stripping default packages (utils, methods, stats, etc.) | |
| # The version is pinned to the apt revision named in the pin file, which tracks | |
| # R.Version in renv.lock; CRAN's Ubuntu repository retains older revisions, so | |
| # this resolves rather than merely requesting the newest. | |
| - name: Set up R | |
| timeout-minutes: 10 | |
| run: bash scripts/ci/install-r-runtime.sh full | |
| # The R packages are restored from renv.lock, the same pin a developer restores | |
| # from, rather than resolved against whatever the repositories serve that day. | |
| # Asking for a bare package name pins nothing: a Bioconductor release is frozen, | |
| # so dada2 and its kin held still, but CRAN publishes only its newest revision, | |
| # so vegan silently moved off the pinned 2.7-3 and test_provenance caught the | |
| # drift. Restoring into .Library keeps the system library that the RCall steps | |
| # and R_LIBS_SITE below expect, and renv is invoked explicitly here rather than | |
| # left to activate itself. --no-init-file stops R sourcing the repository's | |
| # .Rprofile, and with it the renv autoloader, which would otherwise rebind | |
| # .Library to its own sandbox under root's cache; the flag is used rather than | |
| # the environment variable above because sudo resets the environment first. | |
| # | |
| # renv's package cache persists across runs, so a restore that fails partway | |
| # resumes from the packages it already built. The cache sits outside ~ because | |
| # the restore runs as root. The run id makes each key unique so every attempt | |
| # saves its progress; restore-keys picks the newest match. | |
| - name: Restore the renv cache | |
| uses: actions/cache/restore@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0 | |
| with: | |
| path: /opt/renv-cache | |
| key: renv-${{ runner.os }}-R${{ env.R_APT_VERSION }}-${{ hashFiles('renv.lock') }}-${{ github.run_id }} | |
| restore-keys: | | |
| renv-${{ runner.os }}-R${{ env.R_APT_VERSION }}-${{ hashFiles('renv.lock') }}- | |
| renv-${{ runner.os }}-R${{ env.R_APT_VERSION }}- | |
| # SHA-512 of the cache contents before and after the install, so the save below | |
| # is skipped when this run added nothing (the key is unique per run, so an | |
| # unchanged cache would otherwise be uploaded again for no benefit). | |
| - name: Hash the renv cache before the install | |
| id: renv_before | |
| run: | | |
| sudo mkdir -p /opt/renv-cache | |
| echo "hash=$(sudo find /opt/renv-cache -type f -print0 | LC_ALL=C sort -z | sudo xargs -0 -r sha512sum | sha512sum | cut -d" " -f1)" >> "$GITHUB_OUTPUT" | |
| # R_CLI_DYNAMIC and TERM make renv print progress one line at a time in the log. | |
| - name: Install R packages | |
| timeout-minutes: 25 | |
| env: | |
| RENV_PATHS_CACHE: /opt/renv-cache | |
| run: | | |
| sudo mkdir -p "$RENV_PATHS_CACHE" | |
| sudo chmod 777 "$RENV_PATHS_CACHE" | |
| sudo env R_CLI_DYNAMIC=false TERM=dumb Rscript --no-init-file -e 'install.packages(c("renv", "BiocManager"), repos="https://cloud.r-project.org", lib=.Library)' | |
| sudo env RENV_PATHS_CACHE="$RENV_PATHS_CACHE" R_CLI_DYNAMIC=false TERM=dumb Rscript --no-init-file -e 'renv::restore(project=".", library=.Library, prompt=FALSE)' | |
| Rscript --no-init-file -e 'for (pkg in c("dada2","Biostrings","ShortRead","vegan","MASS","zCompositions","glmGamPoi","MGLM")) if (!require(pkg,character.only=TRUE,quietly=TRUE)) stop(pkg, " failed to install")' | |
| - name: Check DADA2 CSV assembly | |
| run: Rscript --vanilla test/unit/test_dada2_tables.R | |
| - name: Check null-calibration CSV handling | |
| run: Rscript --vanilla test/unit/test_null_calibration_csv.R | |
| - name: Check null-calibration failure annotations | |
| run: julia --startup-file=no scripts/tests/test_null_calibration_failures.jl | |
| # Saved on failure too, since the packages built before a failure are the ones | |
| # the next attempt should reuse. Root writes the cache, so it is made readable first. | |
| - name: Make the renv cache readable | |
| if: always() | |
| run: sudo chmod -R a+rX /opt/renv-cache || true | |
| - name: Hash the renv cache after the install | |
| id: renv_after | |
| if: always() | |
| run: | | |
| echo "hash=$(sudo find /opt/renv-cache -type f -print0 | LC_ALL=C sort -z | sudo xargs -0 -r sha512sum | sha512sum | cut -d" " -f1)" >> "$GITHUB_OUTPUT" | |
| - name: Save the renv cache | |
| if: always() && steps.renv_after.outputs.hash != steps.renv_before.outputs.hash | |
| uses: actions/cache/save@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0 | |
| with: | |
| path: /opt/renv-cache | |
| key: renv-${{ runner.os }}-R${{ env.R_APT_VERSION }}-${{ hashFiles('renv.lock') }}-${{ github.run_id }} | |
| - name: Install cutadapt | |
| timeout-minutes: 10 | |
| run: pip install "$CUTADAPT_SPEC" | |
| # The one tool CI does not pin. Ubuntu ships no versioned cd-hit revision worth | |
| # naming, and 24.04 is frozen, so its cd-hit does not move under us; the version | |
| # that arrives is recorded at preflight, where a discrepancy is visible. | |
| - name: Install cd-hit | |
| timeout-minutes: 5 | |
| run: sudo apt-get install -y cd-hit | |
| # Downloaded against the pinned URL and refused unless it hashes to the pinned | |
| # SHA256, so CI runs the same bytes install.jl puts on a developer's machine. | |
| - name: Install vsearch | |
| timeout-minutes: 5 | |
| run: | | |
| source scripts/ci/fetch_pinned.sh | |
| fetch_pinned "$VSEARCH_URL" vsearch.tar.gz | |
| echo "$VSEARCH_SHA256 vsearch.tar.gz" | sha256sum -c - | |
| tar xzf vsearch.tar.gz --warning=no-unknown-keyword | |
| sudo mv "vsearch-$VSEARCH_VERSION-linux-x86_64/bin/vsearch" /usr/local/bin/vsearch | |
| rm -rf vsearch.tar.gz "vsearch-$VSEARCH_VERSION-linux-x86_64" | |
| vsearch --version | |
| - name: Install swarm | |
| timeout-minutes: 5 | |
| run: | | |
| source scripts/ci/fetch_pinned.sh | |
| fetch_pinned "$SWARM_URL" swarm.tar.gz | |
| echo "$SWARM_SHA256 swarm.tar.gz" | sha256sum -c - | |
| tar xzf swarm.tar.gz --warning=no-unknown-keyword | |
| sudo mv "swarm-$SWARM_VERSION-linux-x86_64/bin/swarm" /usr/local/bin/swarm | |
| rm -rf swarm.tar.gz "swarm-$SWARM_VERSION-linux-x86_64" | |
| swarm --version | |
| - name: Install multiqc | |
| timeout-minutes: 10 | |
| run: pip install "$MULTIQC_SPEC" | |
| # FastQC ships as a Java launcher script; `fastqc --version` checks that Java | |
| # is on PATH as well. | |
| - name: Install fastqc | |
| timeout-minutes: 5 | |
| run: | | |
| source scripts/ci/fetch_pinned.sh | |
| fetch_pinned "$FASTQC_URL" fastqc.zip | |
| echo "$FASTQC_SHA256 fastqc.zip" | sha256sum -c - | |
| sudo unzip -q -d /opt fastqc.zip | |
| rm -f fastqc.zip | |
| sudo chmod +x /opt/FastQC/fastqc | |
| sudo ln -sf /opt/FastQC/fastqc /usr/local/bin/fastqc | |
| fastqc --version | |
| # No precompile here: RCall is rebuilt below and that invalidates its image | |
| # and everything that loads it, so precompiling now would be done twice. | |
| - name: Instantiate Julia project | |
| env: | |
| JULIA_PKG_PRECOMPILE_AUTO: "0" | |
| run: julia --project=. -e 'import Pkg; Pkg.instantiate()' | |
| - name: Download PR2 databases | |
| timeout-minutes: 10 | |
| run: julia --project=. config/ci/download_databases.jl | |
| - name: Rebuild RCall against installed R | |
| run: julia --project=. -e 'import Pkg; Pkg.build("RCall")' | |
| # Explicit, so a precompile failure (an RCall image that does not match the | |
| # installed R, for one) fails here with its own error and not later as a | |
| # slow load inside the test run. | |
| - name: Precompile Julia project | |
| run: julia --project=. -e 'import Pkg; Pkg.precompile()' | |
| - name: Verify R packages visible from RCall | |
| run: | | |
| julia --project=. -e ' | |
| using RCall | |
| R"cat(.libPaths(), sep=\"\n\")" | |
| for pkg in ["dada2", "vegan", "tibble", "MASS", "zCompositions", "glmGamPoi", "MGLM"] | |
| R"if (!require($pkg, character.only=TRUE, quietly=TRUE)) stop($pkg, \" not found\")" | |
| end | |
| ' | |
| # The independent oracles are GNU bc (high precision, exact summaries) and awk | |
| # (ordination): none shares maths code with Julia. bc is installed explicitly, | |
| # and the step fails if a tool is missing, so a test cannot skip itself green. | |
| - name: Install the independent oracle tools | |
| timeout-minutes: 5 | |
| run: | | |
| sudo apt-get install -y --no-install-recommends bc jq | |
| command -v bc jq awk | |
| - name: Check independent high-precision references | |
| run: bash test/references/check_high_precision_references.sh --check test/unit/test_high_precision.jl | |
| # Same coverage flag as the full suite: the .cov files of both runs sit side by | |
| # side and the coverage step below merges them. | |
| - name: Run validated-statistics tests first | |
| env: | |
| R_LIBS_SITE: /usr/local/lib/R/site-library:/usr/lib/R/site-library:/usr/lib/R/library | |
| TEST_TIMING_TITLE: Validated-statistics tests (early step) | |
| shell: bash | |
| run: | | |
| set +e | |
| # The list is word-split on purpose: each name is a separate argument. | |
| # shellcheck disable=SC2086 | |
| julia --project=. -t2 --code-coverage=@ test/runtests.jl $VALIDATED_STATISTICS_TESTS 2>&1 | tee /tmp/validated-statistics-tests.log | |
| # Preserve both exits immediately: a successful Julia run must not | |
| # hide a failed log write (e.g. a full runner filesystem). | |
| statuses=("${PIPESTATUS[@]}") | |
| status="${statuses[0]}" | |
| if [ "$status" -eq 0 ]; then status="${statuses[1]}"; fi | |
| if [ "$status" -ne 0 ]; then | |
| enc() { head -c 3000 | sed -e 's/%/%25/g' -e 's/\r/%0D/g' | awk '{printf "%s%%0A", $0}'; } | |
| # One annotation cannot hold a failing run, and a tail hides every | |
| # failure but the last one. Publish a digest of all failing | |
| # assertions first - the testset, the expression and the evaluated | |
| # values are what identify the bug - then the end of the log. | |
| # `set +e` above is deliberate: diagnostic helpers may find no | |
| # matches, and only the captured test status controls this step. | |
| # One annotation cannot hold a failing run, and a tail hides every | |
| # failure but the last one. Pair each location with its assertion, | |
| # cut long lines (an evaluated HTML page is useless in a digest), | |
| # then publish the first few chunks. | |
| # Print each failure's location and the lines that explain it: the | |
| # expression and evaluated value for an assertion, the exception for | |
| # an error. Long lines are cut because an evaluated HTML page would | |
| # otherwise fill the whole digest. | |
| awk ' | |
| /Test Failed at / { print; remaining = 2; next } | |
| /Error During Test at / { print; remaining = 4; next } | |
| /statistics UI request failed/ { print; remaining = 6; next } | |
| remaining > 0 { print; remaining-- } | |
| ' /tmp/validated-statistics-tests.log | | |
| cut -c1-260 > /tmp/validated-statistics-failures.log | |
| rm -f /tmp/validated-statistics-digest-* | |
| split -b 3800 /tmp/validated-statistics-failures.log /tmp/validated-statistics-digest- | |
| index=0 | |
| for chunk in /tmp/validated-statistics-digest-*; do | |
| [[ -e "$chunk" ]] || continue | |
| index=$((index + 1)) | |
| [[ "$index" -le 8 ]] || break | |
| echo "::error title=Validated-statistics failure digest $index::$(enc < "$chunk")" | |
| done | |
| echo "::error title=Validated-statistics log tail::$(tail -c 3000 /tmp/validated-statistics-tests.log | enc)" | |
| fi | |
| exit "$status" | |
| - name: Run tests | |
| env: | |
| OCCUPANCY_RESULTS: ${{ runner.temp }}/occupancy-results.yml | |
| CI_SKIP_TAXONOMY: "1" | |
| TEST_TIMING_TITLE: Full suite (less the early step's files) | |
| R_LIBS_SITE: /usr/local/lib/R/site-library:/usr/lib/R/site-library:/usr/lib/R/library | |
| # A failure also posts annotations, which the checks API serves without the full | |
| # log. Annotations are capped at 4096 bytes, so each failing assertion gets its own | |
| # (up to 8), followed by the summary rows that report a failure or an error. | |
| shell: bash | |
| run: | | |
| command -v vsearch # The full suite must run the occupancy experiment, not skip it. | |
| set +e | |
| julia --project=. -t 2 --code-coverage=@ test/runtests.jl --exclude="${VALIDATED_STATISTICS_TESTS// /,}" --integration --server 2>&1 | tee /tmp/julia-tests.log | |
| # Preserve both exits immediately: a successful Julia run must not | |
| # hide a failed log write (e.g. a full runner filesystem). | |
| statuses=("${PIPESTATUS[@]}") | |
| status="${statuses[0]}" | |
| if [ "$status" -eq 0 ]; then status="${statuses[1]}"; fi | |
| if [ "$status" -ne 0 ]; then | |
| enc() { head -c 3500 | sed -e 's/%/%25/g' -e 's/\r/%0D/g' | awk '{printf "%s%%0A", $0}'; } | |
| awk ' | |
| /Test Summary:/ { left = 0 } | |
| /(Test Failed at|Error During Test at)/ || (left == 0 && /Got exception outside of a @test/) { n++; left = 60 } | |
| left > 0 { print > ("/tmp/julia-failure-" n ".txt"); left-- } | |
| ' /tmp/julia-tests.log | |
| shown=0 | |
| for f in $(ls /tmp/julia-failure-*.txt 2>/dev/null | sort -t- -k3 -n); do | |
| shown=$((shown + 1)) | |
| [ "$shown" -gt 8 ] && break | |
| echo "::error title=Julia test failure ${shown}::$(enc < "$f")" | |
| done | |
| awk ' | |
| /Test Summary:/ { print; p = index($0, "Pass"); pe = (p ? p + 3 : 0); t = index($0, "Total"); next } | |
| pe && t && index($0, "|") && substr($0, pe + 1, t - pe - 1) ~ /[0-9]/ { print; next } | |
| /ERROR:|Some tests did not pass/ { print } | |
| ' /tmp/julia-tests.log | tail -n 60 > /tmp/julia-tests-summary.txt | |
| echo "::error title=Julia tests failed (summary)::$(enc < /tmp/julia-tests-summary.txt)" | |
| if [ "$shown" -eq 0 ]; then | |
| echo "::error title=Julia tests failed (tail)::$(tail -c 3500 /tmp/julia-tests.log | enc)" | |
| fi | |
| fi | |
| exit "$status" | |
| - name: Benchmark validated statistics | |
| run: julia --project=. -t2 bench/validated_statistics.jl --output "$RUNNER_TEMP/validated-statistics-benchmark.json" | |
| - name: Retain validated-statistics benchmark | |
| if: always() | |
| uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 | |
| with: | |
| name: validated-statistics-benchmark | |
| path: ${{ runner.temp }}/validated-statistics-benchmark.json | |
| if-no-files-found: ignore | |
| retention-days: 30 | |
| - name: Validate measured occupancy grades | |
| run: | | |
| julia --project=. scripts/check-occupancy-grades.jl "$RUNNER_TEMP/occupancy-results.yml" | |
| bash scripts/lint-occupancy-readings.sh | |
| # Both test runs write .cov files named for their process id. Fewer than two | |
| # processes means one run's coverage never reached this step. | |
| - name: Process coverage | |
| run: | | |
| find src -name '*.cov' | sed -E 's/.*\.([0-9]+)\.cov$/\1/' | sort -u > "$RUNNER_TEMP/coverage-pids" | |
| echo "coverage files: $(find src -name '*.cov' | wc -l); processes that wrote them: $(wc -l < "$RUNNER_TEMP/coverage-pids")" | |
| if [ "$(wc -l < "$RUNNER_TEMP/coverage-pids")" -lt 2 ]; then | |
| echo "::error::coverage from the early step or the full suite is missing" | |
| exit 1 | |
| fi | |
| julia scripts/process-ci-coverage.jl | |
| - name: Upload coverage to Codecov | |
| uses: codecov/codecov-action@303a32d7a59b442fa8d48b6a1cc6825c09c847a5 # v7.1.1 | |
| with: | |
| files: lcov.info | |
| token: ${{ secrets.CODECOV_TOKEN }} | |
| slug: JoshuaJewell/MetaManifold-WebUI | |
| fail_ci_if_error: false | |
| # Issue #1 evidence that cannot live in the Julia suite: the two standards | |
| # scripts run from the pinned standards commit, a seeded simulation study with | |
| # pre-declared tolerances, and a mutation campaign that proves the focused | |
| # tests can fail. The tools are pinned by commit and by SHA-256; a missing | |
| # tool is exit 2 in both standards scripts, so this job cannot pass by skipping. | |
| standards: | |
| name: Statistics standards and evidence | |
| needs: gate | |
| if: needs.gate.outputs.relevant == 'true' | |
| runs-on: ubuntu-24.04 | |
| timeout-minutes: 60 | |
| steps: | |
| - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 | |
| with: | |
| persist-credentials: false # nothing here pushes | |
| - name: Set up Julia | |
| timeout-minutes: 10 | |
| run: bash scripts/install-ci-julia.sh | |
| - name: Read pinned runtime versions | |
| run: | | |
| { | |
| echo "JULIA_VERSION=$(yq -r '.runtimes.julia.version' config/defaults/tool_versions.yml)" | |
| echo "R_APT_VERSION=$(yq -r '.runtimes.r.apt_version' config/defaults/tool_versions.yml)" | |
| } >> "$GITHUB_ENV" | |
| # Same reasoning as the Julia tests job: the compiled caches depend on the | |
| # Julia pin and on the R that RCall was built against. | |
| - name: Cache Julia packages and compiled caches | |
| uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0 | |
| with: | |
| path: | | |
| ~/.julia/artifacts | |
| ~/.julia/packages | |
| ~/.julia/registries | |
| ~/.julia/compiled | |
| key: julia-standards-${{ runner.os }}-J${{ env.JULIA_VERSION }}-R${{ env.R_APT_VERSION }}-${{ hashFiles('Manifest.toml') }} | |
| # The versions, the HTTPS restriction and the exact-commit fetches live in | |
| # the script (one reviewed place), not interpolated into this workflow. | |
| - name: Install pinned standards tools | |
| timeout-minutes: 10 | |
| run: bash scripts/ci/fetch-statistics-tools.sh | |
| # MetaManifold includes RCall at module load, and RCall's build step needs | |
| # an R installation even though this job runs no R code. The version comes | |
| # from the committed pin file, not from whatever apt calls current. | |
| - name: Install the pinned R runtime | |
| timeout-minutes: 10 | |
| run: | | |
| R_APT_VERSION="$(yq -r '.runtimes.r.apt_version' config/defaults/tool_versions.yml)" | |
| R_APT_VERSION="$R_APT_VERSION" bash scripts/ci/install-r-runtime.sh core | |
| # Null-calibration uncertainty is independently rechecked with base R, | |
| # the same pinned runtime. This catches source/CLI regressions in the | |
| # new replacement for the banned Python benchmark utility. | |
| - name: Dataset-clustered calibration test (base R) | |
| run: Rscript --vanilla bench/null_calibration/test_cluster_check.R | |
| # The evidence scripts are ordinary project code: they load JSON3 and the | |
| # statistics modules, so the environment must be instantiated after R. | |
| - name: Instantiate Julia project | |
| id: instantiate | |
| env: | |
| JULIA_PKG_PRECOMPILE_AUTO: "0" | |
| run: julia --project=. -e 'import Pkg; Pkg.instantiate()' | |
| # Explicit, so a precompile failure fails here and names itself. | |
| - name: Precompile Julia project | |
| id: precompile | |
| run: julia --project=. -e 'import Pkg; Pkg.precompile()' | |
| # YAML-POLICY Y-3 / D307. --check exits 1 on drift and 2 when yq is | |
| # missing or the file does not parse, so neither outcome can read as a pass. | |
| - name: KYAML formatting gate | |
| run: bash "$RUNNER_TEMP/standards/scripts/kyaml-format.sh" --check config/defaults/validated_statistics.kyaml | |
| # JSON-POLICY J-1 / D306. Enforcement is scoped to the documents this | |
| # branch is responsible for; the repository-wide pass is report-only | |
| # because the policy calls unconverted files migration backlog, not a | |
| # violation of a new change. Both outputs are retained. | |
| - name: I-JSON/JCS gate | |
| env: | |
| IJSON_JCS: ${{ runner.temp }}/ijson-jcs/target/release/ijson-jcs | |
| run: | | |
| set -euo pipefail | |
| bash "$RUNNER_TEMP/standards/scripts/check-ijson-jcs.sh" --enforce \ | |
| frontend/public/config.json | |
| # test/fixtures/jcs_oracle.jsonl is a vector file: its inputs are | |
| # deliberately NOT canonical and its expected outputs are the | |
| # canonical form, so enforcing on it would be a category error. | |
| bash "$RUNNER_TEMP/standards/scripts/check-ijson-jcs.sh" . \ | |
| | tee "$RUNNER_TEMP/ijson-jcs-report.txt" | |
| # A failing study must say why in the checks API, not only in a log the | |
| # reviewer cannot open from every client. Annotations are the same channel | |
| # the Julia suite uses for failing assertions. | |
| # run-with-log.sh keeps the command's own exit status and annotates a | |
| # failure with the tail of its log. The workflow carries no copy of that | |
| # logic, so the exit-preserving pipeline stays a single tested construct. | |
| - name: Seeded simulation study | |
| env: | |
| RUN_LOG_TITLE: Seeded simulation study | |
| run: | | |
| bash scripts/ci/run-with-log.sh "$RUNNER_TEMP/simulation.log" -- \ | |
| julia --project=. -t2 scripts/statistics/simulation_study.jl \ | |
| --output "$RUNNER_TEMP/statistics-simulation-report.json" | |
| # Six mutants are defined; four keep the campaign inside the job timeout. | |
| # The script restores every file and re-verifies its digest, so a failed | |
| # run cannot leave a planted defect behind. | |
| # | |
| # always(), but only once the environment exists. Run unconditionally, the | |
| # campaign outlived an earlier failure and died with "Package JSON3 is | |
| # required but does not seem to be installed: Run Pkg.instantiate()" — a | |
| # second failure that named neither the real cause nor a mutable file, and | |
| # masked the tool-install failure above it in the checks API. Gating on the | |
| # instantiate step keeps the campaign's real value (it still runs when the | |
| # study, the gates or an earlier evidence step failed) without inventing a | |
| # failure that cannot distinguish a broken mutant from an absent project. | |
| - name: Mutation campaign | |
| if: always() && steps.instantiate.outcome == 'success' && steps.precompile.outcome == 'success' | |
| env: | |
| RUN_LOG_TITLE: Mutation campaign | |
| run: | | |
| bash scripts/ci/run-with-log.sh "$RUNNER_TEMP/mutation.log" -- \ | |
| julia --project=. -t2 scripts/statistics/mutation_check.jl --max-mutants 4 \ | |
| --output "$RUNNER_TEMP/statistics-mutation-report.json" \ | |
| --keep-logs "$RUNNER_TEMP/mutation-logs" | |
| - name: Retain statistics evidence | |
| if: always() | |
| uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 | |
| with: | |
| name: statistics-standards | |
| path: | | |
| ${{ runner.temp }}/statistics-simulation-report.json | |
| ${{ runner.temp }}/statistics-mutation-report.json | |
| ${{ runner.temp }}/ijson-jcs-report.txt | |
| ${{ runner.temp }}/mutation-logs | |
| if-no-files-found: warn | |
| retention-days: 30 | |
| # Machine-checked proofs of the Benjamini-Hochberg adjustment and the TSS/RLE | |
| # scaling algebra (proofs/agda, proofs/agda/README.md). | |
| # Agda publishes no 2.6.4.3 binary, and agda-stdlib 2.1 requires Agda 2.6.4.x, | |
| # so the pair comes from Debian trixie, which packages exactly that pair with | |
| # pre-built library interfaces. The image is pinned by digest and the two | |
| # packages by revision, so a rebuild in the archive fails loudly here instead | |
| # of silently changing the checker. These pins live here rather than in | |
| # config/defaults/tool_versions.yml because no other job and no installer | |
| # reads them. | |
| agda: | |
| name: Agda proofs | |
| needs: gate | |
| if: needs.gate.outputs.relevant == 'true' | |
| runs-on: ubuntu-24.04 | |
| container: debian:trixie-20250929-slim@sha256:1caf1c703c8f7e15dcf2e7769b35000c764e6f50e4d7401c355fb0248f3ddfdb | |
| timeout-minutes: 30 | |
| env: | |
| DEBIAN_FRONTEND: noninteractive | |
| # The pins of this job, in one place. They are part of the input hash below, | |
| # so changing one re-runs the proofs; so does any change under proofs/. | |
| AGDA_BIN_VERSION: 2.6.4.3-1+b2 | |
| AGDA_STDLIB_VERSION: 2.1-4 | |
| AGDA_FLAGS: --safe --without-K --cubical-compatible | |
| AGDA_TARGET: MetaManifold/All.agda | |
| # The image of the container: above, the one literal that `container:` | |
| # cannot read from env. The hash step refuses to run if the two differ. | |
| AGDA_IMAGE: debian:trixie-20250929-slim@sha256:1caf1c703c8f7e15dcf2e7769b35000c764e6f50e4d7401c355fb0248f3ddfdb | |
| steps: | |
| - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 | |
| with: | |
| persist-credentials: false # nothing here pushes | |
| # A pass is memoised on its inputs: the proofs, the checker pins and the | |
| # invocation. Pull requests reuse a pass whose inputs are unchanged, which | |
| # is the usual case for a PR that does not touch proofs/ (a workflow-only or | |
| # script change is "relevant" but cannot change a proof). The step summary | |
| # always names the run reused. A push to main never reuses: it re-checks in | |
| # full, so the memo can only ever shorten a pull request, never main. | |
| - name: Hash the proof inputs | |
| id: inputs | |
| shell: bash | |
| run: | | |
| set -euo pipefail | |
| # A container job's steps cannot read the container image from the | |
| # context, so the image is a literal in env; it must be the one in use. | |
| # Only this job's container line counts: the occupancy job has its own. | |
| container="$(awk '/^ agda:/ { a = 1; next } a && /^ [a-z_]+:/ { a = 0 } a && /^ container:/ { sub(/^ container: */, ""); print; exit }' .github/workflows/ci.yml)" | |
| [ "$container" = "$AGDA_IMAGE" ] \ | |
| || { echo "ERROR: AGDA_IMAGE differs from the Agda job container" >&2; exit 1; } | |
| hash="$( { | |
| printf '%s\n' "$AGDA_IMAGE" "$AGDA_BIN_VERSION" "$AGDA_STDLIB_VERSION" "$AGDA_FLAGS" "$AGDA_TARGET" | |
| find proofs -type f -print0 | LC_ALL=C sort -z | xargs -0 sha256sum | |
| } | sha256sum | cut -d' ' -f1 )" | |
| echo "hash=$hash" >> "$GITHUB_OUTPUT" | |
| echo "Input hash: $hash" | |
| # lookup-only: nothing is downloaded, the matched key carries the run id. | |
| - name: Look for a reusable pass | |
| id: lookup | |
| if: github.event_name == 'pull_request' | |
| uses: actions/cache/restore@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0 | |
| with: | |
| lookup-only: true | |
| path: ${{ runner.temp }}/agda-pass-marker | |
| key: agda-pass-${{ steps.inputs.outputs.hash }}-none | |
| restore-keys: | | |
| agda-pass-${{ steps.inputs.outputs.hash }}- | |
| - name: Reuse the earlier pass | |
| id: reuse | |
| shell: bash | |
| if: github.event_name == 'pull_request' && steps.lookup.outputs.cache-matched-key != '' | |
| env: | |
| MATCHED: ${{ steps.lookup.outputs.cache-matched-key }} | |
| HASH: ${{ steps.inputs.outputs.hash }} | |
| REPO: ${{ github.repository }} | |
| run: | | |
| set -euo pipefail | |
| # The key ends in <run id>.<attempt>: a re-run of a run must not try to | |
| # save over the key its first attempt wrote. | |
| run_id="${MATCHED##*-}" | |
| run_id="${run_id%%.*}" | |
| [[ "$run_id" =~ ^[0-9]+$ ]] || { echo "ERROR: cannot read a run id from $MATCHED" >&2; exit 1; } | |
| msg="Reused pass from run $run_id for input hash $HASH" | |
| echo "$msg" | |
| { | |
| echo "### Agda proofs: reused pass" | |
| echo | |
| echo "$msg" | |
| echo | |
| echo "Earlier run: https://github.com/$REPO/actions/runs/$run_id" | |
| echo "The proofs, the checker pins and the invocation are unchanged, so the type-check was not repeated. A push to main always re-checks in full." | |
| } >> "$GITHUB_STEP_SUMMARY" | |
| echo "reused=true" >> "$GITHUB_OUTPUT" | |
| - name: Install Agda and the standard library | |
| if: steps.reuse.outputs.reused != 'true' | |
| timeout-minutes: 10 | |
| run: | | |
| apt-get update -qq | |
| apt-get install -y --no-install-recommends "agda-bin=$AGDA_BIN_VERSION" "agda-stdlib=$AGDA_STDLIB_VERSION" | |
| agda --version | grep -qx 'Agda version 2.6.4.3' | |
| grep -qx 'name: standard-library-2.1' /usr/share/agda-stdlib/standard-library.agda-lib | |
| # Runs before the type-check: --safe already refuses postulates, but the | |
| # audit also refuses holes, check-disabling pragmas and flags, and any | |
| # module that MetaManifold/All.agda does not import (an unimported module | |
| # is never type-checked at all). | |
| - name: Axiom audit | |
| if: steps.reuse.outputs.reused != 'true' | |
| run: bash proofs/tests/axiom-audit.sh | |
| # The invocation is the estate PROOF-POLICY §2.1 one, written out rather | |
| # than left to the .agda-lib flags. Agda prints its warnings with | |
| # Unicode, and under the image's default POSIX locale it then exits 42 | |
| # instead of reporting, so the locale is UTF-8. | |
| - name: Type-check | |
| if: steps.reuse.outputs.reused != 'true' | |
| env: | |
| AGDA_DIR: /tmp/agda-dir | |
| LC_ALL: C.UTF-8 | |
| run: | | |
| mkdir -p "$AGDA_DIR" | |
| echo /usr/share/agda-stdlib/standard-library.agda-lib > "$AGDA_DIR/libraries" | |
| cd proofs/agda | |
| # AGDA_FLAGS is word-split on purpose: each flag is its own argument. | |
| # shellcheck disable=SC2086 | |
| if ! agda $AGDA_FLAGS "$AGDA_TARGET" >/tmp/agda.log 2>&1; then | |
| cat /tmp/agda.log | |
| msg="$(awk 'NR > 1 { printf "%%0A" } { gsub(/%/, "%25"); printf "%s", $0 }' /tmp/agda.log | tail -c 3500)" | |
| echo "::error file=proofs/agda/MetaManifold/All.agda,title=Agda type-check failed::$msg" | |
| exit 1 | |
| fi | |
| cat /tmp/agda.log | |
| # Only a full pass leaves a marker, keyed on the inputs and the run id. | |
| # Pull requests and main both leave one; only pull requests read it. | |
| - name: Record the pass | |
| if: steps.reuse.outputs.reused != 'true' | |
| env: | |
| HASH: ${{ steps.inputs.outputs.hash }} | |
| RUN_ID: ${{ github.run_id }} | |
| MARKER: ${{ runner.temp }}/agda-pass-marker | |
| run: printf 'run=%s\nhash=%s\n' "$RUN_ID" "$HASH" > "$MARKER" | |
| - name: Save the pass marker | |
| if: steps.reuse.outputs.reused != 'true' | |
| uses: actions/cache/save@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0 | |
| with: | |
| path: ${{ runner.temp }}/agda-pass-marker | |
| key: agda-pass-${{ steps.inputs.outputs.hash }}-${{ github.run_id }}.${{ github.run_attempt }} | |
| occupancy: | |
| name: Occupancy typed peak | |
| needs: occupancy_gate | |
| if: needs.occupancy_gate.outputs.relevant == 'true' | |
| runs-on: ubuntu-24.04 | |
| container: debian:trixie-20250929-slim@sha256:1caf1c703c8f7e15dcf2e7769b35000c764e6f50e4d7401c355fb0248f3ddfdb | |
| timeout-minutes: 30 | |
| steps: | |
| - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 | |
| with: | |
| persist-credentials: false # nothing here pushes | |
| - name: Install proof tools | |
| timeout-minutes: 10 | |
| run: | | |
| apt-get update -qq | |
| apt-get install -y --no-install-recommends ca-certificates curl git agda-bin=2.6.4.3-1+b2 agda-stdlib=2.1-4 | |
| - name: Set up Julia | |
| timeout-minutes: 10 | |
| run: bash scripts/install-ci-julia.sh | |
| - name: Check Session IR and occupancy proofs | |
| run: bash scripts/check-occupancy.sh | |
| # The full suite already runs the actual two-thread vsearch experiment. This | |
| # required context reports that result, including the fresh grade validation, | |
| # instead of paying for a second Julia/R installation and repeating the run. | |
| disagreement: | |
| name: Occupancy disagreement test | |
| needs: [occupancy_gate, test] | |
| if: always() && needs.occupancy_gate.result == 'success' && needs.occupancy_gate.outputs.relevant == 'true' | |
| runs-on: ubuntu-24.04 | |
| timeout-minutes: 5 | |
| steps: | |
| - name: Require the executed experiment and grade validation to pass | |
| env: | |
| TEST_RESULT: ${{ needs.test.result }} | |
| run: | | |
| if [ "$TEST_RESULT" != success ]; then | |
| echo "ERROR: full suite, occupancy experiment or measured-grade validation did not pass ($TEST_RESULT)" >&2 | |
| exit 1 | |
| fi | |
| echo 'The full Julia suite passed, including the two-thread vsearch experiment and fresh empirical grade validation.' >> "$GITHUB_STEP_SUMMARY" | |
| # The account ruleset "Branch-Floor" requires a status check named exactly | |
| # `CI/gate`. The check context is this job's `name:`, so it must stay a fixed | |
| # string (no interpolation, no matrix). It waits for every other job in this | |
| # workflow and runs even when one fails, is skipped or is cancelled. | |
| # | |
| # A job may be `skipped` only where this workflow skips it by design: the | |
| # detector that governs it succeeded and reported `relevant == 'false'`. | |
| # test, standards and agda are governed by `gate`; occupancy and disagreement | |
| # by `occupancy_gate`. A job skipped while its detector failed, was cancelled | |
| # or was itself skipped fails this gate, as does any failure, cancellation or | |
| # missing/unknown result. Only `run:` shell is used: nothing here needs pinning. | |
| ci-status: | |
| name: CI/gate | |
| runs-on: ubuntu-24.04 | |
| timeout-minutes: 5 | |
| permissions: {} | |
| needs: [gate, occupancy_gate, test, standards, agda, occupancy, disagreement] | |
| if: always() | |
| steps: | |
| - name: Require every job to succeed, or to be skipped by design | |
| env: | |
| NEEDS_JSON: ${{ toJSON(needs) }} | |
| run: | | |
| set -euo pipefail | |
| summary="${GITHUB_STEP_SUMMARY:-/dev/null}" | |
| result() { local job="$1"; jq -r --arg j "$job" '.[$j].result // "missing"' <<< "$NEEDS_JSON"; } | |
| relevant() { local job="$1"; jq -r --arg j "$job" '.[$j].outputs.relevant // "missing"' <<< "$NEEDS_JSON"; } | |
| failures=0 | |
| total=0 | |
| { | |
| echo '### CI/gate' | |
| echo | |
| echo 'Each result below is the aggregate result of that job. This workflow has no matrix jobs.' | |
| echo | |
| echo '| job | result | expected | verdict |' | |
| echo '| --- | --- | --- | --- |' | |
| } >> "$summary" | |
| check() { | |
| local job="$1" expected="$2" actual verdict=ok | |
| actual="$(result "$job")" | |
| total=$((total + 1)) | |
| if [[ "$actual" != "$expected" ]]; then | |
| verdict=FAIL | |
| failures=$((failures + 1)) | |
| echo "::error::$job result is '$actual', expected '$expected'" | |
| fi | |
| printf '%-16s %-10s expected %-8s %s\n' "$job" "$actual" "$expected" "$verdict" | |
| echo "| $job | $actual | $expected | $verdict |" >> "$summary" | |
| } | |
| # What a detector-governed job must be: success when the detector | |
| # (itself successful) says the change is relevant, skipped when it | |
| # says it is not. Anything else, including a detector that did not | |
| # succeed or reported no usable output, expects success and so fails. | |
| expect_for() { | |
| local detector="$1" | |
| if [[ "$(result "$detector")" != success ]]; then echo success; return; fi | |
| case "$(relevant "$detector")" in | |
| true) echo success ;; | |
| false) echo skipped ;; | |
| *) echo success ;; | |
| esac | |
| } | |
| check gate success | |
| check occupancy_gate success | |
| for job in test standards agda; do check "$job" "$(expect_for gate)"; done | |
| for job in occupancy disagreement; do check "$job" "$(expect_for occupancy_gate)"; done | |
| if [[ "$failures" -ne 0 ]]; then | |
| echo "CI/gate FAILED: $failures of $total jobs not as expected." | tee -a "$summary" | |
| exit 1 | |
| fi | |
| echo "CI/gate passed: $total jobs checked; skipped only where the successful detector reported nothing relevant." | tee -a "$summary" |