# Rollcall: everything in one file > Rollcall scans Wayne State's apps and reports each one's PHP image, Laravel version, auth package and PROCTOR result, checked against the dates in CREED's policy. It keeps a snapshot per scan, so you can see drift and an EOL burn-down. The README and the Markdown twin of every page, joined. The index is https://rollcall.apps.wayne.edu/llms.txt. Written by Squire's agent-ready kit; do not edit. --- ## README Source: https://github.com/waynestate/rollcall/blob/HEAD/README.md ## Rollcall Checks: `composer ci` (the same command runs on GitLab and GitHub). > Every app answers "present". The ones on PHP 7.4 answer from the back row. Front page: [`site/index.html`](https://github.com/waynestate/rollcall/blob/HEAD/site/index.html). It is static, with no build step (see `site/README.md`). On Citadel, the raw-PHP deploy layer in [`deploy/`](https://github.com/waynestate/rollcall/blob/HEAD/deploy/) serves it: a Squire kit whose front controller puts `site/` behind HELMET's security headers. For local development, serve `site/` directly. Rollcall is the fleet scanner for the Wayne State application stack. For each app it records the PHP image, the lowest PHP its `composer.json` allows, the Laravel version, the auth package and its version, the PROCTOR result, and, when the app commits one, the result, Booster version and finish time of Booster's hop record (`booster-hop.json`). Then it looks up each version by date in CREED's `policy.json`. It keeps one snapshot per scan, so you can see drift and an EOL burn-down over time. It prunes old snapshots after the retention window (default 90 days; the newest one always stays). Rollcall enforces nothing. It never opens an issue, leaves a comment or deploys anything, and `scan` and `report` exit `0` whatever the fleet looks like (only `rollcall owners`, a check of the owners file, exits `1`). The public report has totals only: counts and progress, no app names, owners or rankings. The per-app list is internal. Like a good attendance sheet, it is for noticing who is missing, not for shaming them. ### Where it sits in the stack The parts of the Wayne State application stack, and their jobs. WELD is the Laravel starter app that has most of them installed: | Part | Job | |---|---| | WayneUI (project 0) | The interface layer: tokens, components, four consumer paths | | CREED | The standards and `policy.json`, the dates Rollcall reads | | PROCTOR | Measures one app against the policy; Rollcall reads its JSON report and never re-runs a rule | | SESAME | Protocol-neutral auth; Rollcall reports which auth package each app uses | | HELMET | Baseline runtime and its own optional `/metrics` | | Sourdough | Starters for every app shape | | Squire | The Citadel deploy kit; the layer that serves this repo's front page is one | | Parity | Citadel on your computer: its PHP image, its proxy and MySQL 5.6, so an app that works here works on Citadel (0.1.0; site: [parity.apps.wayne.edu](https://parity.apps.wayne.edu/)) | | Preflight | CI templates | | Pinstripe | The coding standard this repo includes for its Pint and PHPStan settings | | Booster | The upgrade tool; Rollcall reads its hop record (`booster-hop.json`) to see who is catching up | | Rollcall | The fleet census and EOL burn-down | | Drawbridge | The one OpenID Connect front door for the Citadel | | ADVISOR | The stack's read-only MCP server; Rollcall's module gives it three fleet tools | | WELD | The Laravel starter app with most of the stack installed | ### How it is built A framework-free core (`src/`) plus thin entry points that hold no rules: - `bin/rollcall`: the CLI (`scan`, `report`, `digest`, `owners`, `drift`, `advisories`, `prune`). One PHP command, so it works the same on Windows, macOS and Linux. - `public/index.php`: a raw-PHP front controller for `GET /metrics` and `GET /report.json`. - `rollcall_dashboard()`: the dashboard page for a raw PHP app, one call in a file you serve (see "The dashboard in a raw PHP app"). - `src/Laravel/`: a Laravel adapter with a dashboard page (the Blade view, or an Inertia page in your own layout), a `/metrics` route and `php artisan rollcall:scan` and `rollcall:prune`. - `resources/js/RollcallDashboard.vue`: the same dashboard as a Vue component, for an Inertia app's own page (see "The dashboard in an Inertia app (Vue)"). The Blade view and `rollcall_dashboard()` print the same renderer (`src/Dashboard/DashboardPage.php`) from the same report, so they cannot drift, and CI fails the Vue component on any difference from that renderer's markup. CREED's policy reader lives under `src/Creed/` (namespace `Waynestate\Rollcall\Creed`) as a generated copy, made by CREED's `bin/export.php`. CREED is on Packagist now, so the copy can become a `require` of `waynestate/creed`; until Rollcall switches, the copy stays. To refresh it, run `php /bin/export.php --namespace='Waynestate\Rollcall\Creed' --to=src/Creed` from a CREED checkout. `composer creed-copy:check` proves the copy has not drifted (it reads the checkout from `CREED_PATH`); a hand edit to `src/Creed/` fails that check. Weekly CREED copy refresh: a scheduled GitLab job (`creed-copy-refresh`, Mondays, an hour after CREED's policy robot) re-exports the copy from CREED main, rebuilds the versions table and docs, runs `composer creed-copy:check` and `composer ci`, and pushes to main only when both pass. A red run leaves main untouched. Details in MAINTAINING.md, "Refreshing the CREED copy". Data comes in through three interfaces. Each has a fixture adapter, so you can try everything without a live host: | Source | Interface | Adapters | |---|---|---| | Repositories (`composer.json`, `composer.lock`, `booster-hop.json`) | `RepositorySource` | a directory of fixtures; GitLab over PSR-18, tested against recorded responses | | Runtime image per app | `ImageSource` | a JSON export of the app list from any platform, or Citadel's own registrations export (which adds forced upgrade dates) | | PROCTOR result | `ProctorReportSource` | a directory of PROCTOR `--format=json` reports (the default); or, with `ROLLCALL_PROCTOR_SOURCE=gitlab`, each project's proctor job artifact in GitLab CI (see [docs/architecture.md](https://github.com/waynestate/rollcall/blob/HEAD/docs/architecture.md#where-proctor-results-come-from)) | Rollcall only reads from every source. It writes its own snapshot directory, and digest files only when `rollcall digest --out` asks for them. The decisions behind this shape (saved files over live calls, counts in public, one image source, the contract) are recorded in [DECISIONS.md](https://github.com/waynestate/rollcall/blob/HEAD/DECISIONS.md) and [ADR/](https://github.com/waynestate/rollcall/blob/HEAD/ADR/). ### Install ``` composer require waynestate/rollcall ``` Rollcall 1.2.0 is on Packagist. No extra repository needed. Requires PHP `^8.3`. The CLI is `vendor/bin/rollcall`. From 1.0 Rollcall follows SemVer against its contract ([`contract/`](https://github.com/waynestate/rollcall/blob/HEAD/contract/README.md)): inside 1.x the report, the stored snapshot and the image list may gain a field (a minor release) but never lose or retype one. Promoted to 1.0 with perfect attendance. ### Quick start This runs on the fixtures in the repo, so you need no network and no token. Run `composer install` once (or the Docker line under "Run the checks"), then the commands below. Linux and macOS (bash): ``` export ROLLCALL_POLICY_FILE=tests/fixtures/policy.json export ROLLCALL_REPOS_DIR=tests/fixtures/repos export ROLLCALL_IMAGES_FILE=tests/fixtures/images.json export ROLLCALL_PROCTOR_DIR=tests/fixtures/proctor export ROLLCALL_STORE_DIR=var/snapshots php bin/rollcall scan php bin/rollcall report ``` Windows (PowerShell, no bash or WSL needed): ``` $env:ROLLCALL_POLICY_FILE = "tests/fixtures/policy.json" $env:ROLLCALL_REPOS_DIR = "tests/fixtures/repos" $env:ROLLCALL_IMAGES_FILE = "tests/fixtures/images.json" $env:ROLLCALL_PROCTOR_DIR = "tests/fixtures/proctor" $env:ROLLCALL_STORE_DIR = "var/snapshots" php bin/rollcall scan php bin/rollcall report ``` `policy.json` is CREED's file; the copy under `tests/fixtures/` is a snapshot for tests. Use the released one in real runs. ### Commands ``` rollcall scan [--today=YYYY-MM-DD] [--prune[=DAYS]] rollcall report [--format=text|json|prometheus] [--internal] [--today=YYYY-MM-DD] rollcall digest [--owner=CONTACT] [--format=text|json] [--out=DIR] [--send] [--today=YYYY-MM-DD] rollcall owners [--format=text|json] rollcall drift --feed= [--component=php] [--today=YYYY-MM-DD] rollcall advisories --feed= [--today=YYYY-MM-DD] rollcall prune [--days=N] [--dry-run] [--today=YYYY-MM-DD] ``` - `scan` scans once and stores `/.json`. A second scan on the same day replaces it. A gap in one source (a missing report, a bad image tag) becomes a note on that app, and the scan carries on. A refused GitLab token stops the scan loudly instead of producing a flattering partial answer. `--prune[=DAYS]` deletes snapshots older than that many days after saving (default: `ROLLCALL_RETENTION_DAYS`, 90; 0 keeps everything). - `report` prints the latest snapshot against the policy as of today. `text` is a terminal table, `json` is the machine-readable form, `prometheus` is the metrics text (refused unless `ROLLCALL_METRICS_ENABLED=true`). `--internal` adds the per-app list; keep that output inside the project. - `digest` builds the opt-in owner digests (see "Owner digests" below): plain words about only one owner's apps, only when something changed since the previous scan. It prints them; `--out=DIR` writes one text file each; `--send` mails them, and only when sending is switched on too. - `owners` reads the same owners file as `digest`, checks it against the latest scan, and names every scanned app whose owner is unknown: no entry lists it, or no entry that lists it was confirmed (its `"confirmed"` date) in the last `ROLLCALL_OWNERS_CONFIRM_DAYS` days (365 by default). It exits 1 when there is one, and the weekly scan job runs it, so a new app without an owner, or an owner nobody has re-confirmed in a year, fails that job. - `drift` compares `policy.json` with a saved endoflife.date v1 product page (for example `https://endoflife.date/api/v1/products/php/` saved to a file). A difference is a flag for a person to look at; the policy stays the source of truth. Rollcall does not fetch that page itself. - `advisories` checks each app's locked `laravel/framework` and auth-package versions against a saved Packagist security-advisories response (for example `https://packagist.org/api/security-advisories/?packages[]=laravel/framework` saved to a file). One line per package and version, sorted by package then version: the status (`affected`, `clear` or `no data`), the count and the advisory ids, and how many apps hold that pair. A package with no advisory data prints `no data`, never `safe`: an absent row proves nothing about the package, and a version nobody can parse says `no data` too. Rollcall does not fetch that page itself; a person saves it and `--feed` points at the file. Output is package names and counts only: no app ids. - `prune` deletes snapshots older than `--days` (default: `ROLLCALL_RETENTION_DAYS`, 90; 0 keeps everything). The newest snapshot is never deleted, even if it is older than the cut-off, so the dashboard always has data. `--dry-run` lists what would go without deleting anything. Exit codes: `0` ok, `1` owner unknown (`rollcall owners` only), `2` tool error (a bad option value, an unreadable policy, a source that refused). Rollcall does not gate the fleet, so no command exits `1` over what the apps run: `rollcall owners` exits `1` while an app's owner is unknown, and that is the register, not the fleet. A misspelled command or an option the CLI does not know never reaches Rollcall: the console library prints the usage and exits `1`. #### Which command when Several stack commands sound alike (`weld:doctor`, `squire doctor`, `proctor check`) and do different jobs. Find your question in the second column and run the command beside it. The doctors look at setup, the proctor grades against policy, and the gate decides deploys: same waiting room, different appointments. | Command | What it checks | When to run it | Where it runs | |---|---|---|---| | `composer ci` | **Will my pipeline pass?** The repo's own CI contract, the same command the pipeline runs: validation, the tests, Pint, PHPStan, `composer audit` and whatever checks the repo adds. | Before every push. | App repo, CI | | `bin/weld.sh doctor` or `.\bin\weld.ps1 doctor` (both run `php artisan weld:doctor`) | **Does my WELD app hold together?** The app key, writable `storage` and `bootstrap/cache`, the database connection and pending migrations. One PASS, WARN or FAIL line each; exit 1 on a FAIL. Standards are PROCTOR's. | After `up`, when the app will not start, and after every deploy off Citadel. | App repo (in the app container), deploy host (in the app container) | | `vendor/bin/squire doctor` | **Is my Citadel release setup right?** `build.sh`, the release scripts, the health check, script hygiene, line endings, secrets kept out of git and the local parity setup, against Squire's rules. Exit 1 on a failed rule. The lock file, audit and MySQL 5.6 checks are handed to PROCTOR. | After `squire init` or `squire update`, and before the first deploy. | App repo, CI | | `vendor/bin/squire init --check` | **Have the files Squire wrote drifted from its templates?** Missing, outdated or edited copies. Writes nothing; exit 1 on drift. | After you upgrade Squire (then run `squire update`), and in CI. | App repo, CI | | `vendor/bin/squire doctor oracle`, or `php artisan oracle:check` in WELD and Sourdough's Laravel apps | **Can my app reach Oracle?** The `ORACLE_*` settings, the host, the port, the `oci8` driver and the login, in plain language, printing setting names and never values. Silent when the app has no Oracle settings. | After you fill in the `ORACLE_*` settings, or when a connection fails. Squire's `release.sh` runs the same check on every release, as a report. | App repo, deploy host | | `vendor/bin/proctor check` (`composer proctor` in WELD and Sourdough's apps) | **Does my app meet CREED's policy?** The PHP floor, Laravel, Node and MySQL end of life, the committed lock, `composer audit`, open-ended constraints, portability, MySQL 5.6 safety, overrides and the rest of its checks. Exit 1 on a FAIL. | Before you merge; the pipeline runs it too. | App repo, CI | | `vendor/bin/proctor gate` | **May this commit deploy?** The deploy-time subset of `proctor check`, ratcheted against the last release's verdict, so a deploy that makes nothing worse goes. Exit 1 is a no-go. | At deploy time. Squire's `release.sh` calls it for you. | Deploy host | | `sourdough manifest --check` | **Which managed files did I change since Sourdough baked my app?** Managed files that changed or are missing against `.sourdough/manifest.json`; seeded files are yours and never reported. Exit 1 on a change. | Before `sourdough feed`. | App repo, CI | | `sourdough feed --dry-run` | **Is my app behind its Sourdough template?** The plan a feed would apply, with nothing written. Exit 1 when feeding would change files. | After you install a new Sourdough, and in CI to catch an app falling behind. | App repo, CI | | `booster plan` | **What does my upgrade take?** The ordered PHP, Laravel and front-end hops, the dependencies that block them, and advisory PHPCompatibility and PHPStan scans. Changes nothing. | Before an upgrade, and when PROCTOR says your PHP or Laravel is past support. | App repo | | `booster replay check` | **Does my app still answer the same after a change?** Replays the requests in `booster-replay.json` and compares the answers with the ones `booster replay record` saved. Exit 1 on a changed answer. | After an upgrade hop or a hand fix, once you have a recording. | App repo (in Docker) | | `booster init --check` | **Are Booster's coding-tab playbooks current?** The playbooks in `.agents/skills`. Changes nothing; exit 1 when one is missing or out of date. | After you upgrade Booster, and in CI. | App repo, CI | | `php bin/regen-check.php --generated ` | **Is WELD still Sourdough's Inertia shape?** WELD, file by file, against a fresh `sourdough new --inertia`; fails only on drift that `.sourdough/regen-baseline.json` does not already accept. | When Sourdough's Inertia shape or WELD changes. | WELD repo, CI | | `rollcall report` | **Where does the whole fleet stand?** The latest scan's totals against CREED's policy: PHP, Laravel, the auth package, PROCTOR results and the end-of-life burn-down. Always exit 0; it never gates. | After `rollcall scan`, on the scan's schedule. | CI (a scheduled scan job) | The canonical copy of this table is in WELD's docs: [Which command when](https://weld.apps.wayne.edu/docs/reference/which-command.html). ### What the report says - **Apps present and scan notes**: the apps the scan read, then the notes it printed and carried on past (`totals.scan_errors` in JSON). Today a note means a source is not configured (no image export, no PROCTOR reports). A note is not a failed scan: a source that refuses stops the scan instead. - **PHP image, declared PHP floor, Laravel**: apps per version, the state from the policy (`active`, `security_only`, `eol`, `unknown`), the date security support ends and the days left (negative once past). - **Auth package and PROCTOR**: apps per auth package, and per PROCTOR result (`pass`, `fail`, `none`). - **Drift**, counted per kind: `image_eol`, `image_unknown`, `image_below_floor`, `floor_allows_eol`, `floor_unbounded`, `eol_past_grace` (past the policy's grace days), `laravel_eol`, `proctor_missing`, `proctor_failing`, `override_expired`. - **Progress**: apps that moved since the previous scan and apps that went from an EOL image to a supported one. In the internal view each upgraded app carries the day it landed. - **EOL burn-down**: for each scan day, how many apps ran an EOL image on that day. It reads the image, not the declared floor, so it stays `unknown` until an image export is configured. Each day also carries the same roll three ways, counts only: per support state (`states`), per PHP minor of the image (`php_image`, such as `{"8.1": 3, "8.4": 9}`) and per Laravel major (`laravel`). Every stored snapshot gets the breakdown, including the ones written before it existed, so the history reaches back as far as `rollcall prune` keeps snapshots. - **Forced image upgrades**: with Citadel's export as the image source, how many apps have a forced base-image upgrade pending, how many are due today or earlier, and the next date (`forced_upgrades`). The same counts reach `/metrics` (`rollcall_forced_upgrades_pending_apps`, `rollcall_forced_upgrades_overdue_apps` and `rollcall_forced_upgrades_next_due_timestamp_seconds`) and ADVISOR's `rollcall_fleet_summary`. The internal per-app list carries each app's `upgrade_due`. Zero with any other image source. The dashboard shows the three counts under its totals, and its internal table has an "Upgrade due" column, badged "date has come" once a date arrives. See [docs/guides/citadel.md](https://github.com/waynestate/rollcall/blob/HEAD/docs/guides/citadel.md). State is never decided in code: it is derived from the dates in `policy.json` by CREED's reader. A version the policy does not list is `unknown`. ### Configuration Every setting is an environment variable. `.env.example` holds placeholders; never commit a real token. | Variable | Meaning | Default | |---|---|---| | `ROLLCALL_POLICY_FILE` | Path to CREED's `policy.json` | none (required for `report`, `drift`) | | `ROLLCALL_STORE_DIR` | Snapshot directory, the only place Rollcall writes | `var/snapshots` | | `ROLLCALL_SOURCE` | `directory` (fixtures) or `gitlab` | `directory` | | `ROLLCALL_REPOS_DIR` | Fixture repositories as `//composer.{json,lock}`, plus `booster-hop.json` where an app has one | none | | `ROLLCALL_GITLAB_URL` | `https://` base URL of the GitLab instance | none | | `ROLLCALL_GITLAB_TOKEN` | A GitLab group or project access token (a bot), or a service account's token, with the read_api scope only, the Reporter role and an expiry. The stack's is the group token rollcall-scanner, rotated by the stack maintainer (docs/security.md). Never in git, never logged, never printed | none | | `ROLLCALL_GITLAB_GROUPS` | Comma-separated group ids or paths; subgroups are included. Ignored when ROLLCALL_GITLAB_PROJECTS is set | none | | `ROLLCALL_GITLAB_PROJECTS` | Comma-separated full `group/project` paths; when set, only those projects are scanned and no group is listed | none | | `ROLLCALL_IMAGES_FILE` | Export of the app list: `{"apps": [{"project": "group/project", "image": "php:8.4-apache"}]}` | none | | `ROLLCALL_CITADEL_EXPORT` | Citadel's saved registrations export, used instead of `ROLLCALL_IMAGES_FILE` (not both): base images plus forced upgrade dates. See [docs/guides/citadel.md](https://github.com/waynestate/rollcall/blob/HEAD/docs/guides/citadel.md) | none | | `ROLLCALL_PROCTOR_SOURCE` | Where PROCTOR reports come from: `directory` (`ROLLCALL_PROCTOR_DIR`) or `gitlab` (each project's proctor job artifact from its newest finished default-branch pipeline, with the same `read_api` token and GitLab settings) | `directory` | | `ROLLCALL_PROCTOR_DIR` | PROCTOR JSON reports, one per app: `group/project` is read from `group__project.json`. Not read when `ROLLCALL_PROCTOR_SOURCE` is `gitlab` | none | | `ROLLCALL_PROCTOR_JOB` | `ROLLCALL_PROCTOR_SOURCE=gitlab`: the CI job whose artifact holds the report; set it when Preflight's proctor component is included with another `job_name` | `proctor` | | `ROLLCALL_PROCTOR_ARTIFACT` | `ROLLCALL_PROCTOR_SOURCE=gitlab`: the PROCTOR `--format=json` report's path inside that job's artifact | `proctor.json` | | `ROLLCALL_AUTH_PACKAGES` | Comma-separated Composer packages that count as an auth package. An entry without a slash matches that package under any vendor (`wayne-cas` matches `anyvendor/wayne-cas`); an entry with a slash matches exactly. First match in list order wins | `waynestate/sesame`, `waynestate/wayne-cas`, `apereo/phpcas`, `jasig/phpcas`, `subfission/cas`, `wayne-cas`, `simplecas` | | `ROLLCALL_RETENTION_DAYS` | How many days of snapshots to keep; the newest is never deleted | `90` (0 keeps everything) | | `ROLLCALL_OWNERS_FILE` | Owners file for the digests: `{"owners": [{"contact": "team@example.test", "digest": true, "projects": ["group/project"]}]}`. Rollcall's own, for the stack's projects, is `owners.json` in the repo (roles only); keep another fleet's outside a public repo | none (no digests) | | `ROLLCALL_OWNERS_CONFIRM_DAYS` | How long an owners-file entry's `"confirmed"` date counts; past it, `rollcall owners` calls that owner unknown and exits 1 | `365` (0 turns the check off) | | `ROLLCALL_DIGEST_MAIL_ENABLED` | Allow `rollcall digest --send` to mail | `false` | | `ROLLCALL_DIGEST_MAIL_DSN` | Symfony Mailer DSN for sending, such as `smtp://mail.example.test:25`. A secret: never in git, never printed | none | | `ROLLCALL_DIGEST_MAIL_FROM` | The from address of the digests | none | | `ROLLCALL_METRICS_ENABLED` | Turn metrics on (`CLI report --format=prometheus` and `/metrics`) | `false` | | `ROLLCALL_METRICS_TOKEN` | Bearer token a scraper must present | none | | `ROLLCALL_METRICS_ALLOW` | Comma-separated scraper IP addresses (exact match) | none | | `ROLLCALL_PUBLIC_REPORT_ENABLED` | Serve `GET /report.json` (public counts only) | `false` | | `ROLLCALL_DASHBOARD_ENABLED` | Laravel and raw PHP: serve the dashboard page | `false` | | `ROLLCALL_DASHBOARD_PATH` | Laravel: dashboard URL path | `rollcall` | | `ROLLCALL_INTERNAL_ENABLED` | Laravel and raw PHP: serve the per-app page (Laravel at `/apps`, behind your sign-in middleware; raw PHP only where you call `rollcall_dashboard(['internal' => true])` behind your sign-in) | `false` | | `ROLLCALL_DASHBOARD_INERTIA` | Laravel + Inertia: answer the dashboard routes with the app's Vue page (`Rollcall/Dashboard`, published with `vendor:publish --tag=rollcall-inertia`) instead of the Blade view; same switches, same report. Needs `inertiajs/inertia-laravel` | `false` | | `ROLLCALL_WAYNEUI_CSS` | Laravel and raw PHP: `https://` or absolute URL of WayneUI's stylesheet for the dashboard | none | To scan GitLab you need the token and either a group or the project allowlist. The narrow way is `ROLLCALL_GITLAB_PROJECTS`: name the exact `group/project` paths and Rollcall reads only those, never listing a group. Otherwise set `ROLLCALL_GITLAB_GROUPS`. The token is a GitLab bot or personal access token with `read_api` only and an expiry, whose user can read only the projects to scan; until it exists Rollcall runs on its fixtures. Set `ROLLCALL_SOURCE=gitlab` and the GitLab variables. The `rollcall-scan` job in `.gitlab-ci.yml` does this on a schedule or by hand (see below). Rollcall sends only `GET` and `HEAD`, fetches the two Composer files and Booster's `booster-hop.json` without cloning, skips a Composer file whose blob id has not changed, follows `Link` pagination only to the configured host, and waits out `429 Retry-After`. PROCTOR results can come from GitLab CI too: with `ROLLCALL_PROCTOR_SOURCE=gitlab` the scan reads each project's `proctor.json` from its proctor job's artifact, with the same token. That needs apps whose CI keeps `proctor.json` as an artifact: Preflight 0.5.0 or later, or a proctor job of your own that does (see [docs/architecture.md](https://github.com/waynestate/rollcall/blob/HEAD/docs/architecture.md#where-proctor-results-come-from)). Elsewhere every app reads `none`. #### Run the collector in Docker No PHP on the machine? The repo ships a `Dockerfile` that builds a small image of the collector. It runs as a non-root user, writes only to its snapshot folder, and takes every setting from the environment at run time. Never put a token in the image: the build stays clean, and the token travels with `-e` (or `--env-file`) each time you run. Two lines, and every app answers present. Build it, from the repo root (again whenever the code changes): ``` docker build -t rollcall-collector . ``` That reads the `Dockerfile` next to it and tags the result `rollcall-collector`. Then run a scan. Each `-e` flag is a setting from the table above; for the narrow scan add `-e ROLLCALL_GITLAB_PROJECTS=group/project,other-group/other-project` and only those projects are read, no group is listed. The two `-v` flags mount your policy file and snapshot folder so the answer survives the container: ``` docker run --rm -e ROLLCALL_SOURCE=gitlab -e ROLLCALL_GITLAB_URL=https://gitlab.example.test -e ROLLCALL_GITLAB_TOKEN="$ROLLCALL_GITLAB_TOKEN" -e ROLLCALL_GITLAB_GROUPS=your-group -e ROLLCALL_POLICY_FILE=/app/policy.json -v "$PWD/policy.json:/app/policy.json" -v "$PWD/var:/app/var" rollcall-collector scan ``` Next: after a good scan, `var/snapshots/.json` holds the day's attendance, and the same run with `report` instead of `scan` prints it. On Windows PowerShell, set `$env:ROLLCALL_GITLAB_TOKEN` first and use `${PWD}` for the mount paths. #### Scheduled scan on GitLab CI Rollcall's own repository (on git.wayne.edu, its canonical home) carries a `rollcall-scan` job in `.gitlab-ci.yml`. It runs `scan` over the 13 stack projects read-only and keeps the snapshot in `var/snapshots/` as a 30 day artifact. It runs when a GitLab schedule says so, or when a person starts it by hand from the web; without a token it skips green. It needs three things in GitLab, and on git.wayne.edu all three exist: 1. A token with the `read_api` scope only, the Reporter role and an expiry. The stack's is the group access token `rollcall-scanner` on the `enterprise-apps` group, which expires 2027-11-06 (Rollcall prints a note 14 days before). 2. A CI/CD variable `ROLLCALL_GITLAB_TOKEN` on the ROLLCALL project: masked and hidden, protected (the schedule runs on the protected default branch), and not a file. 3. A schedule on `main`: CI/CD > Schedules, weekly (Monday), with the variable `ROLLCALL_JOB` set to `scan`. The token is rotated by a role, the stack maintainer, not a named person. The runbook (where the token lives, when it expires, the five steps, and what to look for in the job log) is "The scanner token and how to rotate it" in [docs/security.md](https://github.com/waynestate/rollcall/blob/HEAD/docs/security.md). About reach: a group token reads every project in its group. The project owner chose group reach for the stack's token; the allowlist `ROLLCALL_GITLAB_PROJECTS` keeps what Rollcall asks for to the 13 projects (it never lists the group and never asks for another project). If your fleet needs a tighter fence, give a service account Reporter on just the projects to scan and use its token instead, because only membership limits what a token can read. Exactly which scope, and why each other scope stays off: `read_api` covers every call Rollcall makes (listed one by one, with the role and the expiry rules, under "The GitLab token, exactly" in [docs/security.md](https://github.com/waynestate/rollcall/blob/HEAD/docs/security.md)). Not `api`, not `read_repository` (Rollcall never clones), not `read_user`, not `self_rotate` (the stack maintainer rotates the token, never Rollcall). ### Owner digests (opt-in) An owner who asks can get a short digest of only their own apps: what changed since the previous scan (an image upgrade, a new drift flag, one cleared, a PROCTOR result that moved), then where each app stands. Nothing changed, no digest. Nobody gets one by default, and no owner is ever guessed from commit authors. 1. Point `ROLLCALL_OWNERS_FILE` at an owners file that maps each scanned project to its contacts (a mail address, a team alias or a role). An owner opts in with `"digest": true`; leaving the key out means no. `"confirmed"` is the day the contact last said it still answers for those apps; `rollcall owners` calls the owner unknown once that day is older than `ROLLCALL_OWNERS_CONFIRM_DAYS`. The shape is `contract/owners.schema.json`. ```json { "$schema": "contract/owners.schema.json", "owners": [ {"contact": "team@example.test", "digest": true, "confirmed": "2026-11-01", "projects": ["group/project", "group/other-project"]} ] } ``` Rollcall keeps its own in the repo: [owners.json](https://github.com/waynestate/rollcall/blob/HEAD/owners.json) lists the 13 stack projects the scheduled scan reads, all answered for by the stack maintainer. The repo is public, so it names roles and teams, never a person. For another fleet, keep that fleet's file next to its snapshots, outside a public repo. 2. After a scan, `rollcall digest` prints each digest with news (`--format=json` for a script, `--owner=CONTACT` for one owner). `--out=DIR` writes them as `-.txt` instead, for a mail tool you already have. A scanned app that no entry lists is never dropped: every run names it on stderr as "no owner on file", and the JSON lists it under `no_owner_on_file`. 3. To have Rollcall mail them itself, install `symfony/mailer`, set `ROLLCALL_DIGEST_MAIL_ENABLED=true`, `ROLLCALL_DIGEST_MAIL_DSN` and `ROLLCALL_DIGEST_MAIL_FROM`, and run `rollcall digest --send`. Without all four, it sends nothing. Every contact must be a mail address, or nothing goes out at all. A digest names apps, so it is internal like the per-app list. It uses the report's own states and drift flags, so a digest and the report never disagree. Schedule it after `rollcall scan` (weekly suits the burn-down). ### WSU values (Playbook) `ROLLCALL_GITLAB_URL` is a Wayne State value, so it may come from Playbook (`waynestate/playbook`) when the environment has none. The environment always wins; Playbook only fills what the environment leaves out. The GitLab token never comes through Playbook and stays an environment variable. | Setting | Value | |---|---| | `ROLLCALL_GITLAB_URL` | The `https://` base URL of the GitLab instance | Playbook is private and lives on git.wayne.edu. Getting it into your app: Composer: add the repository to your `composer.json`, then require the package. Composer authenticates to git.wayne.edu with the token in `auth.json`. ```json { "repositories": [ {"type": "vcs", "url": "https://git.wayne.edu/enterprise-apps/playbook.git"} ] } ``` ``` composer require waynestate/playbook ``` curl (Linux, macOS): ``` curl --fail -H "PRIVATE-TOKEN: $GITLAB_TOKEN" "https://git.wayne.edu/api/v4/projects/enterprise-apps%2Fplaybook/repository/files/playbook.env/raw?ref=main" -o .env.playbook ``` PowerShell (Windows): ``` Invoke-WebRequest -Headers @{ 'PRIVATE-TOKEN' = $env:GITLAB_TOKEN } -Uri "https://git.wayne.edu/api/v4/projects/enterprise-apps%2Fplaybook/repository/files/playbook.env/raw?ref=main" -OutFile .env.playbook ``` Clone: ``` git clone https://git.wayne.edu/enterprise-apps/playbook.git ``` The token is your own: `read_api` for curl, `read_repository` for clone and Composer. Playbook is private on git.wayne.edu. If you get a 404, ask the Enterprise Applications team for read access. ### Metrics Metrics are off by default (the stack's metrics rule). With `ROLLCALL_METRICS_ENABLED=true`, `/metrics` serves Prometheus text built from the latest snapshot (a request never triggers a scan). It needs `ROLLCALL_METRICS_TOKEN` as a bearer token or an address in `ROLLCALL_METRICS_ALLOW`; with neither set, nobody gets in. Labels are version numbers, state names, drift kinds and public package names: no app names or personal data. The dashboard JSON is in `grafana/rollcall-burn-down.json`; import it into Grafana once a Prometheus server scrapes the endpoint. Run `rollcall scan` on a schedule so the series moves. Forced image upgrades from a Citadel export come through as three gauges, counts only, in the same style as the rest: `rollcall_forced_upgrades_pending_apps` (apps with one pending, overdue ones included), `rollcall_forced_upgrades_overdue_apps` (due today or earlier) and `rollcall_forced_upgrades_next_due_timestamp_seconds` (midnight of the next date still ahead, only while there is one). With any other image source the two counts are 0 and the date is absent. The dashboard shows pending and overdue as two stat panels. ### Laravel The package registers itself (`extra.laravel.providers`). Publish the config with `php artisan vendor:publish --tag=rollcall-config`, set the variables above, and schedule `rollcall:scan`. The dashboard shows counts and progress; the per-app page is a second route that stays off until you enable it, and it runs behind `rollcall.dashboard.internal_middleware` (default `web` and `auth.sesame`), so an app with no such middleware fails closed. The page uses WayneUI's class names and takes its stylesheet from `ROLLCALL_WAYNEUI_CSS`. In an Inertia app it can be one of your own Vue pages instead: see "The dashboard in an Inertia app (Vue)". The `/metrics` route is registered on its own path; if your app already serves `/metrics` (HELMET does), run Rollcall's on a separate app or leave metrics off. ### The dashboard in a raw PHP app The same page, no framework. `rollcall_dashboard()` prints the renderer the Laravel page prints, from the same report, so the two answer the roll in the same words. Drop one file into the folder your web server serves: ```php 'citadel']); rollcall_dashboard(['nonce' => $helmet['nonce']]); ``` It answers 404 until `ROLLCALL_DASHBOARD_ENABLED=true`, sends `X-Robots-Tag: noindex` with every answer, and never runs a scan: it reads the latest snapshot, so set `ROLLCALL_POLICY_FILE` and `ROLLCALL_STORE_DIR` as for the CLI and schedule `vendor/bin/rollcall scan`. The page has no script. Its one small style element takes HELMET's nonce; link WayneUI's stylesheet with `ROLLCALL_WAYNEUI_CSS` and the page keeps its look under HELMET's CSP even without one. No HELMET? Call `rollcall_dashboard()` with no options. The per-app page is a second file, behind your sign-in: call `rollcall_dashboard(['internal' => true])` after SESAME's `sesame_login()` has returned a user. It also needs `ROLLCALL_INTERNAL_ENABLED=true`; with either one missing it answers 404, so it fails closed. For a front controller of your own, `Waynestate\Rollcall\Dashboard\RawDashboard::response()` returns the same answer as data (status, headers, body). ### The dashboard in an Inertia app (Vue) In a Laravel + Inertia + Vue app (WELD's shape) the dashboard can be one of the app's own pages, inside its own layout. Same routes, same switches, same report: with `ROLLCALL_DASHBOARD_INERTIA=true` the controller hands what `DashboardPage::report()` built to an Inertia page as props (`report`, `internal`, `scanCommand`) instead of printing the Blade view. From a WELD app: ```bash php artisan vendor:publish --tag=rollcall-inertia # writes resources/js/pages/Rollcall/Dashboard.vue # .env: ROLLCALL_DASHBOARD_ENABLED=true and ROLLCALL_DASHBOARD_INERTIA=true npm run build ``` The published page is short and it is yours. In essence it puts the component in WELD's `AppLayout` with a title and a `noindex` tag (the full file adds breadcrumbs and a few lines of scoped CSS, in WayneUI's spacing tokens, that space the sections and set the three totals side by side): ```vue ``` Why this shape: the page is published because the layout is the app's, and the component is imported straight from `vendor/` because the markup is Rollcall's. `composer update` moves the component together with the PHP renderer it must match, and there is no npm package to install or keep in step (Rollcall publishes none). Vite and `vue-tsc` follow the relative import like any file in the project, and the component imports nothing but `vue`, which the app already has. An app that does not use the Vue page loads none of it; `inertiajs/inertia-laravel` is needed only when the switch is on. The component renders what the Blade page shows inside ``: the same WayneUI classes, the `role="status"` line, the captions and headers, and the per-app table only on the internal page (`/apps`, still behind `rollcall.dashboard.internal_middleware` and `ROLLCALL_INTERNAL_ENABLED`). It has no style block, no style attribute and no script of its own, so it works under HELMET's CSP, and it takes its look from the app's WayneUI stylesheet. Every Inertia answer carries `X-Robots-Tag: noindex`. CI holds the rooms together: `dashboard-vue` server-renders the component with the props the route sends and fails on any difference from the Blade page (elements, attributes and text; only whitespace, attribute order and Vue's hydration comments are normalized), and `dashboard-a11y` checks the three Vue pages with the other six. ### Use Rollcall from your coding agent (ADVISOR) Rollcall ships a module for [ADVISOR](https://packagist.org/packages/waynestate/advisor), the stack's MCP server: three read-only tools, and a small creed goes with them: every app answers present, the agent may ask, and nobody gets ranked. Install both packages where the MCP server runs: ``` composer require waynestate/advisor waynestate/rollcall ``` Then name the module in your own manifest file. Rollcall ships none on purpose, so nothing loads by accident: ```json { "modules": [ "Waynestate\\Rollcall\\Advisor\\RollcallModule" ] } ``` and point `ADVISOR_MODULES_FILE` at that file. The tools read the snapshot store behind `ROLLCALL_STORE_DIR`; with an empty store each one says so in plain words and names `rollcall scan`. | Tool | What it answers | |---|---| | `rollcall_fleet_summary` | Counts from the latest snapshot: apps by PHP image, declared floor, Laravel line, auth package, PROCTOR result, MySQL 5.6 CI job state and Booster hop result, drift per kind, progress since the previous scan, forced image upgrades (`forced_upgrades`: pending, overdue, next due), and the snapshot date | | `rollcall_burn_down` | The dated EOL series, one point per scan day, each with its counts per support state, PHP minor and Laravel major; optional `days` (an integer, 1 to 365) keeps only the most recent days | | `rollcall_supported_versions` | Every version in CREED's policy, grouped by what it says today: active, security only, or end of life | The tools take no path, command or URL, make no network call, and answer public counts only: the same fields `/report.json` serves. The per-app list stays internal and never leaves through a tool. Each answer names its source and its dates. ### Proof Rollcall's first scheduled scan of the stack on GitLab CI and a rerun over 58 Wayne State applications (2026-11-06): what ran, what held, what it caught in Rollcall and what it does not prove yet, on the [Proof](https://github.com/waynestate/rollcall/blob/HEAD/docs/reference/proof.md) docs page. ### Docs The full documentation lives at [/docs/](/docs/) on the project site: install, guides, reference and checks, built from `docs/` by Squire's docs builder. Two tables are generated so they cannot drift: the command reference comes from `php bin/rollcall list --format=json`, and the environment table is scanned out of `src/`, `bin/` and `config/`. - `composer docs` rebuilds `site/docs/` from `docs/`; run it after editing a page. - `composer docs:check` fails when the built site is stale or a generated table has drifted; `composer ci` runs it. The pages are committed because the deploy server serves `site/` without building. Every page links back to its Markdown, and the footer stamps the version the docs describe. Roll call: the docs answer present too. The docs pages wear the front page's look: the same masthead and menu, ruled paper, Caslon titles, the front page's red section folios (each section of a page opens with its own "§ 1") and the green back cover. To change it, edit `docs/_header.html` (the masthead, links written as if from `site/`) and `docs/theme/rollcall.css` (the front page's tokens mapped onto the kit's `--dk-*`, plus a derived dark mode), then run `composer docs`. Never edit `site/assets/docs.css` or `docs.js`: they are Squire's kit and a sync overwrites them. ### Run the checks Maintainers: how to build, test and release this project, and where its data comes from, is in [MAINTAINING.md](https://github.com/waynestate/rollcall/blob/HEAD/MAINTAINING.md). Why it is built this way is in [DECISIONS.md](https://github.com/waynestate/rollcall/blob/HEAD/DECISIONS.md) and the ADRs under [ADR/](https://github.com/waynestate/rollcall/blob/HEAD/ADR/). `composer ci` runs every check: manifest, tests (the contract suite among them), Pint, the agent-ready files, a check that the docs site is current, a check that the front page's versions table and quick-start printout still match CREED's policy, PHPStan and `composer audit`. The contract itself is JSON Schema in [`contract/`](https://github.com/waynestate/rollcall/blob/HEAD/contract/README.md): the report, the stored snapshot and the image list export. `tests/ContractTest.php` runs the real commands on the fixtures and validates their output against it, so a field cannot appear or vanish without the contract changing in the same commit. PHP is not needed on the host: ``` docker run --rm -v "${PWD}:/app" -w /app composer:2.11.1@sha256:8de2184c6de224f4689e8f80ed5f5edaf0030b6b8b7839a22a2bcb6722ac87d0 sh -c "composer install --no-interaction && composer ci" ``` (On Windows PowerShell `${PWD}` works as written; in Git Bash use `$(pwd -W)` and set `MSYS_NO_PATHCONV=1`.) The GitLab pipeline (`.gitlab-ci.yml`) and the GitHub workflow (`.github/workflows/ci.yml`) both wrap `composer ci`, on PHP 8.3, 8.4 and 8.5. git.wayne.edu now has an instance runner, and the stack's CI runs on it. Every product in the stack still strongly recommends a git.wayne.edu instance runner, so that capacity stays there. The front page has its own accessibility gate (axe-core in Playwright, run in Docker): `scripts/a11y.sh` on Linux and macOS, `scripts/a11y.ps1` on Windows; MAINTAINING.md says when to run it. ### Security notes - Read-only toward GitLab and everything else: one gate in the GitLab adapter allows only `GET` and `HEAD`, and a test fails if a write verb appears in `src/`. - The GitLab token is a group or project access token (a GitLab bot), or a service account's token, with the `read_api` scope only, the Reporter role and an expiry; the stack's is the group access token `rollcall-scanner`, which expires 2027-11-06. It goes in the environment as `ROLLCALL_GITLAB_TOKEN`, never in git, is sent only to the configured `https` host, and is hidden from debug output and error messages. `ROLLCALL_GITLAB_PROJECTS` limits what Rollcall asks for, not what the token can read; only the token's membership does that. When the source is GitLab, `scan` reads the token's own record (`GET /api/v4/personal_access_tokens/self`) and prints a note 14 days before it expires, or when it has already expired. The note names the date; the stack maintainer (a role, not a named person) rotates the token before its expiry, never Rollcall, following the runbook in [docs/security.md](https://github.com/waynestate/rollcall/blob/HEAD/docs/security.md). The check is advisory: a refused, unreachable or unparseable answer prints nothing and never fails the scan, and the token value never appears in output. - Composer files are parsed as data. No `composer install`, script or plugin from a scanned repository ever runs. - PROCTOR reports, image tags and app ids are outside input: shapes are validated, text is bounded, and terminal output strips control characters. - Every GitLab call, the scope that covers it, and the scopes the token must not have are tabled in [docs/security.md](https://github.com/waynestate/rollcall/blob/HEAD/docs/security.md); a test fails if the adapter calls a path that table does not list. ### Where the code lives The canonical repository is [enterprise-apps/rollcall](https://git.wayne.edu/enterprise-apps/rollcall) on git.wayne.edu. Clone it over SSH as `git@git.wayne.edu:enterprise-apps/rollcall.git` or over HTTPS as `https://git.wayne.edu/enterprise-apps/rollcall.git`; open issues and merge requests there, and tags are made there, by the maintainer, with an approver. GitHub ([waynestate/rollcall](https://github.com/waynestate/rollcall)) is a read-only push mirror of git.wayne.edu: nobody pushes to it, and Packagist reads from it. Roll call: git.wayne.edu? Present. GitHub? A copy of the sheet. ### Contributing Issues and merge requests go to git.wayne.edu; see Where the code lives above. License: MIT, Copyright Wayne State University. --- Source: https://rollcall.apps.wayne.edu/ Fleet attendance, Wayne State University ## ROLLCALL Every app answers “present”. The ones on PHP 7.4 answer from the back row. Rollcall is the stack's fleet scanner. For each app it records the PHP image, the lowest PHP its `composer.json` allows, the Laravel version, the auth package and the PROCTOR result. Then it looks up each version in CREED's `policy.json`. Every scan is kept as a snapshot, so you can see drift and how fast the EOL apps are going away. `$ composer require waynestate/rollcall` Promoted to **1.2.0**, on Packagist. Inside 1.x the report, the snapshot and the image list never lose or retype a field: [the contract](https://rollcall.apps.wayne.edu/docs/reference/contract.html) says so. **Works alongside [WELD](https://weld.apps.wayne.edu/).** Rollcall doesn't go inside your app. You run it on its own to see what every app in the fleet is running, WELD apps included. [Quick start](https://rollcall.apps.wayne.edu/#start-title) [Take the roll](https://rollcall.apps.wayne.edu/#roll-title) Today's roll sample data 1. kiln-bookingPHP 8.5present 2. tuba-rentalPHP 8.4present 3. pigeon-postPHP 8.3late 4. lunch-ledgerPHP 8.3late 5. abacus-classicPHP 7.4back row Answered 5 of 5 A sample roll ### Take the roll Seventeen made-up apps, seated by PHP version with the newest at the front. As you scroll, Rollcall calls each name. The back row answers with a hand in the air. Sample data · fictional apps · policy as of 2026-10-28 **Sample roll: seventeen fictional apps with their PHP image, Laravel version, auth package, PROCTOR result and the mark Rollcall gives them** | No. | App | PHP image | Laravel | Auth | PROCTOR | Mark | | --- | --- | --- | --- | --- | --- | --- | | Front row PHP 8.5 and 8.4, active | | | | | | | | 01 | kiln-booking | 8.5 | 13 | sesame | pass | present | | 02 | tuba-rental | 8.4 | 13 | sesame | pass | present | | 03 | moth-catalog | 8.4 | 12 | sesame | pass | present | | 04 | quad-weather | 8.4 | 13 | none | pass | present | | 05 | greenhouse-log | 8.4 | 12 | sesame | pass | present | | 06 | sundial | 8.4 | 13 | sesame | pass | present | | 07 | otter-tracker | 8.4 | 12 | sesame | pass | present | | Middle rows PHP 8.3 and 8.2, security fixes only | | | | | | | | 08 | pigeon-post | 8.3 | 12 | phpcas | pass | late | | 09 | lunch-ledger | 8.3 | 12 | sesame | fail | late | | 10 | chess-club | 8.3 | 11, EOL | phpcas | pass | late | | 11 | lost-mittens | 8.3 | 12 | none | none | late | | 12 | fog-index | 8.2 64 days left | 11, EOL | phpcas | pass | late | | Back row past end of life | | | | | | | | 13 | abacus-classic | 7.4 | 8, EOL | phpcas | none | back row | | 14 | punch-card-pal | 7.4 | none | none | none | back row | | 15 | dial-up-directory | 8.1 | 10, EOL | phpcas | fail | back row | | 16 | floppy-archive | 8.0 | 9, EOL | sesame | pass | back row | | 17 | ghost-kiosk | legacy-base no version in the tag | none | none | none | inaudible | - **present**: 7 - **late**: 5 - **back row**: 4 - **inaudible**: 1 - **Answered**: 17 Nobody is marked absent. If one source has a gap, like a missing PROCTOR report or a bad image tag, that app gets a note and the scan carries on. The public report only shows totals like these. The per-app list is the internal view (`--internal`), and it stays inside the project. Five answers per app ### What “present” means Four of the answers are versions, and Rollcall looks each one up by date in CREED's `policy.json`. No support date is written into Rollcall's code. The fifth answer is PROCTOR's own result. 1. ### PHP image The image the app actually runs on, read from its tag in the app list. 2. ### PHP floor The lowest PHP its `composer.json` allows. `*` counts as no floor at all. 3. ### Laravel The version that's installed, read from `composer.lock`. 4. ### Auth package Which sign-in package is installed: SESAME, a CAS client, or none. 5. ### PROCTOR `pass`, `fail` or `none`, from PROCTOR's JSON report. Rollcall never re-runs a rule. Key to the marks - present `active`: fully supported - late `security_only`: security fixes only, and the end date is set - back row `eol`: past its security date, or older than anything the policy lists - inaudible `unknown`: newer than the policy knows, or a tag nobody can read **Supported versions from CREED's policy.json: runtime or tool, version, support state and end of support** | Runtime or tool | Version | Support state | End of support | | --- | --- | --- | --- | | php | 8.1 | eol_grace_expired | 2025-12-31 | | php | 8.2 | security | 2026-12-31 | | php | 8.3 | security | 2027-12-31 | | php | 8.4 | active | 2028-12-31 | | php | 8.5 | active | 2029-12-31 | | laravel | 10 | eol_grace_expired | 2025-02-04 | | laravel | 11 | eol_grace_expired | 2026-03-12 | | laravel | 12 | security | 2027-02-24 | | laravel | 13 | active | 2028-03-17 | | node | 20 | eol_grace_expired | 2026-04-30 | | node | 22 | security | 2027-04-30 | | node | 24 | security | 2028-04-30 | | node | 26 | active | 2029-04-30 | | mysql | 5.6 | eol_grace_expired | 2021-02-28 | | mysql | 5.7 | eol_grace_expired | 2023-10-31 | | mysql | 8.0 | eol_grace_expired | 2026-04-30 | | mysql | 8.4 | active | 2032-04-30 | | mysql | 9.7 | active | 2034-04-30 | | vue | 2 | eol_grace_expired | 2023-12-31 | | vue | 3 | active | n/a | | inertia | 2 | active | n/a | | inertia | 3 | active | n/a | | composer | 2.8.0 | minimum | n/a | Drift and the burn-down ### Watch the back row empty Rollcall keeps one snapshot per scan day. Count the apps on an EOL image in each one and you get a line that should only go down. Apps on an EOL PHP image, one scan a week Sample data Grafana draws the same line from `/metrics` with the bundled dashboard, `grafana/rollcall-burn-down.json`. Each scan day also counts the roll per PHP minor, Laravel major and support state, so the JSON report shows which lines the fleet is leaving and which it is joining. #### Drift, counted per kind - `image_eol`runs on an EOL PHP image - `image_unknown`an image tag nobody can read - `image_below_floor`the image is older than the app allows - `floor_allows_eol`the PHP floor still lets an EOL version in - `floor_unbounded`no PHP floor declared at all - `eol_past_grace`past the policy's grace days - `laravel_eol`Laravel past its security date - `proctor_missing`no PROCTOR report on file - `proctor_failing`PROCTOR says fail - `override_expired`a PROCTOR override ran out `rollcall drift` also compares the policy with a saved endoflife.date page. A difference is a flag for a person; the policy stays the source of truth. From a checkout, with the bundled fixtures ### Quick start This runs on the fixtures in the repo, so you need no network and no token, just PHP 8.3 or newer. Run `composer install` once, then the commands below. **Linux and macOS** bash ``` export ROLLCALL_POLICY_FILE=tests/fixtures/policy.json export ROLLCALL_REPOS_DIR=tests/fixtures/repos export ROLLCALL_IMAGES_FILE=tests/fixtures/images.json export ROLLCALL_PROCTOR_DIR=tests/fixtures/proctor export ROLLCALL_STORE_DIR=var/snapshots php bin/rollcall scan php bin/rollcall report ``` **Windows** PowerShell, no bash or WSL needed ``` $env:ROLLCALL_POLICY_FILE = "tests/fixtures/policy.json" $env:ROLLCALL_REPOS_DIR = "tests/fixtures/repos" $env:ROLLCALL_IMAGES_FILE = "tests/fixtures/images.json" $env:ROLLCALL_PROCTOR_DIR = "tests/fixtures/proctor" $env:ROLLCALL_STORE_DIR = "var/snapshots" php bin/rollcall scan php bin/rollcall report ``` What comes back real output, abridged, Rollcall 1.1, bundled fixtures (four demo apps) ``` Present: 4 apps. Snapshot 2026-10-28 saved to var/snapshots. ROLLCALL 1.1.1 | scan 2026-10-28 | as of 2026-10-28 | public Apps present: 4 (scan notes: 0) PHP image VERSION APPS STATE SECURITY UNTIL DAYS TO EOL 8.1 1 eol 2025-12-31 -320 8.3 1 security_only 2027-12-31 410 8.4 1 active 2028-12-31 776 unknown 1 unknown - - EOL burn-down (state on each scan day) DATE APPS EOL SUPPORTED UNKNOWN 2026-11-16 4 1 2 1 ``` **exit 0**, however the fleet looks. There is no exit 1: Rollcall takes attendance, it does not hand out detention. 2026-10-28 4 1 2 1 **exit 0**, however the fleet looks. Neither command exits 1: Rollcall takes attendance, it does not hand out detention. - **`rollcall scan`**: Scans once and saves `.json`. A second scan on the same day replaces it. - **`rollcall report`**: `--format=text|json|prometheus`. `--internal` adds the per-app list; keep that inside the project. - **`rollcall drift`**: `--feed=`, a saved endoflife.date page. Rollcall never fetches it itself. - **In Laravel**: The package registers itself. Publish the config with `php artisan vendor:publish --tag=rollcall-config`, then schedule `php artisan rollcall:scan`. Left on the desk for your agent ### Notes for the substitute Your coding agent is the substitute teacher here: it has never met this class. Each note tells it where to read up on Rollcall and what it must leave alone, and asks it to check with you before it guesses. Copy one, or open it in OpenCode, Claude Code, Codex or ChatGPT. #### Get started with Rollcall Call the sample roll from a checkout, with the bundled fixtures, and have the agent read the report back to you. A prompt for your coding agent. Copy it as it stands: ```text You are a coding agent helping a Wayne State University developer try Rollcall, the fleet scanner of WELD, the Wayne State application stack. Rollcall reads each app's composer.json and composer.lock, its PHP image and its PROCTOR report, and checks every version against CREED's policy.json by date. It enforces nothing: scan and report always exit 0. Read first: - https://rollcall.apps.wayne.edu/llms.txt, the index of Rollcall's pages, each one as Markdown. Work from them, not from memory. - ADVISOR, the stack's MCP server, if it is connected: get_project_status and read_project_docs with project rollcall, and policy_lookup for PHP. If it is not connected, say so and work from the pages. How to add it: https://advisor.apps.wayne.edu/llms.txt - The README in this folder, if this folder is a Rollcall checkout. If it is not, ask me whether to clone https://github.com/waynestate/rollcall first. Task: 1. Install the dependencies once with `composer install` (PHP 8.3 or newer). If the host has no PHP, use the Docker line in the README's Run the checks section. 2. Point Rollcall at the bundled fixtures: set ROLLCALL_POLICY_FILE, ROLLCALL_REPOS_DIR, ROLLCALL_IMAGES_FILE, ROLLCALL_PROCTOR_DIR and ROLLCALL_STORE_DIR the way the README's Quick start does. 3. Call the roll with `php bin/rollcall scan`, then print it with `php bin/rollcall report`. 4. Read the report back to me: each PHP image, the state CREED gives it, and the days left before end of life. Constraints: - Fixtures only: no network and no GitLab token. A real scan needs a read_api group or project access token (a GitLab bot), which a role, the stack maintainer, makes and rotates; never invent one. - Give separate commands for Windows (PowerShell), macOS and Linux wherever they differ. - The per-app list (report --internal) stays inside the project. Never paste app names anywhere public. - Ask me before you guess, and before you touch anything outside this folder. Output: the commands you ran, the report, then a short reading of it and your questions. ``` #### Or leave the note for your kind of app #### Rollcall as a plain PHP tool The CLI on a schedule, and the dashboard page and the /metrics and /report.json front controller only if you ask for them. A prompt for your coding agent. Copy it as it stands: ```text You are a coding agent setting up Rollcall, the fleet scanner of WELD, the Wayne State application stack, as a plain PHP tool with no framework: a scan on a schedule from the command line and, only if I ask, the dashboard page of totals and the /metrics and /report.json endpoints. Read first: - https://rollcall.apps.wayne.edu/llms.txt, then the README it links: the Commands, Configuration and Metrics sections, and The dashboard in a raw PHP app. - ADVISOR, the stack's MCP server, if it is connected: list_stack_rules with permutation raw-php for the rules that apply, and policy_lookup for PHP. If it is not connected, say so and work from the pages. - This project's composer.json, and how this host runs scheduled jobs. Task: 1. Add Rollcall with `composer require waynestate/rollcall`. The CLI is `vendor/bin/rollcall`. 2. Write the settings as environment variables from the README's Configuration table: the policy file, the store folder and the source. Start with directory fixtures; switch to GitLab only once the read_api token exists (the stack maintainer makes it) and you have the group. 3. Schedule the scan subcommand once a day with --prune, and show me the report subcommand in text and in json. 4. Only if I ask for metrics: serve the package's public/index.php front controller, with ROLLCALL_METRICS_ENABLED and either ROLLCALL_METRICS_TOKEN or ROLLCALL_METRICS_ALLOW set. 5. Only if I ask for the dashboard: add one file under the served folder that calls rollcall_dashboard(), after helmet_boot() with its nonce when this app runs HELMET. Turn it on with ROLLCALL_DASHBOARD_ENABLED and give it WayneUI's stylesheet with ROLLCALL_WAYNEUI_CSS. Leave the per-app page (ROLLCALL_INTERNAL_ENABLED plus 'internal' => true) off unless I ask; it belongs only behind this app's sign-in. Constraints: - Rollcall is read-only toward every source and writes only its snapshot folder (plus digest files, when `rollcall digest --out` is asked for). Keep it that way. - The GitLab token is a read_api group or project access token (a GitLab bot) that the stack maintainer makes and rotates; it comes from the environment as ROLLCALL_GITLAB_TOKEN. Never commit it, log it or print it. - Metrics, the public report and the dashboard stay off unless I turn them on. - Give separate commands for Windows (PowerShell), macOS and Linux wherever they differ, schedules included. - Ask me before you guess, and before you touch a deploy or a scheduler. Output: the files you changed, the schedule entry for each OS, then your questions. ``` #### Rollcall in a Laravel app The scheduled scan and the dashboard of totals: the package's Blade page, or in an Inertia app one of your own Vue pages, inside your layout. A prompt for your coding agent. Copy it as it stands: ```text You are a coding agent adding Rollcall, the fleet scanner of WELD, the Wayne State application stack, to a Laravel app: the scheduled scan, the dashboard page of totals and, only if I ask, the internal per-app page. Read first: - https://rollcall.apps.wayne.edu/llms.txt, then the README it links: the Laravel, Configuration and Metrics sections. - ADVISOR, the stack's MCP server, if it is connected: list_stack_rules with the permutation that fits this app (laravel-blade, laravel-blade-vue or laravel-inertia-vue), and policy_lookup for PHP and Laravel. If it is not connected, say so and work from the pages. - composer.json, composer.lock, config/, routes/, bootstrap/app.php and .env.example. Task: 1. Add Rollcall with `composer require waynestate/rollcall`. Its service provider registers itself. 2. Publish the config with `php artisan vendor:publish --tag=rollcall-config`, and add the settings to .env.example as placeholders. 3. Schedule `php artisan rollcall:scan` once a day. 4. Turn on the dashboard with ROLLCALL_DASHBOARD_ENABLED. In a Blade app it is the package's page in WayneUI's class names; give it WayneUI's stylesheet with ROLLCALL_WAYNEUI_CSS. In an Inertia app (WELD), publish the Vue page with `php artisan vendor:publish --tag=rollcall-inertia`, set ROLLCALL_DASHBOARD_INERTIA and rebuild the assets, so it renders inside this app's own layout. 5. Leave the per-app page (ROLLCALL_INTERNAL_ENABLED) off unless I ask. It runs behind the web and auth.sesame middleware and fails closed without them. Constraints: - Meet each setting the Laravel way (config, the scheduler, middleware) before writing code of your own. - If this app already serves /metrics (HELMET does), leave Rollcall's metrics off. - Never commit a real token or a .env file. - Ask me before you guess, and before you touch migrations, auth or anything that deploys. Output: the files you changed, the scheduler entry, then your questions. ``` Your agent reads the same pages you do. [llms.txt](https://rollcall.apps.wayne.edu/llms.txt) lists them, [llms-full.txt](https://rollcall.apps.wayne.edu/llms-full.txt) has all of them in one file, and this page has a [Markdown twin](https://rollcall.apps.wayne.edu/index.md). The buttons only copy text or open the tool you pick; nothing is sent anywhere. Classroom rules ### For noticing who is missing, not for shaming them 1. ### It enforces nothing. It never opens an issue, leaves a comment or deploys anything, and its scan and report exit `0` whatever they find. 2. ### The public report has totals only. Counts and progress. There are no app names, owners or rankings in it. 3. ### It only reads. `GET` and `HEAD` only, and a test fails if a write verb shows up in `src/`. It writes its own snapshot folder, and digest files only when you ask. 4. ### Metrics stay off until you turn them on. Once they're on, `/metrics` needs a bearer token or an allowed address. If neither is set, nobody gets in. Three sources and a policy ### Where the answers come from Rollcall reads three sources plus CREED's policy, and writes one snapshot per scan day. Each source also has a fixture adapter, so you can try all of it without a live GitLab. - Repositories`composer.json` and `.lock`, from GitLab or a folder - App listthe PHP image each app runs - [PROCTOR](https://proctor.apps.wayne.edu/) one JSON report per app, from a folder or CI - [CREED](https://creed.apps.wayne.edu/) `policy.json`, the dates Rollcall scans and compares - Terminal`text` and `json` reports - /metricsPrometheus text, off by default - Grafanathe bundled burn-down dashboard - Dashboard pageWayneUI totals, in Laravel, Inertia/Vue or raw PHP Rollcall's place in the stack ### The class list These are the parts of the Wayne State application stack, and what each one has to do with Rollcall. WELD is the Laravel starter app that has most of them installed. 1. [WayneUI](https://wayneui.apps.wayne.edu/)the interface; the dashboard wears its classes 2. [CREED](https://creed.apps.wayne.edu/)writes the dates Rollcall reads 3. [PROCTOR](https://proctor.apps.wayne.edu/)checks one app; Rollcall collects the results 4. [Preflight](https://preflight.apps.wayne.edu/)CI templates, where PROCTOR reports are born 5. [SESAME](https://sesame.apps.wayne.edu/)the auth package Rollcall counts 6. [HELMET](https://helmet.apps.wayne.edu/)baseline runtime, with its own `/metrics` 7. [Pinstripe](https://pinstripe.apps.wayne.edu/)the Pint and PHPStan rules this repo wears 8. [Sourdough](https://sourdough.apps.wayne.edu/)starters that begin in the front row 9. [WELD](https://weld.apps.wayne.edu/)the Laravel starter app, with the stack already set up 10. Rollcallyou are here: the fleet census and EOL burn-down 11. [Booster](https://booster.apps.wayne.edu/)moves the back row forward 12. [Squire](https://squire.apps.wayne.edu/)carries the release to Citadel 13. [Parity](https://parity.apps.wayne.edu/)Citadel on your computer, so the dress rehearsal counts 14. [Drawbridge](https://drawbridge.apps.wayne.edu/)the sign-in gateway for Citadel 15. [ADVISOR](https://advisor.apps.wayne.edu/)the MCP server your agent asks about the stack --- Source: https://rollcall.apps.wayne.edu/docs/architecture.html ## How it is built [#](https://rollcall.apps.wayne.edu/docs/architecture.html#how-it-is-built) This page shows the moving parts. Next: [security notes](https://rollcall.apps.wayne.edu/docs/security.html). A framework-free core (`src/`) plus thin entry points that hold no rules: - `bin/rollcall`: the CLI (`scan`, `report`, `digest`, `owners`, `drift`, `advisories`, `prune`). One PHP command, so it works the same on Windows, macOS and Linux. - `public/index.php`: a raw-PHP front controller for `GET /metrics` and `GET /report.json`. - `rollcall_dashboard()`: the dashboard page for a raw PHP app, one call in a file you serve. It prints the same renderer (`src/Dashboard/DashboardPage.php`) as the Laravel page, so the two cannot drift. - `resources/js/RollcallDashboard.vue`: the same dashboard as a Vue component for an Inertia app's own page. The Laravel adapter hands it the same report as props, and the CI job `dashboard-vue` fails it on any difference from the PHP renderer's markup. - `src/Laravel/`: a Laravel adapter with a dashboard page, a `/metrics` route and `php artisan rollcall:scan` and `rollcall:prune`. CREED's policy reader lives under `src/Creed/` (namespace `Waynestate\Rollcall\Creed`) as a generated copy, made by CREED's `bin/export.php`. CREED is on Packagist now, so the copy can become a `require` of `waynestate/creed`; until Rollcall switches, the copy stays. To refresh it, run `php /bin/export.php --namespace='Waynestate\Rollcall\Creed' --to=src/Creed` from a CREED checkout. `composer creed-copy:check` proves the copy has not drifted (it reads the checkout from `CREED_PATH`); a hand edit to `src/Creed/` fails that check. Weekly CREED copy refresh: a scheduled GitLab job (`creed-copy-refresh`, Mondays, an hour after CREED's policy robot) re-exports the copy from CREED main, rebuilds the versions table and docs, runs `composer creed-copy:check` and `composer ci`, and pushes to main only when both pass. A red run leaves main untouched. The steps are in [Scripts on every OS](https://rollcall.apps.wayne.edu/docs/reference/scripts.html#inside-gitlab-ci-only). Data comes in through three interfaces. Each has a fixture adapter, so you can try everything without a live host: | Source | Interface | Adapters | | --- | --- | --- | | Repositories (`composer.json`, `composer.lock`, `booster-hop.json`) | `RepositorySource` | a directory of fixtures; GitLab over PSR-18, tested against recorded responses | | Runtime image per app | `ImageSource` | a JSON export of the app list from any platform, or Citadel's own registrations export (which adds forced upgrade dates) | | PROCTOR result | `ProctorReportSource` | a directory of PROCTOR `--format=json` reports (the default); or, with `ROLLCALL_PROCTOR_SOURCE=gitlab`, each project's proctor job artifact in GitLab CI | #### Where PROCTOR results come from [#](https://rollcall.apps.wayne.edu/docs/architecture.html#where-proctor-results-come-from) Rollcall never runs PROCTOR. It reads the JSON report PROCTOR already wrote (`proctor check --format=json`), from one of two places, chosen by `ROLLCALL_PROCTOR_SOURCE`: - `directory` (the default): `ROLLCALL_PROCTOR_DIR`, one file per app, `group/project` read from `group__project.json`. The fixtures and any shared folder a pipeline copies reports into use this. - `gitlab`: the report straight from CI, with the same `read_api` token and GitLab adapter as the scan (`ROLLCALL_GITLAB_URL` and the groups or projects must be set even when the repositories come from a directory). For each project Rollcall lists the newest finished pipelines on the default branch, takes the newest one that ran the `proctor` job (`ROLLCALL_PROCTOR_JOB`), whether that job passed or failed, and reads `proctor.json` (`ROLLCALL_PROCTOR_ARTIFACT`) from the job's artifact by job id. Three reads per project, usually; every call is listed in [security notes](https://rollcall.apps.wayne.edu/docs/security.html#every-call-rollcall-makes). GitLab's one-call "artifact from the latest successful pipeline" endpoint is not used on purpose: a failing PROCTOR job fails its pipeline, so that endpoint would show a failing app's last passing report, or none. In both readers a missing report is no report: the app's PROCTOR result is `none` and the scan carries on. Over CI that covers no pipeline yet, no proctor job in the newest five finished pipelines, a 404 for the file (never kept, or the artifact expired) and CI/CD turned off for the project (a 403 on its pipeline list). A file that is not a PROCTOR report becomes the note "PROCTOR report could not be read" for that app. Any other GitLab error is handled like every other call: a refused token stops the scan, 429 waits, anything else fails it. For the CI reader to find a report, the app's pipeline must keep PROCTOR's JSON report as a file artifact (`artifacts: paths`, not only `artifacts: reports: codequality`, which this endpoint cannot read), with `when: always` so a failing job still keeps it, and an `expire_in` longer than the gap between scans. For apps that include Preflight's proctor component, that means Preflight 0.5.0 or later: the earlier components keep only the Code Quality report, so over CI every such app reads `none`. A pipeline with a proctor job of its own can add the artifact itself. Rollcall only reads from every source. It writes its own snapshot directory, and digest files only when `rollcall digest --out` asks for them. The decisions behind this shape (saved files over live calls, counts in public, one image source, the contract) are recorded in [DECISIONS.md](https://github.com/waynestate/rollcall/blob/main/DECISIONS.md) and [ADR/](https://github.com/waynestate/rollcall/tree/main/ADR). --- Source: https://rollcall.apps.wayne.edu/docs/checks.html ## Run the checks [#](https://rollcall.apps.wayne.edu/docs/checks.html#run-the-checks) This page shows how the project is built, tested and released, and where changes land. Checks: `composer ci` (the same command runs on GitLab and GitHub). Maintainers: how to build, test and release this project, and where its data comes from, is in [MAINTAINING.md](https://github.com/waynestate/rollcall/blob/main/MAINTAINING.md). `composer ci` runs every check: manifest, tests (the [contract suite](https://rollcall.apps.wayne.edu/docs/reference/contract.html) among them), Pint, the agent-ready files, a check that the docs site is current, a check that the front page's versions table and quick-start printout still match CREED's policy, PHPStan and `composer audit`. PHP is not needed on the host: ``` docker run --rm -v "${PWD}:/app" -w /app composer:2.11.1@sha256:8de2184c6de224f4689e8f80ed5f5edaf0030b6b8b7839a22a2bcb6722ac87d0 sh -c "composer install --no-interaction && composer ci" ``` (On Windows PowerShell `${PWD}` works as written; in Git Bash use `$(pwd -W)` and set `MSYS_NO_PATHCONV=1`.) The GitLab pipeline (`.gitlab-ci.yml`) and the GitHub workflow (`.github/workflows/ci.yml`) both wrap `composer ci`, on PHP 8.3, 8.4 and 8.5. git.wayne.edu now has an instance runner, and the stack's CI runs on it. Every product in the stack still strongly recommends a git.wayne.edu instance runner, so that capacity stays there. The front page has its own accessibility gate (axe-core in Playwright, run in Docker): `scripts/a11y.sh` on Linux and macOS, `scripts/a11y.ps1` on Windows; [MAINTAINING.md](https://github.com/waynestate/rollcall/blob/main/MAINTAINING.md) says when to run it. ### Contributing [#](https://rollcall.apps.wayne.edu/docs/checks.html#contributing) The canonical repository is [enterprise-apps/rollcall](https://git.wayne.edu/enterprise-apps/rollcall) on git.wayne.edu; changes land there first, and Wayne State developers open issues and merge requests on that project. GitHub ([waynestate/rollcall](https://github.com/waynestate/rollcall)) is a read-only push mirror of git.wayne.edu: nobody pushes to it, and Packagist reads from it. License: MIT, Copyright Wayne State University. --- Source: https://rollcall.apps.wayne.edu/docs/guides/advisor.html ## Use Rollcall from your coding agent (ADVISOR) [#](https://rollcall.apps.wayne.edu/docs/guides/advisor.html#use-rollcall-from-your-coding-agent-advisor) This page installs the ADVISOR module and names the three tools. Next: [run the checks](https://rollcall.apps.wayne.edu/docs/checks.html). Rollcall ships a module for [ADVISOR](https://packagist.org/packages/waynestate/advisor), the stack's MCP server: three read-only tools, and a small creed goes with them: every app answers present, the agent may ask, and nobody gets ranked. Install both packages where the MCP server runs: ``` composer require waynestate/advisor waynestate/rollcall ``` Then name the module in your own manifest file. Rollcall ships none on purpose, so nothing loads by accident: ```json { "modules": [ "Waynestate\\Rollcall\\Advisor\\RollcallModule" ] } ``` and point `ADVISOR_MODULES_FILE` at that file. The tools read the snapshot store behind `ROLLCALL_STORE_DIR`; with an empty store each one says so in plain words and names `rollcall scan`. | Tool | What it answers | | --- | --- | | `rollcall_fleet_summary` | Counts from the latest snapshot: apps by PHP image, declared floor, Laravel line, auth package, PROCTOR result, MySQL 5.6 CI job state and Booster hop result, drift per kind, progress since the previous scan, forced image upgrades (`forced_upgrades`: pending, overdue, next due), and the snapshot date | | `rollcall_burn_down` | The dated EOL series, one point per scan day, each with its counts per support state, PHP minor and Laravel major; optional `days` (an integer, 1 to 365) keeps only the most recent days | | `rollcall_supported_versions` | Every version in CREED's policy, grouped by what it says today: active, security only, or end of life | The tools take no path, command or URL, make no network call, and answer public counts only: the same fields `/report.json` serves. The per-app list stays internal and never leaves through a tool. Each answer names its source and its dates. --- Source: https://rollcall.apps.wayne.edu/docs/guides/citadel.html ## Citadel's registrations export [#](https://rollcall.apps.wayne.edu/docs/guides/citadel.html#citadel-s-registrations-export) This page shows how Rollcall reads the runtime image of each app, and any forced upgrade date, from a file Citadel produces. Next: [run the collector in Docker](https://rollcall.apps.wayne.edu/docs/guides/collector-docker.html). Citadel is one source among others. On OpenShift, Coolify or plain Docker, keep using the image list (`ROLLCALL_IMAGES_FILE`), which any platform can produce. Nothing in Rollcall needs Citadel. ### 1. Rollcall never calls Citadel [#](https://rollcall.apps.wayne.edu/docs/guides/citadel.html#1-rollcall-never-calls-citadel) Rollcall reads a saved file. It holds no Citadel account, opens no connection to Citadel, and sends nothing back. A person or a scheduled job saves the export, and `rollcall scan` reads it, the same way it reads PROCTOR's reports and the endoflife.date page. If Citadel offers a read-only endpoint that answers with this JSON, save its answer to the file: the shape is the same. ### 2. The shape [#](https://rollcall.apps.wayne.edu/docs/guides/citadel.html#2-the-shape) The export uses Citadel's own field names, so the people who keep Citadel can produce it without a mapping table. The schema is `contract/citadel-export.schema.json`; extra fields are ignored, so an export may carry more. ```json { "applications": [ {"repository": "group/project", "base_image": "citadel/php-apache:8.4r5"}, {"repository": "group/old-project", "base_image": "citadel/php-apache:8.1r2"} ], "base_image_upgrades": [ {"old_image": "citadel/php-apache:8.1r2", "new_image": "citadel/php-apache:8.4r5", "due_date": "2026-12-15", "completed": false} ] } ``` | Field | What it is in Citadel | What Rollcall does with it | | --- | --- | --- | | `applications[].repository` | The GitLab `group/project` an application deploys from | Joins the app to the repository the scan read | | `applications[].base_image` | The base image of the application's active deployment | Reads the PHP version (`8.4r5` is PHP 8.4) | | `base_image_upgrades[].old_image` | The image being retired | Every app on that image gets the due date | | `base_image_upgrades[].due_date` | The day Citadel forces the upgrade, `YYYY-MM-DD` | The earliest pending date per image counts | | `base_image_upgrades[].completed` | Whether that upgrade is done | Only `false` counts; a done upgrade is ignored | Two fields are optional: `applications[].php_version` (the PHP version in the running container, such as `8.3.14`) and `applications[].httpd_version` (the Apache httpd version, such as `2.4.62`). We have asked the Citadel team to send them. When they arrive, Rollcall keeps them in the snapshot and shows them per app in the internal report as "PHP (running)" and "httpd (running)", blank until Citadel sends them; an export without them changes nothing. Entries Rollcall cannot trust are skipped, never guessed: an application with no repository, an upgrade with no real date (`"soon"`, `2026-02-30`) or without `"completed": false`. An app registered on Citadel but not in the scan is not invented either: the census starts from the repositories. ### 3. Point Rollcall at it [#](https://rollcall.apps.wayne.edu/docs/guides/citadel.html#3-point-rollcall-at-it) macOS and Linux ```sh export ROLLCALL_CITADEL_EXPORT=/path/to/citadel-export.json php bin/rollcall scan php bin/rollcall report ``` Windows ```powershell $env:ROLLCALL_CITADEL_EXPORT = "C:\path\to\citadel-export.json" php bin/rollcall scan php bin/rollcall report ``` Set `ROLLCALL_CITADEL_EXPORT` or `ROLLCALL_IMAGES_FILE`, not both: each is a complete image source, and the scan stops with a plain message if both are set. In Laravel, the setting is `rollcall.citadel_export`. ### 4. What the report gains [#](https://rollcall.apps.wayne.edu/docs/guides/citadel.html#4-what-the-report-gains) - **Forced image upgrades**: the text report prints `Forced image upgrades pending: 2 (1 due today or earlier), next due 2026-12-15.` and the JSON report carries `forced_upgrades` with `pending`, `overdue` (due today or earlier) and `next_due` (the next future date, or `null`). Counts only, so it is public. With the image list, or no image source, all three are zero. - **Metrics and ADVISOR**: the same counts reach `/metrics` as `rollcall_forced_upgrades_pending_apps`, `rollcall_forced_upgrades_overdue_apps` and `rollcall_forced_upgrades_next_due_timestamp_seconds` (see [metrics](https://rollcall.apps.wayne.edu/docs/guides/metrics.html)), and ADVISOR's `rollcall_fleet_summary` tool answers with `forced_upgrades` (see [ADVISOR](https://rollcall.apps.wayne.edu/docs/guides/advisor.html)). - **Per app, internally**: the internal report's per-app list carries `upgrade_due`, and the stored snapshot keeps it. Snapshots written before it existed load as `null`. - **The dashboard**: a "Forced image upgrades" section under the totals with the three counts (the due one in a red badge while any date has come), and on the internal page an "Upgrade due" column with each app's date, badged "date has come" from that day on. The public page never names an app. - **Owner digests**: a new forced upgrade date is news, and so is one that went away. See [owner digests](https://rollcall.apps.wayne.edu/docs/guides/digest.html). The export names applications, so keep it where you keep the snapshots: on the host, outside git. --- Source: https://rollcall.apps.wayne.edu/docs/guides/collector-docker.html ## Run the collector in Docker [#](https://rollcall.apps.wayne.edu/docs/guides/collector-docker.html#run-the-collector-in-docker) This page builds the collector image and runs a scan in Docker. Next: [WSU values (Playbook)](https://rollcall.apps.wayne.edu/docs/guides/wsu-values.html) for where the GitLab URL comes from. No PHP on the machine? The repo ships a `Dockerfile` that builds a small image of the collector. It runs as a non-root user, writes only to its snapshot folder, and takes every setting from the environment at run time. Never put a token in the image: the build stays clean, and the token travels with `-e` (or `--env-file`) each time you run. Two lines, and every app answers present. Build it, from the repo root (again whenever the code changes): ``` docker build -t rollcall-collector . ``` That reads the `Dockerfile` next to it and tags the result `rollcall-collector`. Then run a scan. Each `-e` flag is a setting from [the configuration table](https://rollcall.apps.wayne.edu/docs/reference/configuration.html); for the narrow scan add `-e ROLLCALL_GITLAB_PROJECTS=group/project,other-group/other-project` and only those projects are read, no group is listed. The two `-v` flags mount your policy file and snapshot folder so the answer survives the container: ``` docker run --rm -e ROLLCALL_SOURCE=gitlab -e ROLLCALL_GITLAB_URL=https://gitlab.example.test -e ROLLCALL_GITLAB_TOKEN="$ROLLCALL_GITLAB_TOKEN" -e ROLLCALL_GITLAB_GROUPS=your-group -e ROLLCALL_POLICY_FILE=/app/policy.json -v "$PWD/policy.json:/app/policy.json" -v "$PWD/var:/app/var" rollcall-collector scan ``` Next: after a good scan, `var/snapshots/.json` holds the day's attendance, and the same run with `report` instead of `scan` prints it. On Windows PowerShell, set `$env:ROLLCALL_GITLAB_TOKEN` first and use `${PWD}` for the mount paths. --- Source: https://rollcall.apps.wayne.edu/docs/guides/digest.html ## Owner digests [#](https://rollcall.apps.wayne.edu/docs/guides/digest.html#owner-digests) This page shows how an owner who asks gets a digest of only their own apps. Next: [metrics](https://rollcall.apps.wayne.edu/docs/guides/metrics.html). A digest is a short note in plain words: what changed in that owner's apps since the previous scan, then where each app stands. Nothing changed, no digest. Nobody gets one by default, and Rollcall never guesses an owner from commit authors. ### 1. Say who answers for which apps [#](https://rollcall.apps.wayne.edu/docs/guides/digest.html#1-say-who-answers-for-which-apps) An owners file maps each scanned project to the contacts who answer for it. Point `ROLLCALL_OWNERS_FILE` at it. An owner opts in with `"digest": true`; leaving the key out means no. ```json { "$schema": "contract/owners.schema.json", "owners": [ {"contact": "team@example.test", "digest": true, "projects": ["group/project", "group/other-project"]}, {"contact": "another-team@example.test", "projects": ["group/third-project"]} ] } ``` Here the first team gets digests and the second does not. A contact is a mail address, a team alias or a role; each one is listed once, and a project may sit under more than one contact. The shape is `contract/owners.schema.json`, and the optional `"$schema"` line lets an editor check the file as you type. Rollcall keeps its own file in the repo, [`owners.json`](https://github.com/waynestate/rollcall/blob/main/owners.json): the 13 stack projects the scheduled scan reads, all answered for by the stack maintainer. The repo is public, so its contacts are roles and teams, never a person (a test refuses an `@` in it), and those digests print rather than mail. To scan another fleet, keep that fleet's file next to its snapshots, outside a public repo, and point `ROLLCALL_OWNERS_FILE` there. An app in the scan that no entry lists is not dropped. `rollcall digest` names it on stderr every run, ``` No owner on file for 1 of 14 apps in this scan, so no digest covers it. Add it to the owners file: - group/new-project: no owner on file ``` and `--format=json` lists it under `no_owner_on_file`. An owner who has not opted in still counts as its owner. Reports never read the owners file, so the report stays free of owners. #### Confirm owners on a schedule [#](https://rollcall.apps.wayne.edu/docs/guides/digest.html#confirm-owners-on-a-schedule) An owner on file is only as good as the last time somebody said it is still true. Give each entry a `"confirmed"` date, the day the contact last confirmed it answers for those apps: ```json {"contact": "team@example.test", "digest": true, "confirmed": "2026-11-01", "projects": ["group/project"]} ``` `rollcall owners` checks the owners file against the latest scan and calls an app's owner unknown when no entry lists the app, or when no entry that lists it was confirmed in the last `ROLLCALL_OWNERS_CONFIRM_DAYS` days (365 by default; 0 turns the check off). An entry with no date was never confirmed, and a date after today is not trusted. One fresh entry is enough when an app sits under several contacts. ``` Owners file: 2 owners, 1 opted in to the digest An owner counts as confirmed for 365 days after its "confirmed" date. 1 of 14 scanned apps have an owner on file that nobody confirmed in the last 365 days: - group/old-project (last confirmed 2025-06-01) Owner unknown for 1 of 14 scanned apps. Ask who answers for it, then list or re-date it in the owners file. ``` It exits 1 while any owner is unknown, so the weekly scan job, which runs it after `scan`, goes red until someone asks the contact and writes the new date. `--format=json` gives the same answer to a script (`contract/owners-check.schema.json`). Rollcall never fills the gap by guessing an owner from commit authors. ### 2. Print them [#](https://rollcall.apps.wayne.edu/docs/guides/digest.html#2-print-them) After a scan: ``` rollcall digest ``` prints one digest per opted-in owner with news, each headed `To:` and `Subject:`. `--owner=CONTACT` picks one owner (an owner who has not opted in is refused), `--format=json` gives a script the same digests (`contract/digest.schema.json`), and `--out=DIR` writes them as `-.txt` instead of printing, for a mail tool you already run. Lines on stderr name any app with no owner on file and count how many owners had news and how many get nothing this time. What counts as a change, app by app: - the PHP image moved (a move from end of life to a supported PHP says so, with a well-earned "Present!"); - the declared PHP floor, the Laravel version or the PROCTOR result changed; - a forced image upgrade date from [Citadel's export](https://rollcall.apps.wayne.edu/docs/guides/citadel.html) appeared, moved or went away; - a drift flag appeared ("now runs an end-of-life Laravel") or cleared ("no longer has a failing PROCTOR result"), including one that appears because a date in CREED's policy passed; - an app answered present for the first time, or was in the last scan and is not in this one. The first scan has no "before", so the first digest is a first roll call: every app and where it stands. The states and flags are the report's own (`rollcall report --internal`), so a digest and the report never disagree. ### 3. Mail them (only if you want Rollcall to) [#](https://rollcall.apps.wayne.edu/docs/guides/digest.html#3-mail-them-only-if-you-want-rollcall-to) Sending is a second, separate switch, and every part of it must be there: 1. `composer require symfony/mailer` (Rollcall only suggests it). 2. `ROLLCALL_DIGEST_MAIL_ENABLED=true`. 3. `ROLLCALL_DIGEST_MAIL_DSN`: a Symfony Mailer DSN, such as `smtp://mail.example.test:25`. It can hold a password, so it is a secret: never in git, never printed. 4. `ROLLCALL_DIGEST_MAIL_FROM`: the from address. 5. `rollcall digest --send`. Without any one of them nothing is mailed; with the settings but no `--send`, the digests are only printed. Every contact with news must be a mail address, or nothing goes out at all. Mail is plain text. This is the one outbound action in Rollcall, so it stays behind both the flag and the settings. Schedule it right after `rollcall scan`: weekly suits the burn-down, and a quiet week sends nothing. --- Source: https://rollcall.apps.wayne.edu/docs/guides/laravel.html ## Laravel [#](https://rollcall.apps.wayne.edu/docs/guides/laravel.html#laravel) This page wires Rollcall into a Laravel app, and shows the same dashboard as a Vue page in an Inertia app and in a raw PHP app. Next: [use it from your coding agent (ADVISOR)](https://rollcall.apps.wayne.edu/docs/guides/advisor.html). The package registers itself (`extra.laravel.providers`). Publish the config with `php artisan vendor:publish --tag=rollcall-config`, set the variables in [the configuration reference](https://rollcall.apps.wayne.edu/docs/reference/configuration.html), and schedule `rollcall:scan`. The dashboard shows counts and progress; the per-app page is a second route that stays off until you enable it, and it runs behind `rollcall.dashboard.internal_middleware` (default `web` and `auth.sesame`), so an app with no such middleware fails closed. The page uses WayneUI's class names and takes its stylesheet from `ROLLCALL_WAYNEUI_CSS`. In an Inertia app it can be one of your own Vue pages instead (below). The page also carries a status line (a `role="status"` paragraph) that names the apps shown and the scan date, so assistive technology hears what the page displays. The `/metrics` route is registered on its own path; if your app already serves `/metrics` (HELMET does), run Rollcall's on a separate app or leave metrics off. ### The dashboard in an Inertia app (Vue) [#](https://rollcall.apps.wayne.edu/docs/guides/laravel.html#the-dashboard-in-an-inertia-app-vue) In a Laravel + Inertia + Vue app (WELD's shape) the dashboard can be one of the app's own pages, inside its own layout. Same routes, same switches, same report: with `ROLLCALL_DASHBOARD_INERTIA=true` the controller hands what `DashboardPage::report()` built to an Inertia page as props (`report`, `internal`, `scanCommand`) instead of printing the Blade view. From a WELD app: ```bash php artisan vendor:publish --tag=rollcall-inertia # writes resources/js/pages/Rollcall/Dashboard.vue # .env: ROLLCALL_DASHBOARD_ENABLED=true and ROLLCALL_DASHBOARD_INERTIA=true npm run build ``` The published page is short and it is yours. In essence it puts the component in WELD's `AppLayout` with a title and a `noindex` tag (the full file adds breadcrumbs and a few lines of scoped CSS, in WayneUI's spacing tokens, that space the sections and set the three totals side by side): ```vue ``` Why this shape: the page is published because the layout is the app's, and the component is imported straight from `vendor/` because the markup is Rollcall's. `composer update` moves the component together with the PHP renderer it must match, and there is no npm package to install or keep in step (Rollcall publishes none). Vite and `vue-tsc` follow the relative import like any file in the project, and the component imports nothing but `vue`, which the app already has. An app that does not use the Vue page loads none of it; `inertiajs/inertia-laravel` is needed only when the switch is on. The component renders what the Blade page shows inside `
`: the same WayneUI classes, the `role="status"` line, the captions and headers, and the per-app table only on the internal page (`/apps`, still behind `rollcall.dashboard.internal_middleware` and `ROLLCALL_INTERNAL_ENABLED`). It has no style block, no style attribute and no script of its own, so it works under HELMET's CSP, and it takes its look from the app's WayneUI stylesheet. Every Inertia answer carries `X-Robots-Tag: noindex`. CI holds the rooms together: `dashboard-vue` server-renders the component with the props the route sends and fails on any difference from the Blade page (elements, attributes and text; only whitespace, attribute order and Vue's hydration comments are normalized), and `dashboard-a11y` checks the three Vue pages with the other six. ### The dashboard in a raw PHP app [#](https://rollcall.apps.wayne.edu/docs/guides/laravel.html#the-dashboard-in-a-raw-php-app) The same page, no framework. `rollcall_dashboard()` prints the renderer the Laravel page prints, from the same report, so the two answer the roll in the same words. Drop one file into the folder your web server serves: ```php 'citadel']); rollcall_dashboard(['nonce' => $helmet['nonce']]); ``` It answers 404 until `ROLLCALL_DASHBOARD_ENABLED=true`, sends `X-Robots-Tag: noindex` with every answer, and never runs a scan: it reads the latest snapshot, so set `ROLLCALL_POLICY_FILE` and `ROLLCALL_STORE_DIR` as for the CLI and schedule `vendor/bin/rollcall scan`. The page has no script. Its one small style element takes HELMET's nonce; link WayneUI's stylesheet with `ROLLCALL_WAYNEUI_CSS` and the page keeps its look under HELMET's CSP even without one. No HELMET? Call `rollcall_dashboard()` with no options. It carries the same status line as the Laravel page. The per-app page is a second file, behind your sign-in: call `rollcall_dashboard(['internal' => true])` after SESAME's `sesame_login()` has returned a user. It also needs `ROLLCALL_INTERNAL_ENABLED=true`; with either one missing it answers 404, so it fails closed. For a front controller of your own, `Waynestate\Rollcall\Dashboard\RawDashboard::response()` returns the same answer as data (status, headers, body). All three go through the same accessibility gate: `DashboardRenderTest` writes the Laravel and the raw-PHP pages and the Inertia props, `dashboard-vue` renders the Vue pages from those props once they match, and `dashboard-a11y` checks all nine (public, internal and empty, in each room) in light and dark at 320 and 1280 px. --- Source: https://rollcall.apps.wayne.edu/docs/guides/metrics.html ## Metrics [#](https://rollcall.apps.wayne.edu/docs/guides/metrics.html#metrics) This page turns on and protects the Prometheus endpoint. Next: [Laravel](https://rollcall.apps.wayne.edu/docs/guides/laravel.html) for the dashboard. Metrics are off by default (the stack's metrics rule). With `ROLLCALL_METRICS_ENABLED=true`, `/metrics` serves Prometheus text built from the latest snapshot (a request never triggers a scan). It needs `ROLLCALL_METRICS_TOKEN` as a bearer token or an address in `ROLLCALL_METRICS_ALLOW`; with neither set, nobody gets in. Labels are version numbers, state names, drift kinds and public package names: no app names or personal data. The dashboard JSON is in `grafana/rollcall-burn-down.json`; import it into Grafana once a Prometheus server scrapes the endpoint. Run `rollcall scan` on a schedule so the series moves. Forced image upgrades from a Citadel export come through as three gauges, counts only, in the same style as the rest: `rollcall_forced_upgrades_pending_apps` (apps with one pending, overdue ones included), `rollcall_forced_upgrades_overdue_apps` (due today or earlier) and `rollcall_forced_upgrades_next_due_timestamp_seconds` (midnight of the next date still ahead, only while there is one). With any other image source the two counts are 0 and the date is absent. The dashboard shows pending and overdue as two stat panels. PROCTOR's MySQL 5.6 CI job check comes through as one gauge, `rollcall_mysql56_ci_apps`, counted per state (`held`, `missing`, `not_applicable`, `unknown`); all four series always exist, zero when no app is in a state. The dashboard shows the four as a bar gauge. Booster's hop records come through the same way, as `rollcall_booster_apps`, counted per result (`pass`, `fail`, `none`); all three series always exist. The dashboard shows the three as a pie chart beside the MySQL 5.6 one. Every query on the dashboard names a metric this endpoint serves; `composer ci` renders the fixture fleet's metrics and fails when a panel asks for one that is not there, so a renamed gauge never leaves a panel on "No data". **Watch the back row empty (the burn-down, sample data)** ![Rollcall's sample burn-down: hatched bars of apps on an end-of-life PHP image falling from 19 on August 12 to 4 on October 28, with a red line over the top and the last bar filled green.](https://rollcall.apps.wayne.edu/docs/readme/burn-down.jpg) The same line Grafana draws from `/metrics`. Made-up apps, real arithmetic. --- Source: https://rollcall.apps.wayne.edu/docs/guides/quick-start.html ## Quick start [#](https://rollcall.apps.wayne.edu/docs/guides/quick-start.html#quick-start) This page takes you from a fresh clone to a first report, on the fixtures in the repo. Next: read [what the report says](https://rollcall.apps.wayne.edu/docs/guides/what-the-report-says.html). This runs on the fixtures in the repo, so you need no network and no token. Run `composer install` once (or the Docker line under [Run the checks](https://rollcall.apps.wayne.edu/docs/checks.html)), then the commands below. Linux and macOS (bash): ``` export ROLLCALL_POLICY_FILE=tests/fixtures/policy.json export ROLLCALL_REPOS_DIR=tests/fixtures/repos export ROLLCALL_IMAGES_FILE=tests/fixtures/images.json export ROLLCALL_PROCTOR_DIR=tests/fixtures/proctor export ROLLCALL_STORE_DIR=var/snapshots php bin/rollcall scan php bin/rollcall report ``` Windows (PowerShell, no bash or WSL needed): ``` $env:ROLLCALL_POLICY_FILE = "tests/fixtures/policy.json" $env:ROLLCALL_REPOS_DIR = "tests/fixtures/repos" $env:ROLLCALL_IMAGES_FILE = "tests/fixtures/images.json" $env:ROLLCALL_PROCTOR_DIR = "tests/fixtures/proctor" $env:ROLLCALL_STORE_DIR = "var/snapshots" php bin/rollcall scan php bin/rollcall report ``` `policy.json` is CREED's file; the copy under `tests/fixtures/` is a snapshot for tests. Use the released one in real runs. --- Source: https://rollcall.apps.wayne.edu/docs/guides/what-the-report-says.html ## What the report says [#](https://rollcall.apps.wayne.edu/docs/guides/what-the-report-says.html#what-the-report-says) This page explains each part of the report. Next: [Citadel's registrations export](https://rollcall.apps.wayne.edu/docs/guides/citadel.html) if your apps run on Citadel. - **Apps present and scan notes**: the first line counts the apps the scan read, then the notes it printed and carried on past (`totals.scan_errors` in JSON, `rollcall_scan_errors` in metrics). Today a note means a source is not configured: with no image export the PHP image column is `unknown`, with no PROCTOR reports every app is `none`. `scan` prints each note as it saves the snapshot, and `report --format=json --internal` lists them. A note is not a failed scan; a source that refuses (a bad token) stops the scan instead. - **PHP image, declared PHP floor, Laravel**: apps per version, the state from the policy (`active`, `security_only`, `eol`, `unknown`), the date security support ends and the days left (negative once past). - **Auth package and PROCTOR**: apps per auth package, and per PROCTOR result (`pass`, `fail`, `none`). - **MySQL 5.6 CI job**: apps by the state of PROCTOR's `mysql56-ci` finding (CREED's `databases.md` rule says an app's migrations must run in CI against MySQL 5.6): `held` when the report carries a `held` finding, `missing` when it carries a `no-job` finding, `not_applicable` when it carries neither and came from PROCTOR 0.15.1 or newer (the check ran and had nothing to say: no migrations), and `unknown` for an app with no report, one that could not be read, or a report from PROCTOR below 0.15.1, which cannot tell `held` from `not_applicable`. The dashboard shows the four counts as panels under "Apps present" (held, missing, not applicable, unknown); `missing` wears a red badge with the word in it while any app is missing the job, and the internal page's table has each app's state in a "MySQL 5.6 CI" column beside PROCTOR's. - **Booster hop record**: apps by how their last committed Booster run ended, from the `booster-hop.json` Booster writes at the repository root after a real upgrade run: `pass`, `fail` (a hop's gate or checks failed), and `none` for an app with no record or one that could not be read (that one also gets a scan note). In the internal view each app carries its `booster` result, the `booster_version` that wrote the record and `booster_at`, when the run finished. A pass says the app's last hop landed, not that the app is current: read it beside the PHP image. The dashboard shows the three counts as panels after the MySQL 5.6 ones (pass, fail, no record); `fail` wears a red badge with the word in it while any app's last hop failed, and the internal page's table has each app's result in a "Booster" column before Drift. - **Drift**, counted per kind: `image_eol`, `image_unknown`, `image_below_floor`, `floor_allows_eol`, `floor_unbounded`, `eol_past_grace` (past the policy's grace days), `laravel_eol`, `proctor_missing`, `proctor_failing`, `override_expired`. - **Progress**: apps that moved since the previous scan and apps that went from an EOL image to a supported one. In the internal view each upgraded app carries the day it landed. - **EOL burn-down**: for each scan day, how many apps ran an EOL image on that day. It reads the image, not the declared floor, so until an image export is configured every app is `unknown` here even when the floor table already shows EOL versions. - **The roll per version, scan after scan**: each burn-down day also carries the same apps counted three ways, so a dashboard can chart which lines the fleet is leaving and which it is joining. Counts only, never an app name: - `states`: per support state on that day (`active`, `security_only`, `eol`, `unknown`); `supported` is `active` plus `security_only`. - `php_image`: per PHP minor of the image, in version order with `unknown` last, such as `{"8.1": 3, "8.4": 9, "unknown": 2}`. - `laravel`: per Laravel major, the same way. An app with no Laravel, or one Rollcall could not read, is `unknown`. The breakdown is worked out from each stored snapshot when the report is built, so snapshots written before it existed (Rollcall 0.1.9 and older) get one too, and the stored snapshot format is unchanged (`schema_version` 1). It reaches back as far as `rollcall prune` keeps snapshots (`ROLLCALL_RETENTION_DAYS`). A report written by 0.1.9 or older has no `states`, `php_image` or `laravel` on its burn-down days: read that as "no breakdown", not as zero apps. - **Forced image upgrades**: with [Citadel's export](https://rollcall.apps.wayne.edu/docs/guides/citadel.html) as the image source, how many apps have a forced base-image upgrade pending, how many are due today or earlier, and the next date (`forced_upgrades`, counts only). The same counts reach [metrics](https://rollcall.apps.wayne.edu/docs/guides/metrics.html) and ADVISOR's `rollcall_fleet_summary` ([ADVISOR](https://rollcall.apps.wayne.edu/docs/guides/advisor.html)). The internal per-app list carries each app's `upgrade_due`. All three are zero with any other image source. The dashboard shows the three as panels under "Apps present" (apps with an upgrade pending, due today or earlier, the next date ahead); "Due today or earlier" wears a red badge with the words in it while any app's date has come, and the internal page's table has each app's date in an "Upgrade due" column beside its image state, in the same badge once the report's day has reached it ("2026-11-01, date has come"). State is never decided in code: it is derived from the dates in `policy.json` by CREED's reader. A version the policy does not list is `unknown`. --- Source: https://rollcall.apps.wayne.edu/docs/guides/wsu-values.html ## WSU values (Playbook) [#](https://rollcall.apps.wayne.edu/docs/guides/wsu-values.html#wsu-values-playbook) This page says which setting may come from Playbook, and how to get Playbook into your app. Next: [Metrics](https://rollcall.apps.wayne.edu/docs/guides/metrics.html). `ROLLCALL_GITLAB_URL` is a Wayne State value, so it may come from Playbook (`waynestate/playbook`) when the environment has none. The environment always wins; Playbook only fills what the environment leaves out. The GitLab token never comes through Playbook and stays an environment variable. | Setting | Value | | --- | --- | | `ROLLCALL_GITLAB_URL` | The `https://` base URL of the GitLab instance | Playbook is private and lives on git.wayne.edu. Getting it into your app: Composer: add the repository to your `composer.json`, then require the package. Composer authenticates to git.wayne.edu with the token in `auth.json`. ```json { "repositories": [ {"type": "vcs", "url": "https://git.wayne.edu/enterprise-apps/playbook.git"} ] } ``` ``` composer require waynestate/playbook ``` curl (Linux, macOS): ``` curl --fail -H "PRIVATE-TOKEN: $GITLAB_TOKEN" "https://git.wayne.edu/api/v4/projects/enterprise-apps%2Fplaybook/repository/files/playbook.env/raw?ref=main" -o .env.playbook ``` PowerShell (Windows): ``` Invoke-WebRequest -Headers @{ 'PRIVATE-TOKEN' = $env:GITLAB_TOKEN } -Uri "https://git.wayne.edu/api/v4/projects/enterprise-apps%2Fplaybook/repository/files/playbook.env/raw?ref=main" -OutFile .env.playbook ``` Clone: ``` git clone https://git.wayne.edu/enterprise-apps/playbook.git ``` The token is your own: `read_api` for curl, `read_repository` for clone and Composer. Playbook is private on git.wayne.edu. If you get a 404, ask the Enterprise Applications team for read access. --- Source: https://rollcall.apps.wayne.edu/docs/ ## Rollcall [#](https://rollcall.apps.wayne.edu/docs/#rollcall) This page says what Rollcall is and where it sits in the stack. Next: [install it](https://rollcall.apps.wayne.edu/docs/install.html), then run the [quick start](https://rollcall.apps.wayne.edu/docs/guides/quick-start.html). > Every app answers "present". The ones on PHP 7.4 answer from the back row. Front page: [`site/index.html`](https://github.com/waynestate/rollcall/blob/main/site/index.html). It is static, with no build step (see [`site/README.md`](https://github.com/waynestate/rollcall/blob/main/site/README.md)). On Citadel, the raw-PHP deploy layer in [`deploy/`](https://github.com/waynestate/rollcall/tree/main/deploy) serves it: a Squire kit whose front controller puts `site/` behind HELMET's security headers. For local development, serve `site/` directly. Rollcall is the fleet scanner for the Wayne State application stack. For each app it records the PHP image, the lowest PHP its `composer.json` allows, the Laravel version, the auth package and its version, the PROCTOR result, and, when the app commits one, the result, Booster version and finish time of Booster's hop record (`booster-hop.json`). Then it looks up each version by date in CREED's `policy.json`. It keeps one snapshot per scan, so you can see drift and an EOL burn-down over time. It prunes old snapshots after the retention window (default 90 days; the newest one always stays). Rollcall enforces nothing. It never opens an issue, leaves a comment or deploys anything, and `scan` and `report` exit `0` whatever the fleet looks like (only `rollcall owners`, a check of the owners file, exits `1`). The public report has totals only: counts and progress, no app names, owners or rankings. The per-app list is internal. Like a good attendance sheet, it is for noticing who is missing, not for shaming them. ![A page of Rollcall's roll book: seventeen sample apps called down the register one at a time, each answered with a stamp: seven present, five late, four back row and one inaudible.](https://rollcall.apps.wayne.edu/docs/readme/register.svg) One page of the roll book, called name by name. Sample data: the apps are fictional, and a real scan's per-app list stays internal. ### Where it sits in the stack [#](https://rollcall.apps.wayne.edu/docs/#where-it-sits-in-the-stack) The parts of the Wayne State application stack, and their jobs. WELD is the Laravel starter app that has most of them installed: | Part | Job | | --- | --- | | WayneUI (project 0) | The interface layer: tokens, components, four consumer paths | | CREED | The standards and `policy.json`, the dates Rollcall reads | | PROCTOR | Measures one app against the policy; Rollcall reads its JSON report and never re-runs a rule | | SESAME | Protocol-neutral auth; Rollcall reports which auth package each app uses | | HELMET | Baseline runtime and its own optional `/metrics` | | Sourdough | Starters for every app shape | | Squire | The Citadel deploy kit; the layer that serves this repo's front page is one | | Parity | Citadel on your computer: its PHP image, its proxy and MySQL 5.6, so an app that works here works on Citadel (0.1.0; site: [parity.apps.wayne.edu](https://parity.apps.wayne.edu/)) | | Preflight | CI templates | | Pinstripe | The coding standard this repo includes for its Pint and PHPStan settings | | Booster | The upgrade tool; Rollcall reads its hop record (`booster-hop.json`) to see who is catching up | | Rollcall | The fleet census and EOL burn-down | | Drawbridge | The one OpenID Connect front door for the Citadel | | ADVISOR | The stack's read-only MCP server; Rollcall's module gives it three fleet tools | | WELD | The Laravel starter app with most of the stack installed | **The whole class** WayneUI and the stack. Everyone is here today; the ones in the back row know who they are. [![WayneUI](https://rollcall.apps.wayne.edu/docs/readme/cast/wayneui.png)](https://github.com/waynestate/wayne-ui) [![CREED](https://rollcall.apps.wayne.edu/docs/readme/cast/creed.png)](https://github.com/waynestate/creed) [![PROCTOR](https://rollcall.apps.wayne.edu/docs/readme/cast/proctor.png)](https://github.com/waynestate/proctor) [![SESAME](https://rollcall.apps.wayne.edu/docs/readme/cast/sesame.png)](https://github.com/waynestate/sesame) [![HELMET](https://rollcall.apps.wayne.edu/docs/readme/cast/helmet.png)](https://github.com/waynestate/helmet) [![Sourdough](https://rollcall.apps.wayne.edu/docs/readme/cast/sourdough.png)](https://github.com/waynestate/sourdough) [![Squire](https://rollcall.apps.wayne.edu/docs/readme/cast/squire.png)](https://github.com/waynestate/squire) [![Parity](https://rollcall.apps.wayne.edu/docs/readme/cast/parity.png)](https://git.wayne.edu/enterprise-apps/parity) [![Preflight](https://rollcall.apps.wayne.edu/docs/readme/cast/preflight.png)](https://github.com/waynestate/preflight) [![Pinstripe](https://rollcall.apps.wayne.edu/docs/readme/cast/pinstripe.png)](https://github.com/waynestate/pinstripe) [![Booster](https://rollcall.apps.wayne.edu/docs/readme/cast/booster.png)](https://github.com/waynestate/booster) [![Rollcall](https://rollcall.apps.wayne.edu/docs/readme/cast/rollcall.png)](https://github.com/waynestate/rollcall) [![Drawbridge](https://rollcall.apps.wayne.edu/docs/readme/cast/drawbridge.png)](https://git.wayne.edu/enterprise-apps/drawbridge) [![ADVISOR](https://rollcall.apps.wayne.edu/docs/readme/cast/advisor.png)](https://github.com/waynestate/advisor) [![WELD](https://rollcall.apps.wayne.edu/docs/readme/cast/weld.png)](https://github.com/waynestate/weld) Images are regenerated from the front page by [`scripts/readme-art`](https://github.com/waynestate/rollcall/tree/main/scripts/readme-art). Present. **The brand board (the cover of the book)** ![Rollcall's brand board: the open roll-book mark with a gold tick on a green tile, lockups, the green, gold and cream palette, type, favicons, and do and don't panels.](https://rollcall.apps.wayne.edu/docs/readme/board.jpg) ### Install [#](https://rollcall.apps.wayne.edu/docs/#install) One line: ``` composer require waynestate/rollcall ``` The first command is `php bin/rollcall scan`; the [quick start](https://rollcall.apps.wayne.edu/docs/guides/quick-start.html) runs it on the fixtures in the repo, and [Install](https://rollcall.apps.wayne.edu/docs/install.html) has the rest. --- Source: https://rollcall.apps.wayne.edu/docs/install.html ## Install [#](https://rollcall.apps.wayne.edu/docs/install.html#install) This page is the install. Next: run the [quick start](https://rollcall.apps.wayne.edu/docs/guides/quick-start.html). ``` composer require waynestate/rollcall ``` Rollcall is on Packagist, so no extra repository is needed. Requires PHP `^8.3`. The CLI is `vendor/bin/rollcall`. Optional: `composer require symfony/mailer` only if Rollcall should mail the [owner digests](https://rollcall.apps.wayne.edu/docs/guides/digest.html) itself (`rollcall digest --send`). Printing them, or writing them to files, needs nothing extra. ### Versions [#](https://rollcall.apps.wayne.edu/docs/install.html#versions) 1.2.0 is the current release, and Composer's `^1.0` takes every 1.x. From 1.0 Rollcall follows SemVer against its [contract](https://rollcall.apps.wayne.edu/docs/reference/contract.html): inside 1.x the report, the stored snapshot and the image list may gain a field or an enum value (a minor release), but never lose or retype one; that takes a 2.0. What changed in each release is in the [changelog](https://git.wayne.edu/enterprise-apps/rollcall/-/blob/main/CHANGELOG.md). --- Source: https://rollcall.apps.wayne.edu/docs/reference/commands.html ## Commands [#](https://rollcall.apps.wayne.edu/docs/reference/commands.html#commands) This page lists the commands (generated from the CLI) and what each one prints, plus the exit codes. | Command | What it does | | --- | --- | | `rollcall advisories` | Check locked package versions against a saved Packagist security-advisories response. | | `rollcall digest` | Print (or write, or send) each opted-in owner's digest of what changed in their apps. | | `rollcall drift` | Compare policy.json with a saved endoflife.date v1 product file. | | `rollcall owners` | List the scanned apps whose owner is unknown (no owners-file entry, or none confirmed within ROLLCALL_OWNERS_CONFIRM_DAYS); exit 1 when there is one. | | `rollcall prune` | Delete snapshots older than the retention window; the newest is never deleted. | | `rollcall report` | Print the fleet report from the stored snapshots. | | `rollcall scan` | Scan the fleet read-only and store a snapshot. | #### `rollcall advisories` [#](https://rollcall.apps.wayne.edu/docs/reference/commands.html#rollcall-advisories) Check locked package versions against a saved Packagist security-advisories response. Usage: `rollcall advisories [--today TODAY] [--feed FEED]` | Option | Meaning | Default | | --- | --- | --- | | `--today=VALUE` | Override today's date (YYYY-MM-DD). | | | `--feed=VALUE` | Path to the saved Packagist security-advisories JSON. | | | `--silent` | Do not output any message | | #### `rollcall digest` [#](https://rollcall.apps.wayne.edu/docs/reference/commands.html#rollcall-digest) Print (or write, or send) each opted-in owner's digest of what changed in their apps. Usage: `rollcall digest [--today TODAY] [--owner OWNER] [--format FORMAT] [--out OUT] [--send]` | Option | Meaning | Default | | --- | --- | --- | | `--today=VALUE` | Override today's date (YYYY-MM-DD). | | | `--owner=VALUE` | Only this contact from the owners file. | | | `--format=VALUE` | text or json. | `text` | | `--out=VALUE` | Write one text file per digest into this directory instead of printing them. | | | `--send` | Mail the digests. Needs ROLLCALL_DIGEST_MAIL_ENABLED=true, ROLLCALL_DIGEST_MAIL_DSN and ROLLCALL_DIGEST_MAIL_FROM. | | | `--silent` | Do not output any message | | #### `rollcall drift` [#](https://rollcall.apps.wayne.edu/docs/reference/commands.html#rollcall-drift) Compare policy.json with a saved endoflife.date v1 product file. Usage: `rollcall drift [--today TODAY] [--feed FEED] [--component COMPONENT]` | Option | Meaning | Default | | --- | --- | --- | | `--today=VALUE` | Override today's date (YYYY-MM-DD). | | | `--feed=VALUE` | Path to the saved endoflife.date JSON. | | | `--component=VALUE` | Policy component to compare. | `php` | | `--silent` | Do not output any message | | #### `rollcall owners` [#](https://rollcall.apps.wayne.edu/docs/reference/commands.html#rollcall-owners) List the scanned apps whose owner is unknown (no owners-file entry, or none confirmed within ROLLCALL_OWNERS_CONFIRM_DAYS); exit 1 when there is one. Usage: `rollcall owners [--today TODAY] [--format FORMAT]` | Option | Meaning | Default | | --- | --- | --- | | `--today=VALUE` | Override today's date (YYYY-MM-DD). | | | `--format=VALUE` | text or json. | `text` | | `--silent` | Do not output any message | | #### `rollcall prune` [#](https://rollcall.apps.wayne.edu/docs/reference/commands.html#rollcall-prune) Delete snapshots older than the retention window; the newest is never deleted. Usage: `rollcall prune [--today TODAY] [--days DAYS] [--dry-run]` | Option | Meaning | Default | | --- | --- | --- | | `--today=VALUE` | Override today's date (YYYY-MM-DD). | | | `--days=VALUE` | Retention window in days (default: ROLLCALL_RETENTION_DAYS, 90; 0 keeps everything). | | | `--dry-run` | List what would be deleted without deleting anything. | | | `--silent` | Do not output any message | | #### `rollcall report` [#](https://rollcall.apps.wayne.edu/docs/reference/commands.html#rollcall-report) Print the fleet report from the stored snapshots. Usage: `rollcall report [--today TODAY] [--format FORMAT] [--internal]` | Option | Meaning | Default | | --- | --- | --- | | `--today=VALUE` | Override today's date (YYYY-MM-DD). | | | `--format=VALUE` | text, json or prometheus. | `text` | | `--internal` | Include the per-app list. Internal only: do not publish it. | | | `--silent` | Do not output any message | | #### `rollcall scan` [#](https://rollcall.apps.wayne.edu/docs/reference/commands.html#rollcall-scan) Scan the fleet read-only and store a snapshot. Usage: `rollcall scan [--today TODAY] [--prune [PRUNE]]` | Option | Meaning | Default | | --- | --- | --- | | `--today=VALUE` | Override today's date (YYYY-MM-DD). | | | `--prune=VALUE` | After saving, delete snapshots older than this many days (default: ROLLCALL_RETENTION_DAYS, 90; 0 keeps everything). | | | `--silent` | Do not output any message | | #### Options every command accepts [#](https://rollcall.apps.wayne.edu/docs/reference/commands.html#options-every-command-accepts) | Option | Meaning | Default | | --- | --- | --- | | `-h`, `--help` | Display help for the given command. When no command is given display help for the list command | | | `-q`, `--quiet` | Only errors are displayed. All other output is suppressed | | | \`-v | -vv | -vvv`, `--verbose\` | | `-V`, `--version` | Display this application version | | | `--ansi` | Force (or disable --no-ansi) ANSI output | | | `--no-ansi` | Negate the "--ansi" option | | | `-n`, `--no-interaction` | Do not ask any interactive question | | - `scan` scans once and stores `/.json`. A second scan on the same day replaces it. A gap in one source (a missing report, a bad image tag) becomes a note on that app, and the scan carries on. A refused GitLab token stops the scan loudly instead of producing a flattering partial answer. `--prune[=DAYS]` deletes snapshots older than that many days after saving (default: `ROLLCALL_RETENTION_DAYS`, 90; 0 keeps everything). - `report` prints the latest snapshot against the policy as of today. `text` is a terminal table, `json` is the machine-readable form, `prometheus` is the metrics text (refused unless `ROLLCALL_METRICS_ENABLED=true`). `--internal` adds the per-app list; keep that output inside the project. - `drift` compares `policy.json` with a saved endoflife.date v1 product page (for example `https://endoflife.date/api/v1/products/php/` saved to a file). A difference is a flag for a person to look at; the policy stays the source of truth. Rollcall does not fetch that page itself. - `advisories` checks each app's locked `laravel/framework` and auth-package versions against a saved Packagist security-advisories response (for example `https://packagist.org/api/security-advisories/?packages[]=laravel/framework` saved to a file). One line per package and version, sorted by package then version: the status (`affected`, `clear` or `no data`), the count and the advisory ids, and how many apps hold that pair. A package with no advisory data prints `no data`, never `safe`: an absent row proves nothing about the package, and a version nobody can parse says `no data` too. Rollcall does not fetch that page itself; a person saves it and `--feed` points at the file. Output is package names and counts only: no app ids. - `prune` deletes snapshots older than `--days` (default: `ROLLCALL_RETENTION_DAYS`, 90; 0 keeps everything). The newest snapshot is never deleted, even if it is older than the cut-off, so the dashboard always has data. `--dry-run` lists what would go without deleting anything. Exit codes: `0` ok, `1` owner unknown (`rollcall owners` only), `2` tool error (a bad option value, an unreadable policy, a source that refused). Rollcall does not gate the fleet, so no command exits `1` over what the apps run: `rollcall owners` exits `1` while an app's owner is unknown, and that is the register, not the fleet. A misspelled command or an option the CLI does not know never reaches Rollcall: the console library prints the usage and exits `1`. --- Source: https://rollcall.apps.wayne.edu/docs/reference/configuration.html ## Configuration [#](https://rollcall.apps.wayne.edu/docs/reference/configuration.html#configuration) This page covers how Rollcall is configured, all through environment variables. Next: [run the collector in Docker](https://rollcall.apps.wayne.edu/docs/guides/collector-docker.html) with them. Every setting is an environment variable. `.env.example` holds placeholders; never commit a real token. | Variable | Meaning | Default | Read in | | --- | --- | --- | --- | | ROLLCALL_AUTH_PACKAGES | Comma-separated Composer packages that count as an auth package | the built-in list | config/rollcall.php | | ROLLCALL_CITADEL_EXPORT | Citadel's saved registrations export, used instead of ROLLCALL_IMAGES_FILE (not both): base images plus forced upgrade dates. See the Citadel guide | none | config/rollcall.php | | ROLLCALL_DASHBOARD_ENABLED | Laravel and raw PHP: serve the dashboard page | `false` | config/rollcall.php | | ROLLCALL_DASHBOARD_INERTIA | Laravel + Inertia: answer the dashboard routes with the app's Vue page (Rollcall/Dashboard, published with vendor:publish --tag=rollcall-inertia) instead of the Blade view; same switches, same report. Needs inertiajs/inertia-laravel | `false` | config/rollcall.php | | ROLLCALL_DASHBOARD_PATH | Laravel: dashboard URL path | `rollcall` | config/rollcall.php | | ROLLCALL_DIGEST_MAIL_DSN | Symfony Mailer DSN for sending, such as smtp://mail.example.test:25. A secret: never in git, never printed | none | src/Config.php | | ROLLCALL_DIGEST_MAIL_ENABLED | Allow `rollcall digest --send` to mail | `false` | src/Config.php | | ROLLCALL_DIGEST_MAIL_FROM | The from address of the digests | none | src/Config.php | | ROLLCALL_GITLAB_GROUPS | Comma-separated group ids or paths; subgroups are included. Ignored when ROLLCALL_GITLAB_PROJECTS is set | none | config/rollcall.php | | ROLLCALL_GITLAB_PROJECTS | Comma-separated full group/project paths; when set, only those projects are scanned and no group is listed | none | config/rollcall.php | | ROLLCALL_GITLAB_TOKEN | A GitLab group or project access token (a bot), or a service account's token, with the read_api scope only, the Reporter role and an expiry. The stack's is the group token rollcall-scanner, rotated by the stack maintainer (docs/security.md). Never in git, never logged, never printed | none | config/rollcall.php | | ROLLCALL_GITLAB_URL | https:// base URL of the GitLab instance | none | config/rollcall.php | | ROLLCALL_IMAGES_FILE | Export of the app list: {"apps": \[{"project": "group/project", "image": "php:8.4-apache"}\]} | none | config/rollcall.php | | ROLLCALL_INTERNAL_ENABLED | Laravel and raw PHP: serve the per-app page (Laravel at `/apps` behind your sign-in middleware; raw PHP only where you call rollcall_dashboard(\['internal' => true\]) behind your sign-in) | `false` | config/rollcall.php | | ROLLCALL_METRICS_ALLOW | Comma-separated scraper IP addresses (exact match) | none | config/rollcall.php | | ROLLCALL_METRICS_ENABLED | Turn metrics on (CLI report --format=prometheus and /metrics) | `false` | config/rollcall.php | | ROLLCALL_METRICS_TOKEN | Bearer token a scraper must present | none | config/rollcall.php | | ROLLCALL_OWNERS_CONFIRM_DAYS | How long an owners-file entry's "confirmed" date counts; past it, `rollcall owners` calls that owner unknown and exits 1 | `365` (0 turns the check off) | src/Config.php | | ROLLCALL_OWNERS_FILE | Owners file for the digests: who answers for which apps, and who opted in with "digest": true. Rollcall's own, for the stack's projects, is owners.json in the repo (roles only); keep another fleet's outside a public repo | none (no digests) | src/Config.php | | ROLLCALL_POLICY_FILE | Path to CREED's policy.json | none (required for report, drift) | config/rollcall.php | | ROLLCALL_PROCTOR_ARTIFACT | ROLLCALL_PROCTOR_SOURCE=gitlab: the PROCTOR --format=json report's path inside that job's artifact | `proctor.json` | config/rollcall.php | | ROLLCALL_PROCTOR_DIR | PROCTOR JSON reports, one per app: group/project is read from group\_\_project.json. Not read when ROLLCALL_PROCTOR_SOURCE is gitlab | none | config/rollcall.php | | ROLLCALL_PROCTOR_JOB | ROLLCALL_PROCTOR_SOURCE=gitlab: the CI job whose artifact holds the report; set it when Preflight's proctor component is included with another job_name | `proctor` | config/rollcall.php | | ROLLCALL_PROCTOR_SOURCE | Where PROCTOR reports come from: directory (ROLLCALL_PROCTOR_DIR) or gitlab (each project's proctor job artifact from its newest finished default-branch pipeline, read with the same read_api token and GitLab settings). See the architecture page | `directory` | config/rollcall.php | | ROLLCALL_PUBLIC_REPORT_ENABLED | Serve GET /report.json (public counts only) | `false` | config/rollcall.php | | ROLLCALL_REPOS_DIR | Fixture repositories as `//composer.{json,lock}`, plus `booster-hop.json` where an app has one | none | config/rollcall.php | | ROLLCALL_RETENTION_DAYS | How many days of snapshots to keep; the newest is never deleted | `90` (0 keeps everything) | config/rollcall.php | | ROLLCALL_SOURCE | directory (fixtures) or gitlab | `directory` | config/rollcall.php | | ROLLCALL_STORE_DIR | Snapshot directory, the only place Rollcall writes | `var/snapshots` | config/rollcall.php | | ROLLCALL_WAYNEUI_CSS | Laravel and raw PHP: https:// or absolute URL of WayneUI's stylesheet for the dashboard | none | config/rollcall.php | #### Auth packages [#](https://rollcall.apps.wayne.edu/docs/reference/configuration.html#auth-packages) `ROLLCALL_AUTH_PACKAGES` is checked in list order, and the first entry that matches an app wins. An entry with a slash matches that package exactly; an entry without a slash is a bare package name and matches that package under any vendor, so `wayne-cas` matches `anyvendor/wayne-cas`. The report carries the real locked package name, vendor included. The built-in list is `waynestate/sesame`, `waynestate/wayne-cas`, `apereo/phpcas`, `jasig/phpcas`, `subfission/cas`, `wayne-cas` and `simplecas`; the exact `waynestate/wayne-cas` entry comes first, so it still wins over the bare `wayne-cas` entry. To scan GitLab you need the token and either a group or the project allowlist. The narrow way is `ROLLCALL_GITLAB_PROJECTS`: name the exact `group/project` paths and Rollcall reads only those, never listing a group. Otherwise set `ROLLCALL_GITLAB_GROUPS`. The token is a GitLab bot or personal access token with `read_api` only and an expiry, whose user can read only the projects to scan; until it exists Rollcall runs on its fixtures. Set `ROLLCALL_SOURCE=gitlab` and the GitLab variables. The `rollcall-scan` job in `.gitlab-ci.yml` does this on a schedule or by hand. Rollcall sends only `GET` and `HEAD`, fetches the two Composer files and Booster's `booster-hop.json` without cloning, skips a Composer file whose blob id has not changed, follows `Link` pagination only to the configured host, and waits out `429 Retry-After`. With `ROLLCALL_PROCTOR_SOURCE=gitlab` the same token reads each project's `proctor.json` from its proctor job's artifact. Only apps whose CI keeps that file as an artifact have one to read: Preflight 0.5.0 or later, or a proctor job of their own that does. See [where PROCTOR results come from](https://rollcall.apps.wayne.edu/docs/architecture.html#where-proctor-results-come-from). --- Source: https://rollcall.apps.wayne.edu/docs/reference/contract.html ## Contract [#](https://rollcall.apps.wayne.edu/docs/reference/contract.html#contract) This page covers the shapes Rollcall promises to anyone who reads its output. Next: the [Proof](https://rollcall.apps.wayne.edu/docs/reference/proof.html) of a real run. The contract lives in [`contract/`](https://github.com/waynestate/rollcall/tree/main/contract) as JSON Schema (draft 2020-12). `tests/ContractTest.php` runs the real commands on the fixtures, then validates what they print and store against these files, so the code and the contract cannot drift apart. A dashboard, a Grafana import, ADVISOR or a script should read Rollcall against these schemas, not against an example it once saw. | Schema | What it describes | Who produces it | | --- | --- | --- | | `report.schema.json` | `rollcall report --format=json` and `GET /report.json`, public and internal views | Rollcall | | `snapshot.schema.json` | One stored scan, `/.json` (internal: it holds app ids) | Rollcall | | `images-export.schema.json` | The image list behind `ROLLCALL_IMAGES_FILE` | Any platform, or a hand-kept file | | `citadel-export.schema.json` | The Citadel registrations export behind `ROLLCALL_CITADEL_EXPORT` | A person or a job, from Citadel | | `owners.schema.json` | The owners file behind `ROLLCALL_OWNERS_FILE`: Rollcall's own `owners.json` (roles only) or a fleet's own (internal) | The people who run Rollcall | | `digest.schema.json` | `rollcall digest --format=json` (internal: it names apps) | Rollcall | | `owners-check.schema.json` | `rollcall owners --format=json`, the latest scan checked against the owners file (internal: it names apps) | Rollcall | ### What the suite checks [#](https://rollcall.apps.wayne.edu/docs/reference/contract.html#what-the-suite-checks) - The public and internal JSON reports, after one scan and after two, match `report.schema.json`. - `GET /report.json` from the raw-PHP endpoint matches the same schema. - Every stored snapshot matches `snapshot.schema.json`, and its `schema_version` equals the code's. - The image list, Citadel export and owners fixtures, and Rollcall's own `owners.json`, match their input schemas, a report and snapshot built from the Citadel export match theirs, `rollcall digest --format=json` matches `digest.schema.json`, and `rollcall owners --format=json` matches `owners-check.schema.json`. - The drift kinds in the schema are exactly the ones the report builder counts, in the same order. - The schema has teeth: a public report with a per-app list, an `owner` field or a made-up drift kind is refused, and so is an internal report without its list. Every other schema refuses a case too: a snapshot of an unknown `schema_version` or with an `owner`, an image entry without its image, a Citadel upgrade whose date is not a date, an owner without a contact or with a project that is not a group/project path, a digest without `no_owner_on_file`, and an owners check with a `rank`. - Every schema in `contract/` is validated against real output or a fixture and has a case it must refuse, or the suite fails, so a new schema cannot land unchecked. It reads fixtures only and never calls GitLab, Citadel or any other host. Run it alone with `vendor/bin/phpunit tests/ContractTest.php`; `composer ci` runs it with everything else. ### Rules [#](https://rollcall.apps.wayne.edu/docs/reference/contract.html#rules) - **Closed objects.** Rollcall's own output uses `additionalProperties: false` throughout, so a new field is a contract change made in the same commit as the code. Inputs stay open: a producer may add fields of its own, and Rollcall ignores them. - **Public means counts.** The public report may never carry `apps` or `scan_errors`, and no field holds an owner, a rank or a score. - **Versioning.** From 1.0.0 on, Rollcall follows SemVer against this contract: an added field or enum value is a minor release; a removed or renamed field or a changed type is a major release. A snapshot carries its own `schema_version` (1 today), and a reader refuses a version it does not know. --- Source: https://rollcall.apps.wayne.edu/docs/reference/proof.html ## Proof [#](https://rollcall.apps.wayne.edu/docs/reference/proof.html#proof) This page says how Rollcall was proven on real repositories: what ran, what held, what the runs caught in Rollcall itself, and what they do not prove yet. Next, see [What the report says](https://rollcall.apps.wayne.edu/docs/guides/what-the-report-says.html) for how to read the output quoted here. A register is only worth something on a day with real students in the room. Rollcall had two such days on 2026-11-06. ### Last run [#](https://rollcall.apps.wayne.edu/docs/reference/proof.html#last-run) | Check | Date | Commit | Result | Duration | | --- | --- | --- | --- | --- | | `composer ci` | 2026-11-07 | `aed8dd9` | pass: manifest, 199 tests / 1220 assertions, style, generated files, static analysis, audit | 181.3 s | | `rollcall scan` | 2026-11-07 | `aed8dd9` | pass: 4 fixture apps present, 2 notes (no image source, no PROCTOR reports) | 1.1 s | | `rollcall report` | 2026-11-07 | `aed8dd9` | pass: text report, 4 apps | 1.0 s | | `rollcall report --format=json` | 2026-11-07 | `aed8dd9` | pass: JSON report, 4 apps | 1.0 s | | `rollcall report --format=json --internal` | 2026-11-07 | `aed8dd9` | pass: internal JSON, 4 apps | 1.0 s | | `rollcall report --format=prometheus` | 2026-11-07 | `aed8dd9` | pass: Prometheus text, 4 apps | 1.2 s | | `rollcall advisories` (saved feed) | 2026-11-07 | `aed8dd9` | pass: 4 package versions answered, 1 affected, 1 no data | 1.8 s | | `rollcall drift --component=php` (saved feed) | 2026-11-07 | `aed8dd9` | pass: 1 PHP date compared, 1 difference between the feeds | 1.5 s | | `rollcall prune --dry-run` | 2026-11-07 | `aed8dd9` | pass: nothing to prune | 1.2 s | | PROCTOR check on `deploy/` | 2026-11-07 | `aed8dd9` | pass: 14 checks, 12 pass, 2 warn (php-floor, ci-pipelines) | 2.2 s | The rollcall rows ran against the fixtures bundled under `tests/fixtures/` in one `composer:2.10.3` container, with no credentials; the PROCTOR row installed the deploy layer's committed lock first. To refresh this table, re-run `composer ci` and the commands above and rewrite the rows with the new date, commit and durations. The two runs the page describes, the scheduled GitLab CI scan and the 58-repository corpus rerun, need a live service account and the stack's proof corpus, so they are not repeated here; their results stand as recorded below. ### What ran [#](https://rollcall.apps.wayne.edu/docs/reference/proof.html#what-ran) **1. The scheduled scan on GitLab CI.** The weekly `rollcall-scan` job (see [Configuration](https://rollcall.apps.wayne.edu/docs/reference/configuration.html)) ran on its schedule for the first time, on the canonical GitLab, against the 13 stack projects. It used a read-only service account that can see those 13 projects and nothing else, with a `read_api` token held in a masked CI variable. Rollcall 0.1.9 from `main`, `composer:2.10.3`, no image export and no PROCTOR reports configured. **2. A rerun over the stack's proof corpus.** The shared corpus is every PHP repository in the stack's census of Wayne State applications: 95 repositories, of which 58 have a `composer.json` (54 with a `composer.lock`). Rollcall's directory source reads exactly those two files, so only those two files were copied out of a Linux checkout of each repository. The rerun used the same Rollcall commit plus the change described below, CREED's released `policy.json`, and `--today=2026-11-06`, in one `composer:2.10.3` container with no network: 1. `rollcall scan`, then `rollcall report` as text, JSON, internal JSON and Prometheus text; 2. `rollcall advisories` against a saved Packagist security-advisories response for `laravel/framework` and the known auth packages; 3. `rollcall drift --component=php` against a saved endoflife.date page for PHP; 4. `rollcall prune --dry-run`. The 13 stack projects were scanned the same way from their committed files, as a cross-check on the CI run. A run **passes** when every command exits 0 and every repository with a `composer.json` gets a row. A **tool error** is Rollcall breaking: a crash, an exit 2, a repository silently missing from the snapshot, or a number that disagrees with the files. ### Results [#](https://rollcall.apps.wayne.edu/docs/reference/proof.html#results) | Run | Read | Rows | Tool errors | Time | | --- | --- | --- | --- | --- | | CI schedule | 13 stack projects | 13 | 0 | 23 s job, 11 s scan | | Rerun: stack | 13 stack projects | 13 | 0 | 1.3 s scan | | Rerun: corpus | 58 repositories | 58 | 0 | 1.4 s scan | The CI job's 23 seconds include installing Rollcall; the scan itself, 26 file reads over the GitLab API, took about 11. Each report over the corpus took under 4 seconds. - **The CI scan read exactly what is committed.** The snapshot records the Git blob id of every file it read, and each id matched `main` of its project. The local rerun of the same 13 projects gave the same answer: every project declares a PHP floor of 8.3, and one of them (WELD) locks Laravel 13 and SESAME as its auth package. That is the fleet the stack wants every app to look like: one row, one floor, no back row. - **Every corpus repository answered.** All 58 got a row with its declared PHP floor, Laravel line (18 of them run Laravel, from 5.8 to 13) and auth package. The ones with no PHP constraint at all are counted as unbounded, not guessed. - **Advisories answered for every Laravel version** in the corpus from the saved feed, and said `no data` for the in-house packages Packagist has never heard of, including two locked to a development branch. That is the documented behavior: an absent row is never reported as safe. - **Drift:** CREED's policy and endoflife.date agree on every PHP date they both state. - **Prune** found nothing to prune, as it should with one fresh snapshot. - The fleet tallies themselves (how many apps sit on which version) stay with the stack team, the same way Rollcall keeps its own per-app list internal. ### The warning on the scheduled pipeline [#](https://rollcall.apps.wayne.edu/docs/reference/proof.html#the-warning-on-the-scheduled-pipeline) The pipeline that ran the scan finished green with one warning. It was not the scan: it was the allowed-to-fail PROCTOR job that checks the front page's own deploy layer (`deploy/`). Run again locally it says: - `composer-audit` **fail**: the deploy layer's lock held `symfony/http-foundation` and `symfony/yaml` 7.4.22, with five security advisories between them. Symfony 7.4.23 fixes them, and the deploy lock moved to it the same night. - `ci-pipelines` **warn**: `deploy/` has no `.gitlab-ci.yml`. True and harmless: the pipeline lives at the repository root. - `php-floor` **warn**: PHP 8.3 is in security-only support until 2027-12-31. So the one warning on Rollcall's first real attendance day was Rollcall's own homework, found by PROCTOR, which is the system working. ### What it caught in Rollcall [#](https://rollcall.apps.wayne.edu/docs/reference/proof.html#what-it-caught-in-rollcall) A run that only finds praise was not looking hard enough. Every finding here is about Rollcall, not the apps: - **Confirmed fixed: in-house auth packages.** The first corpus run, on 2026-11-03, counted no auth package for any app, because the built-in list only knew public package names and most of the fleet uses an in-house CAS client under a private vendor name. A bare name in `ROLLCALL_AUTH_PACKAGES` now matches under any vendor. This rerun recognized an auth package in 37 of the 58 repositories, as three packages under two vendor names, and named each with its real vendor. - **Fixed: "scan problems" that were not problems.** The text report's first line said `scan problems: 2` on every run that had no image export and no PROCTOR reports. The 2026-11-03 run took those for two unexplained scan errors and logged them for a look. They are the two notes `scan` prints when a source is not configured. The line now says `scan notes`, and [What the report says](https://rollcall.apps.wayne.edu/docs/guides/what-the-report-says.html) explains the count. The JSON key and the metric keep their names, so nothing that reads them breaks. - **Documented: the burn-down needs the image export.** The EOL burn-down counts apps by the PHP image they run. With no image export every app is `unknown` in it, even while the declared-floor table already shows end-of-life versions. That is the design (a floor is a promise, an image is a fact), and the guide now says so. ### What this does not prove [#](https://rollcall.apps.wayne.edu/docs/reference/proof.html#what-this-does-not-prove) - **No PHP image column yet.** No export of the runtime image per app exists yet, so the image table, the image drift kinds and the burn-down were all `unknown`. Rollcall's image source is tested on fixtures only. - **No PROCTOR column yet.** No PROCTOR reports were fed in, so every app shows `none`. The report source is tested on fixtures only. - **The CI scan covers the stack, not the fleet.** The service account sees the 13 stack projects on purpose. The corpus run covers the fleet, but from copied files, not through the GitLab API. - **One week, one snapshot.** Drift between scans, upgrade credit and pruning only show over weeks of scheduled runs. They are covered by tests, not yet by a real history. - **The advisory and endoflife.date feeds were saved on 2026-11-06.** Their answers are only as fresh as the file a person saved. ### Run it on your own repositories [#](https://rollcall.apps.wayne.edu/docs/reference/proof.html#run-it-on-your-own-repositories) On a folder of repositories laid out as `//composer.{json,lock}`: Linux / macOS ```sh export ROLLCALL_POLICY_FILE=/path/to/creed/policy.json export ROLLCALL_REPOS_DIR=/path/to/repos php bin/rollcall scan php bin/rollcall report ``` Windows ```powershell $env:ROLLCALL_POLICY_FILE = "C:\path\to\creed\policy.json" $env:ROLLCALL_REPOS_DIR = "C:\path\to\repos" php bin/rollcall scan php bin/rollcall report ``` To scan your GitLab on a schedule instead, follow [Configuration](https://rollcall.apps.wayne.edu/docs/reference/configuration.html) and the scheduled scan section of the README. Keep `report --internal` output inside your team. ### Related [#](https://rollcall.apps.wayne.edu/docs/reference/proof.html#related) - [What the report says](https://rollcall.apps.wayne.edu/docs/guides/what-the-report-says.html) - [Commands](https://rollcall.apps.wayne.edu/docs/reference/commands.html) - [Configuration](https://rollcall.apps.wayne.edu/docs/reference/configuration.html) - [Run the collector in Docker](https://rollcall.apps.wayne.edu/docs/guides/collector-docker.html) --- Source: https://rollcall.apps.wayne.edu/docs/reference/scripts.html ## Scripts on every OS [#](https://rollcall.apps.wayne.edu/docs/reference/scripts.html#scripts-on-every-os) This page lists every script Rollcall ships and how each OS runs it. Next: the [contract](https://rollcall.apps.wayne.edu/docs/reference/contract.html) its output keeps. Every developer tool works on Windows, macOS and Linux. Where PHP fits, there is one PHP command and nothing to pair. Where a script drives Docker, it ships twice: a `.ps1` for Windows (PowerShell 5.1 and 7, never bash or WSL) and a `.sh` for Linux and macOS (written for macOS's bash 3.2 and BSD tools). `tests/ScriptPairsTest.php` fails if a script ships without its twin, if a `.sh` uses a bash 4 feature or a GNU-only flag, or if a `.ps1` calls a Unix shell on the host. ### One PHP command, every OS [#](https://rollcall.apps.wayne.edu/docs/reference/scripts.html#one-php-command-every-os) | Command | What it does | | --- | --- | | `php bin/rollcall` (`vendor/bin/rollcall` in an install) | The CLI: `scan`, `report`, `digest`, `owners`, `drift`, `advisories`, `prune` | | `php bin/docs-site.php` (`composer docs`) | Builds the docs site from `docs/` | | `php bin/agent-ready.php` (`composer site:agent-ready`) | Writes the Markdown twins, `llms.txt` and the sitemap | | `php tools/versions-table.php` (`composer site:versions`) | Regenerates the front page versions table from CREED's policy | | `php bin/quickstart-versions.php` (`composer site:versions`) | Regenerates the quick-start printout's policy values in `site/index.html` and `site/index.md` from CREED's policy, between the `quickstart-versions` markers | | `composer site:versions-check` | Fails when the front page versions table or the quick-start printout's policy values are stale; runs in `composer ci` | | `php tools/creed-copy-check.php` (`composer creed-copy:check`) | Proves the CREED copy has not drifted | ### A pair per OS [#](https://rollcall.apps.wayne.edu/docs/reference/scripts.html#a-pair-per-os) | Windows (PowerShell) | Linux and macOS (bash) | What they do | | --- | --- | --- | | `scripts/a11y.ps1` | `scripts/a11y.sh` | The front page accessibility gate: Preflight's a11y checker (vendored in `tools/a11y/check.mjs`, pinned by `tests/A11yCheckerPinTest.php`) in Docker, the same image and inputs as the `a11y-site` CI job | | `scripts/dashboard-a11y.ps1` | `scripts/dashboard-a11y.sh` | The dashboard accessibility gate: renders the public, internal and empty-state dashboard pages with PHPUnit, from Laravel and from the raw-PHP entry point (styled with the bundled WayneUI stylesheet), server-renders the Vue page and fails unless it matches the Laravel page (`tools/vue-dashboard/parity.mjs`), then runs the same axe-core check on all nine, in Docker | | `deploy/scripts/parity.ps1` | `deploy/scripts/parity.sh` | The kit's parity script, replaced by Parity (`parity up`); kept only until Parity lands everywhere | `scripts/readme-art` is a Node tool (`npm run build`), the same on every OS. ### Inside Citadel's container only [#](https://rollcall.apps.wayne.edu/docs/reference/scripts.html#inside-citadel-s-container-only) These run on Citadel's Linux container, never on a developer machine, so they have no Windows twin. Squire writes and owns them (`deploy/.squire.json`): | File | When Citadel runs it | | --- | --- | | `deploy/build.sh` | At image build time, as root, with `/bin/sh` | | `deploy/deployments/001-first-release.sh` | Once, when the first release starts | | `deploy/.squire/portable/squire-entrypoint.sh` | Each time the portable image starts (OpenShift, Coolify, raw Docker), as the container entrypoint | | `deploy/scripts/release.sh` | After every Quick Update (the post-script), and from the first-release hook | ### Inside GitLab CI only [#](https://rollcall.apps.wayne.edu/docs/reference/scripts.html#inside-gitlab-ci-only) This runs in a GitLab CI job on the Linux composer image, never on a developer machine, so it has no Windows twin. It still keeps to POSIX sh and macOS-safe tools, like every `.sh` here. | File | When GitLab runs it | | --- | --- | | `tools/creed-copy-refresh.sh` | The weekly `creed-copy-refresh` job (or a web pipeline on main): re-exports the CREED copy from CREED main, rebuilds the versions table, docs and agent-ready files, runs `composer creed-copy:check` and `composer ci`, and pushes to main with the job token only when both pass | Before a release, a maintainer runs the smoke test on all three OSes; the checklist is in [MAINTAINING.md](https://github.com/waynestate/rollcall/blob/main/MAINTAINING.md), "Smoke test on every OS". --- Source: https://rollcall.apps.wayne.edu/docs/security.html ## Security notes [#](https://rollcall.apps.wayne.edu/docs/security.html#security-notes) This page lists how Rollcall keeps itself and the fleet safe, and exactly what its GitLab token needs. Next: [run the checks](https://rollcall.apps.wayne.edu/docs/checks.html). - Read-only toward GitLab and everything else: one gate in the GitLab adapter allows only `GET` and `HEAD`, and a test fails if a write verb appears in `src/`. - The GitLab token is a group or project access token (a GitLab bot), or a service account's personal access token, with the `read_api` scope only, the Reporter role and an expiry. The stack's own is the group access token `rollcall-scanner` (see [the scanner token and how to rotate it](https://rollcall.apps.wayne.edu/docs/security.html#the-scanner-token-and-how-to-rotate-it)). It goes in the environment as `ROLLCALL_GITLAB_TOKEN`, never in git, is sent only to the configured `https` host, and is hidden from debug output and error messages. When the source is GitLab, `scan` reads the token's own record (`GET /api/v4/personal_access_tokens/self`) and prints a note 14 days before it expires, or when it has already expired. The note names the date; the stack maintainer rotates the token before its expiry, never Rollcall. The check is advisory: a refused, unreachable or unparseable answer prints nothing and never fails the scan, and the token value never appears in output. - Composer files are parsed as data. No `composer install`, script or plugin from a scanned repository ever runs. - PROCTOR reports, image tags and app ids are outside input: shapes are validated, text is bounded, and terminal output strips control characters. ### The GitLab token, exactly [#](https://rollcall.apps.wayne.edu/docs/security.html#the-gitlab-token-exactly) Rollcall needs one scope, `read_api`, and one role, Reporter, on each project it scans. Nothing else. GitLab describes `read_api` as read access to the API for the token's scope, and every call Rollcall makes is a read through the REST API. #### Every call Rollcall makes [#](https://rollcall.apps.wayne.edu/docs/security.html#every-call-rollcall-makes) | Call | When | Why | Covered by | | --- | --- | --- | --- | | `GET /api/v4/groups/:id/projects?include_subgroups=true&simple=true&archived=false&per_page=100` | `ROLLCALL_GITLAB_GROUPS` is set and `ROLLCALL_GITLAB_PROJECTS` is not | Lists the projects to scan, following `Link` pagination to the same host | `read_api` | | `GET /api/v4/projects/:id?simple=true` | `ROLLCALL_GITLAB_PROJECTS` is set (no group is listed) | Reads each named project's id and default branch | `read_api` | | `HEAD /api/v4/projects/:id/repository/files/:file_path?ref=` | Every scan, for `composer.json`, `composer.lock` and `booster-hop.json` | Reads the blob id, so an unchanged Composer file is not fetched again (a 404 means the app has no such file) | `read_api` | | `GET /api/v4/projects/:id/repository/files/:file_path/raw?ref=` | When a file is new or changed | Reads the file's bytes, without cloning | `read_api` | | `GET /api/v4/projects/:id/pipelines?ref=&scope=finished&order_by=id&sort=desc&per_page=5` | `ROLLCALL_PROCTOR_SOURCE=gitlab`, once per project per scan | Finds the newest finished pipelines on the default branch, passed or failed | `read_api` (Reporter reads pipelines) | | `GET /api/v4/projects/:id/pipelines/:pipeline_id/jobs?per_page=100` | `ROLLCALL_PROCTOR_SOURCE=gitlab`, newest pipeline first until one ran the proctor job | Finds that pipeline's proctor job id, following `Link` pagination to the same host | `read_api` | | `GET /api/v4/projects/:id/jobs/:job_id/artifacts/:artifact_path` | `ROLLCALL_PROCTOR_SOURCE=gitlab`, when a proctor job was found | Reads the one report file (`proctor.json`) from that job's artifact; 404 means no report | `read_api` (Reporter reads job artifacts) | | `GET /api/v4/personal_access_tokens/self` | Every scan | Reads the token's own expiry date for the 14-day note (advisory) | any valid token | `tests/TokenScopeDocsTest.php` fails if the GitLab adapter calls an API path this table does not list. #### Scopes it must not have [#](https://rollcall.apps.wayne.edu/docs/security.html#scopes-it-must-not-have) | Scope | Why not | | --- | --- | | `api` | Read and write access to the whole API. Rollcall never writes, so a leaked `api` token would hand out powers Rollcall never uses | | `write_repository` | Push access. Rollcall never pushes | | `read_repository` | Git-over-HTTP pull. Rollcall never clones; it reads single files through the API, which `read_api` covers | | `read_user` | The `/user` profile. Rollcall never reads a profile; the expiry note uses `personal_access_tokens/self` | | `read_registry`, `read_virtual_registry` | Container and package registries. Rollcall reads no images; the image tag comes from an export | | `self_rotate` | Lets the token rotate itself. The stack maintainer rotates the token, never Rollcall | | `create_runner`, `manage_runner`, `k8s_proxy`, `ai_features` and any admin scope | Nothing Rollcall does | #### Role, membership and expiry [#](https://rollcall.apps.wayne.edu/docs/security.html#role-membership-and-expiry) - **Reporter, on each project to scan, and nothing more.** Reporter is the lowest role that can read a private project's files; Guest cannot. Developer and above add powers Rollcall never uses. - **Membership is the real fence.** `ROLLCALL_GITLAB_PROJECTS` limits what Rollcall asks for, not what the token can read. A group token reads every project in its group. For the tightest fence, the token's user is a member of just the projects to scan: a service account, or a bot on a small group made for the purpose. The stack's own token takes the wider road on purpose (below), and the scan job's project list keeps the asking narrow. - **An expiry, always.** GitLab caps a token at 365 days by default. `scan` prints a note 14 days before the expiry and again once it has passed, naming the date. - **Where it lives.** In the environment of the job that scans, as `ROLLCALL_GITLAB_TOKEN`: on GitLab CI a masked, hidden and protected CI/CD variable on the Rollcall project, not a file variable. Never in git, `.env.example`, an image or a log. - **Who rotates it.** A role, not a person: the stack maintainer creates the replacement, updates the variable and revokes the old token before the expiry date. Rollcall only reminds. - **A refused token stops the scan.** A `401` or `403` ends the scan loudly with exit `2`, so a dead token never produces a flattering partial roll. One `403` is not the token: with `ROLLCALL_PROCTOR_SOURCE=gitlab`, a `403` on a project's pipeline list means CI/CD is off for that project (the same token has just read its files), so that app has no PROCTOR report and the scan carries on. ### The scanner token and how to rotate it [#](https://rollcall.apps.wayne.edu/docs/security.html#the-scanner-token-and-how-to-rotate-it) The stack's weekly scan on git.wayne.edu reads with one token. Everything about it except its value is here. | What | The stack's answer | | --- | --- | | Token | The group access token `rollcall-scanner` on the `enterprise-apps` group: Reporter, `read_api` only. The project owner chose group reach (2026-11-06), so it can read the group's projects; the job asks only for the 13 it lists | | Where it lives | Its value lives only in the CI/CD variable `ROLLCALL_GITLAB_TOKEN` on `enterprise-apps/rollcall`: masked, hidden, protected, not a file. The token itself is listed under the group's Settings > Access tokens | | Expires | 2027-11-06. `scan` starts its note on 2027-10-23 | | Who rotates it | The stack maintainer, a role, not a named person. Creating a group access token needs the Owner role on the group; a stack maintainer without it asks a group Owner for step 1 and does the rest | | What uses it | The `rollcall-scan` job, on the Monday schedule with `ROLLCALL_JOB=scan`, or started by hand | Rotate it in one sitting, well before the expiry and not just before the Monday schedule runs: 1. **Make the replacement.** In the group's Settings > Access tokens, add a new token: name `rollcall-scanner`, role Reporter, scope `read_api` only, an expiry at most a year out. Copy the value once; GitLab never shows it again. (The token list's Rotate button is the shortcut, but it revokes the old token at once and you must check the new expiry it gives: GitLab's API defaults a rotated token to one week.) 2. **Update the variable.** In `enterprise-apps/rollcall`, Settings > CI/CD > Variables, edit `ROLLCALL_GITLAB_TOKEN` and paste the new value. Keep it masked, hidden and protected, not a file. Paste it nowhere else: not a chat, a ticket, a file or a commit. 3. **Prove it.** Run a pipeline on `main` with the variable `ROLLCALL_JOB` set to `scan`. In the job log, look for `Present: 13 apps.` and no `not set; skipping`, no `GitLab refused the token` and no `Note: the GitLab token` line (the new token is a year from expiry, so it gets no note). 4. **Revoke the old one.** Back in the group's access tokens, revoke the old `rollcall-scanner` (the one with the earlier expiry). 5. **Write down the new date.** Change the expiry in the table above, and note the rotation in `CHANGELOG.md`, in the same merge request. A token that leaked is rotated the same way, at once, without waiting for its date. Revoking it first is fine: the scan stops loudly until step 2 is done.