---
title: "Changelog | Parity docs"
description: "All notable changes to this project."
url: https://parity.apps.wayne.edu/docs/changelog.html
llms: https://parity.apps.wayne.edu/llms.txt
generator: Squire agent-ready
---

# Changelog [#](https://parity.apps.wayne.edu/docs/changelog.html#changelog)

All notable changes to Parity are recorded here. The format follows Keep a Changelog.

## \[Unreleased\] [#](https://parity.apps.wayne.edu/docs/changelog.html#unreleased)

- Changed: `deploy/` requires PROCTOR `^0.16` (was `^0.15`, which does not allow 0.16), whose `ci-pipelines` check no longer asks for a GitHub workflow (D-069).
- Fixed: on Apple Silicon with Docker Desktop, a Rosetta setting Parity cannot read (newer builds store it elsewhere) is now an info line in `parity check`, not a warning nobody can clear; `UseRosetta` is read too.
- Fixed: the docs pages set their text in the body face (Lato) again, not the display serif, and a code block's Copy button sits in a gutter beside the code instead of covering the end of its first line.
- Site: the front page's road to 1.0 lists `trust` and local HTTPS under 1.0, no longer under "Later".
- Docs: local HTTPS (`"https": true`, `parity trust`, the `https.trust` check) in the README, the parity.json and commands references, the FAQ and troubleshooting; it is part of 1.0 now, not after it.
- Added: `parity check` warns (`https.trust`) when your user store does not trust the app's local CA yet, and `parity test` also loads the home page over https, pinned to that CA.
- Added: `parity trust` (and `parity trust --remove`) puts the app's local https certificate authority in your user store on Windows and macOS, and prints the commands for Linux.
- Added (internal): with `"https": true` the stack's HAProxy serves https on 127.0.0.1:8443 with a leaf from the app's local CA (renewed when 7 days are left); `parity trust` comes next.
- Added (internal): parity.json accepts `"https": true` and checks its port (8443) against `http_port` and `database.port`; serving it comes in the next slices.
- Added (internal): a per-app local CA for the coming `"https": true` (one CA per app, name-constrained, keys in the per-user config dir).
- Added: `test.tools` in parity.json: commands `parity test` runs in the app container (as user citadel) before its HTTP checks; the first failing tool stops the run.
- Added: `parity check` checks the running app too: APP_KEY, writable folders, the database and pending migrations. With the app stopped it says so and skips them.
- Added: `parity run -- <command>` runs a tool (composer ci, php artisan test, npm run build) in the app container as user citadel and returns its exit code. In bake mode it says the files it writes vanish on the next `parity up`.
- Changed: with no `parity.json`, `parity up` and `parity check` say one line naming the right next command (`parity init --from-squire` when the folder has Squire's kit, `parity init` otherwise), and `parity check` now fails there instead of warning.
- Changed: mount mode keeps `vendor/` and `node_modules/` in per-project named volumes laid over the bind mount, so the kit's release steps never rewrite the developer's own copies (D-091); `parity init` says so instead of warning.
- Docs: the git LFS image route says to run `git lfs install` once.
- Security: CI and release builds use Go 1.26.11 (was 1.26.10), which fixes GO-2026-6859 (an HTTP/1 server crash from a header race in net/http's MaxBytesReader). govulncheck flagged it on main; `parity` itself only makes HTTP requests, but the release binaries are built with the fixed Go.
- Added (maintainers): `go run ./tools/checklist` runs the release checklist's real-machine steps on the computer it runs on: it builds `parity` from the checkout and, on a scratch copy of `testdata/hello` in each mode, runs `check`, `image get` when Citadel's image is missing, `up`, `test` at once and 30, 60, 90 and 120 seconds later, `status` (the mirror must match Citadel) and `down --volumes`, then prints the row for MAINTAINING's "Checklist runs" table. One command for the Mac run that 1.0 waits on, the same on Windows and Linux.
- Tests: the terminal voice (`internal/term`: style detection, the three symbol sets, colors, the live spinner and progress bar, and what the desktop app's observer hears) is covered at 92% (was 37%), race-clean.
- Added: `parity init --health-check` sets Citadel's health check: a command (`php deploy/health.php`), or a path such as `/up`, which becomes a check that Apache answers it. Without it, init guesses as before.
- Changed: the deploy kit is Squire 0.10.8 (was 0.10.7): 0.10.8 moves no template and no kit file (the last template move was the 0.10.7 `.gitattributes`, the last docs and agent-ready tool change was 0.10.6), so `deploy/.squire.json` records the new version and every kit file stays as it is.
- Fixed: `parity test` no longer fails a healthy app when the engine's own connection drops for a moment (Podman on Windows: `exited 125: unable to connect to Podman socket ... ssh: handshake failed`). Its reads in the container (the health check, and the log reads) try once more after two seconds when the engine's client, not the container, failed; a second drop says so instead of blaming the app. Found in a 30-run loop on the Windows checklist run.
- Site: the front page's "Next" section is now "The road to 1.0": the release-checklist runs per OS (Linux and Windows proven with Citadel's real image, macOS next) and what comes at 1.0, after it and later. The desktop app is labeled "After 1.0" (was "Coming in 0.2.0"), and the installers' unsigned note says the same. MAINTAINING gains a "Checklist runs" table with the 2026-11-10 Windows runs.
- Fixed: on Podman the proxy lost the app about a minute after `parity up` and answered 503 (`DNS timeout status` in `parity logs proxy`). HAProxy asked Docker's DNS address (127.0.0.11) on every engine; it now reads the nameserver each engine writes into the container (`parse-resolv-conf`), so Docker and Podman both keep finding the app. Found on the Windows checklist run with Podman 5.8.9.
- Fixed: `parity up` signs in to MySQL as the app before it starts the app, and stops at the MySQL step (exit 2, with the way out) when the database volume was made with other passwords or for another database name. MySQL's health check passes even when access is denied, so a deleted `.parity/` (git clean -x, a fresh clone) or a second folder with the same app name used to come up "healthy" with every page saying it cannot reach the database. Found on the Windows release-checklist run.
- Docs: the README, MAINTAINING and the guides say what 1.0 promises (today's commands) and what follows it (reset, eject, image pin and build, local HTTPS, the desktop app), as decided on 2026-11-10.
- Changed: the deploy layer requires PROCTOR ^0.15 (locked 0.15.0, was ^0.12): 0.13 checks the release cooldown against the CREED policy and 0.14 adds `script-pair`; 0.15 adds `mysql56-ci`; all of these only warn, nothing breaks.
- Changed: the deploy layer requires PROCTOR ^0.12 (locked 0.12.0, was ^0.11): two new warning-only checks, nothing breaks.
- Site: the front page's stale facts are current (the `parity help` printout lists `engine` and `logs deployments`, and the stack list says the starters ship a Squire kit, which `parity init --from-squire` reads, not a `parity.json`).
- Added: `parity test` notes (`Proxy trust`, a warning that does not fail the run) when HELMET logged rejected forwarded headers while it ran, and says to set HELMET_PROXIES for Parity's proxy; `--json` results gain an optional `warn` field.
- Fixed: `parity up` warns, instead of failing with "does not answer on port", when HAProxy is up but the app's front page is slower than the probe; a refused connection still fails.
- Added: `parity check` warns (`vite-hot`) when the public folder has Vite's `hot` file, and `parity test` fails a front page that loads its assets from Vite's dev server (localhost:5173), which Citadel never runs.
- Added: `parity init --from-squire` warns when mount mode will run the kit's deployments (and so Composer, npm and migrations) in the developer's own folder, and names bake mode or SQUIRE_NPM=skip and SQUIRE_MIGRATE=0 as the ways out.
- Added: `parity init` uses a Laravel app's declared health route (`health: '/up'` in `bootstrap/app.php`) as the health check, instead of asking Apache for `/`.
- Added: `parity check` warns (`mount-speed`) when a Windows folder runs in mount mode on a Linux-container engine, which is slow; it names bake mode and the WSL filesystem as the ways out.
- Changed: the deploy kit is Squire 0.10.7 (was 0.10.6): it ships a `.gitattributes` that pins line endings, so the deploy layer clears PROCTOR's line-ending warnings.
- Changed: the docs and agent-ready kits and the deploy kit are Squire 0.10.6 (was 0.10.5): the docs builder and agent-ready generator see every file on Docker Desktop mounts.
- Site: `assets/stack-env.js` knows Parity, so a pre-production page links Parity's pre-production site and a dev page links its local `site/` folder. Until now Parity, of all parts, was the one link that ignored its environment.
- Fixed: messages no longer name a parity edit command, which never existed; they point to the image field in parity.json and parity image list.
- Removed: the stand-in image and `parity up --fallback`. Parity runs Citadel's own images only; an image Citadel has not published yet says so.
- Docs: the GUI, guides and front page no longer mention the stand-in; a missing image says Citadel has not published it yet.
- Added: the site shows the desktop app beside the terminal. A "Terminal or app" switch on the front page pairs each command's printout with the same step in the app, labeled "Coming in 0.2.0" (the app is not released yet), and a new guide, "The desktop app (0.2.0)", shows three more screens. Screens are from the work in progress, with sample apps.
- Fixed: a failed deployment's own log now ends `parity up`'s message, and `parity logs deployments` shows it; an image with no download says so at once instead of sending you to parity image get.
- Fixed: `parity init --from-squire` keeps the kit's image only when Parity can get it, adds the scheduler only when the app schedules something, and drops the example host name.
- Fixed: the site's downloads folders are readable by the web server; they were created owner-only, so every /downloads/ URL answered 403.
- Changed: a plain `go build` from a checkout now says `parity 0.2.0-dev`. Release binaries still take their version from the tag.
- Added (0.2.0 preview): the desktop app in `gui/`, its own Go module on Wails v2.17.1, so the `parity` command stays free of Wails, WebView and cgo. Every button runs the same Go code as the command: app list, app home with your machine and Citadel side by side (Match, Close or Differs per row), start and stop with live steps, logs streamed with local passwords hidden, `parity test` results, `parity check`, cron entries and settings. Build it with `wails build` (see `gui/README.md`); opening a shell still hands over the command.
- Added: `parity engine [podman|docker|auto]` says which container engine Parity uses and why, or saves the choice for you on this computer (`parity/settings.json` in your config folder; `PARITY_APP_CONFIG_DIR` moves it). Every command, `parity check` and the desktop app use it; `PARITY_ENGINE` still wins where it is set, and both say so. `--json` is the stable contract. A settings file Parity cannot read counts as no choice, and `parity engine` says what is wrong with it.
- Added: the mirror compares Node and PHP extensions too. Parity asks the running app container (or else the app image, or else Citadel's base image here) for `php -m` and `node -v`, once per image id, and compares them with the catalog: Node is Close when only the minor or patch differs and Differs across a major; a missing extension Differs and an extra one is Close, each listed under the extension row and counted as one difference. The catalog records 8.5r3's Node (22.23.4) and its 50 extensions, read from the real image.
- Added: `parity status` and `parity check` end with the same mirror as text, row for row what the desktop app shows, when there is a `parity.json` and the engine runs. The `--json` output is unchanged.
- Added (desktop app): Settings lists Podman and Docker each on its own line, Podman first and recommended: on PATH or not, running, version, Compose, rootless or rootful, and Podman's machine on Windows and macOS (a machine that runs with no Podman service answering in it says so, rather than "stopped"). A missing or stopped engine shows `parity check`'s own fix steps (both come from `check.EngineFix`), with a button to Podman Desktop's download page.
- Added (desktop app): an engine picker in Settings. Podman (first, recommended), Docker, or whichever answers; an engine that is not installed cannot be picked. The choice is the one `parity engine` saves, so the window and every terminal agree. When `PARITY_ENGINE` is set where the window started, the window says it wins and which engine that leaves in use.
- Added (desktop app): ports in Settings. Each app's HTTP and MySQL port, saved to its `parity.json` with the code `parity init` writes with; Check ports asks the way `parity up` does (free, in use by this app, or taken, and two apps on one port). A problem shows beside its field and nothing is written; a running app is offered a Restart.
- Added (desktop app): Citadel's images in Settings. Verify is `parity image verify`; Get is `parity image get`, with download, sha256, load and image id as live steps, the download's progress, and Stop. Use a file takes a tar you downloaded in the browser. A failed step shows its reason and the fix beside the image.
- Added (desktop app): the window fits beside an editor down to 640 px wide, with no sideways scroll and nothing cut short.
- Added (desktop app): sign-in (none, fake with its user, or CAS) and cron entries change on the app's parity.json tab. Parity writes `parity.json` with the code `parity init` writes with, after the same checks the command runs (Citadel's schedule rules; no `;`, `&&`, `|`, `>` or `$` in a command), and shows each problem beside its field. A running app gets a notice and a Restart button (`parity down`, then `parity up`; the database stays).
- Changed: the catalog's 8.5r3 note. The image has opcache (PHP 8.5 builds it in); the note said it had none.
- Changed: the site's deploy layer uses Squire's 0.10.5 kit and current stack packages.
- Changed: the site CI job runs Composer 2.11.1 (was 2.10.3, which is no longer maintained).
- CI: Preflight 0.9.0 (secret-detection, a11y, proctor), up from 0.5.0.

## \[0.1.0\] - 2026-11-09 [#](https://parity.apps.wayne.edu/docs/changelog.html#0-1-0-2026-11-09)

The first release. Parity runs Citadel on your own computer, for any PHP app, with or without Squire:

- **Citadel's stack, piece by piece:** Citadel's real PHP image (`citadel/php-apache:8.5r3`, fetched with your own git.wayne.edu access and checked against Citadel's by sha256 and image id) or a stand-in built from the official PHP image and labeled as one; Citadel's own `vhost.conf` and `php.ini`; HAProxy saying what Citadel's proxy says; MySQL 5.6.51; the app's `build.sh`, `deployments/` and health check run the way Citadel runs them.
- **Commands:** `check`, `init` (with `--from-squire`), `up`, `status`, `logs`, `shell`, `test`, `down`, `image list|get|verify` and `version`. Exit codes 0 pass, 1 findings, 2 cannot run; `--json` on the read commands is the stable contract.
- **One file per OS:** six static binaries (Windows, macOS and Linux, each x64 and arm64), as `parity_0.1.0_<os>_<arch>.tar.gz` (`.zip` on Windows) with `checksums.txt`, installed by `install.ps1` or `install.sh`. Unsigned in 0.1.0; signing comes before the desktop app, which follows 1.0.
- **Not yet:** `reset`, `eject`, `image pin|build`, HTTPS with a local certificate authority, and the desktop app. Citadel's 8.4r5 image is known by its stand-in only until its tar is published.
- Added: Parity's site (`site/`), ready for Citadel at parity.apps.wayne.edu. The front page holds your machine up to Citadel in a mirror, row by row (Match, Close or Differs), with an install line per OS, the real printouts, the six downloads and two prompts for a coding agent. The docs (getting started, every command, `parity.json`, Citadel's images, moving from Squire, how it works, troubleshooting, FAQ and this changelog) wear the same header, built from `docs/` by `site-build/` with Squire's docs builder, with `llms.txt`, `llms-full.txt` and a Markdown twin of every page. `deploy/` serves it on Citadel behind HELMET with Squire's release kit, and CI runs Preflight's accessibility gate on every page.
- Added: `sign_in` now does something. `fake` gives the app `SESAME_DRIVER=fake` and `SESAME_FAKE_USERNAME` (new `fake_user`, default `jdoe`) and needs a local, dev or test `environment`; `cas` gives `SESAME_DRIVER=cas` and `SESAME_CAS_SERVICE_URL=https://<server_name>/login` and needs `server_name` on wayne.edu. Both go into `.parity/app.env`, never the app's `.env`.
- Added: `cron` in `parity.json`, Citadel's cron entries (short name, schedule, command), checked against the rules Citadel's dashboard uses and run inside the app container as `prisoner` by a small loop beside Apache, with Citadel's per-name stdout and stderr files. `parity logs cron:<name>` shows them. `parity init` and `--from-squire` propose `php artisan schedule:run` every minute when the app schedules anything (`--no-cron` leaves it out). No queue worker service, on purpose: Citadel has none, so a queue drains from the scheduler. The README has a `parity shell` recipe for `npm ci && npm run build`, and says a second database is out of scope for 0.1.0.
- Added: release packaging. GoReleaser (v2.20.0, `.goreleaser.yaml`) builds the six archives and `checksums.txt` in git.wayne.edu CI on every tag, with the version and commit stamped into `parity version`; `tools/downloads` lays out the tree Parity's site serves (`downloads/<version>/`, and `downloads/latest/` with version-free names and a `VERSION` file for releases), refusing any archive that does not match its checksum; the `release` job puts the files in the project's package registry and makes the GitLab Release with curl. A snapshot runs on main whenever the release files change.
- Added: `install.ps1` (Windows PowerShell 5.1 and 7: `%LOCALAPPDATA%\Programs\parity`, your user PATH, no administrator) and `install.sh` (macOS and Linux: `~/.local/bin`, or the folder you name, with sudo only when you name one you cannot write). Both take a version or default to the latest release, check the sha256 against the release's `checksums.txt` before installing (which catches a corrupted or partial download, not tampering: both files come from the same site), and say plainly what to do about SmartScreen or macOS quarantine while the binaries are unsigned.
- Added: `install.sh` never edits a shell profile. When its folder is not on PATH it prints the one line to add, for bash or zsh and for fish; `PARITY_NO_PATH=1` drops that hint. Its body runs from `main` on the last line, so a `curl | sh` cut short runs nothing, and a failed copy leaves no `parity.new` behind. A failed fetch of `latest/VERSION` now says so, rather than complaining about an empty version.
- Added: `install.ps1` decides from the user PATH in the registry, not the session's PATH, so a folder added to one terminal by hand still gets written; it says "Added" only when it changed PATH, and "already on your PATH" otherwise. A failed fetch of `latest/VERSION` says which address it tried.
- Added: installer tests (`test/install/`). A small Go file server serves a snapshot's downloads tree on 127.0.0.1, and the tests run each installer against it: the piped install, `parity version`, PATH exactly once after two runs, `PARITY_NO_PATH`, a tampered archive and a missing `VERSION` refused, and (for `install.sh`) a script cut short at six points. git.wayne.edu runs `install.sh` in `package` and `package-snapshot` (now automatic on any branch that changes the release files or the installers); the GitHub mirror runs `install.ps1` on Windows PowerShell 5.1 and PowerShell 7 against the runner's real user PATH, and `install.sh` on macOS.
- Added: `parity image list`, `get` and `verify`. `get` fetches Citadel's image with the user's own git.wayne.edu access (a tar from the browser with `--file`, a token in `PARITY_GITLAB_TOKEN` through GitLab's API, or git LFS over SSH or HTTPS, fetching only the one file), with a progress bar, then checks the tar's sha256 and the loaded image's id against the catalog ("matches Citadel") before calling it done. `verify` checks the image here, or a tar.
- Added: `parity test` (with `--json`): the front page through the proxy, the app's own health check, the requests in `parity.json`, and no PHP fatal or parse error in Apache's log while it ran. The GitHub Linux job runs it after `parity up --fallback`.
- Added: Podman, recommended (ADR-0022). `parity check` reports Podman (machine or native, rootless or rootful), Docker Desktop and any other engine that is here; with none, it suggests Podman Desktop first and Docker Desktop second. `PARITY_ENGINE=docker|podman` picks one (`auto` by default: the running one, Docker first). Docker Compose v2 is the one Compose on both engines: podman-compose is named and refused, and on Linux the check knocks on Podman's API socket. A podman machine that runs with no Podman service answering says so, and why. Proven on Podman 5.8.9, rootful and rootless, through `podman compose` and `docker compose`; a level with two bubbles, both in the middle.
- Added: rootless Podman in mount mode runs the app with `userns_mode: keep-id` (the image's `citadel` ids) as root, and the writable paths go to Apache's group, group-writable, as the container starts, as Citadel's deploy does. Apache, the deployments and the cron entries can all write them; your folder stays yours.
- Changed: images are written in full (`docker.io/library/mysql:5.6.51@sha256:...`), because Podman refuses short names. On Podman, builds use the classic builder (BuildKit's builder container cannot see Podman's images), so Citadel's `vhost.conf` and `php.ini` come from `.parity/citadel` inside the build context rather than a second build context. The catalog also knows each image's config digest, the id Podman reports.
- Fixed: in bake mode a writable path was owned by `prisoner`, so a deployment (run as `citadel`) could not write it. It is now `citadel:prisoner` and group-writable, as on Citadel. Bake images also leave `.parity` out.
- Fixed: `parity logs cron:<name>` and the build, logs and shell commands run in the engine's Compose environment, so Podman's "Executing external compose provider" banner stays out of the output.
- Added: `parity up`. It writes `.parity/` from `parity.json` (the compose file; the Dockerfile Citadel's generator would write; Citadel's own `vhost.conf` and `php.ini`, copied unchanged from Citadel's repository with their MIT license; HAProxy's settings; local MySQL passwords made once and kept) and brings the app up one piece at a time, each with a live line: Citadel's image, checked against Parity's catalog ("matches Citadel"), the build with the build script run as root with `/bin/sh`, MySQL 5.6.51, the app (deployments, Apache, the health check at Citadel's 5 minute and 15 second timing, answered in seconds locally), and HAProxy, then the address. A failure shows the last lines that explain it; everything is in `.parity/up.log`. `--fallback` builds a stand-in base from the official PHP image (the same users, modules, extensions, Node and Citadel's own entrypoint, without oci8, imagick and ssmtp) and says so. On arm64 Citadel's amd64 image runs under emulation.
- Added: `parity status` (with `--json`), `parity logs` (`-f`, `--tail`, `--apache` for Apache's own logs), `parity shell` and `parity down` (`--volumes` empties the local database).
- Added: `parity check` checks Citadel's image (here, and the build Citadel runs) and the ports `parity up` needs.
- Added: the image catalog inside Parity: `citadel/php-apache:8.5r3` (image id, the tar in `enterprise-apps/images` with its sha256 and size) and the fallback bases for PHP 8.5 and 8.4.
- Added: the GitHub workflow runs `parity up --fallback` on `testdata/hello` on Linux, end to end.
- Changed: paths in `parity.json` may not hold `$`, backquotes, double quotes or line breaks, and `health_check` is one line, because they land in a Dockerfile and a shell.
- Added: `parity.json` (format version 1), the app's Citadel settings: image, public folder, mode (`mount` or `bake`), build script, deployments, health check, writable paths, configuration files with required keys, MySQL, sign-in, ports and test requests. Unknown fields are an error.
- Added: `parity init` writes it from the folder's layout (public folder, `build.sh`, `deployments/`, `health.php` or `health-check`, Laravel's writable folders, MySQL from `.env.example`), with flags to override and `--print` to preview. `--from-squire` carries a Squire parity kit's settings over and leaves its passwords behind by name; a kit in `deploy/` is pointed at.
- Added: `parity check` reads `parity.json`: problems in it, the files it names for the line-ending check, and the configuration files (present, required keys filled in, values never printed).
- Added: `testdata/hello`, the smallest app that shows Parity runs Citadel.
- Added: `parity check` (with `--json`). It finds the engine (Docker Desktop, Rancher Desktop, Podman, OrbStack, Colima, Docker Engine, through `docker` or `podman`), Compose v2, Windows containers mode, Docker Desktop off WSL 2, arm64 emulation (Rosetta in Docker Desktop, OrbStack, Colima, Rancher Desktop; QEMU binfmt on Linux; Windows on Arm) and Windows line endings in the files Citadel runs (`build.sh`, `deployments/`, `health-check`, `*.sh`), with one fix per finding for the OS. Exit 0 pass, 1 findings, 2 cannot run.
- Added: styled output. Color, symbols and spinners on a terminal; plain `[ OK ]` tags in a pipe or CI log, with `--plain` or `PARITY_PLAIN=1`; no color with `NO_COLOR`; `PARITY_STYLE=fancy` keeps symbols in a log. The classic Windows console gets VT mode switched on and symbols from its own fonts.
- Added: the repository. `parity version` (with `--json`), the Go module `git.wayne.edu/enterprise-apps/parity`, `tools/build` for the six targets with `checksums.txt`, git.wayne.edu CI (gofmt, vet, tests, govulncheck, secret detection, cross-compiled binaries) and the GitHub workflow for Windows and macOS on tags.
