# Sourdough: everything in one file > Sourdough bakes all five Wayne State app shapes: raw PHP, raw PHP + Vue, Laravel + Blade, Laravel + Blade + Vue islands and Laravel + Inertia/Vue, each with SESAME sign-in, HELMET headers, PROCTOR, Preflight CI and Squire's deploy files already in it. The README and the Markdown twin of every page, joined. The index is https://sourdough.apps.wayne.edu/llms.txt. Written by Squire's agent-ready kit; do not edit. --- ## README Source: https://github.com/waynestate/sourdough/blob/HEAD/README.md ## Sourdough **Feed it and it grows.** A starter you feed: `sourdough new` makes a Wayne State app with the stack already wired in. Checks: `composer ci` (the same command runs on GitLab and GitHub). Status: 0.4.2 (2026-11-09), MIT license: Pinstripe 0.4 in every shape (an app that joins SQL from strings fails PHPStan until it binds values instead), Pint's findings in the merge request widget on the Laravel shapes, a "Run it like Citadel" README section in every shape for [Parity](https://git.wayne.edu/enterprise-apps/parity), and `sourdough adopt` for apps Sourdough did not make. What changed is in the [changelog](https://github.com/waynestate/sourdough/blob/HEAD/CHANGELOG.md); what a feed brings is in [Upgrading](https://github.com/waynestate/sourdough/blob/HEAD/docs/upgrading.md). Every loaf gets proofed before it ships. Documentation: the [docs site](https://github.com/waynestate/sourdough/blob/HEAD/site/docs/index.html) is built from [`docs/`](https://github.com/waynestate/sourdough/blob/HEAD/docs/) by Squire's docs builder; `composer docs:build` rebuilds it and `composer docs:check` fails when it is stale. The docs pages wear the front page's header, menu, palette and fonts: edit [`docs/_header.html`](https://github.com/waynestate/sourdough/blob/HEAD/docs/_header.html) and [`docs/theme/sourdough.css`](https://github.com/waynestate/sourdough/blob/HEAD/docs/theme/sourdough.css) (named by the `theme` key in `docs/docs.json`), never the kit's `docs.css`. Front page: [`site/index.html`](https://github.com/waynestate/sourdough/blob/HEAD/site/index.html), a static page you can open in a browser or serve from `site/`. Its order counter writes the `sourdough new` command for a loaf, an oven and a name, with the bake and the next steps, all read from [`site/assets/order-menu.json`](https://github.com/waynestate/sourdough/blob/HEAD/site/assets/order-menu.json), and copies a link that reopens the same order (`#order?loaf=...&oven=...`). `composer site:order-menu` writes that file from the same plan code `sourdough new --dry-run --json` runs, `composer ci` fails when it is stale, and `tests/OrderMenuTest.php` runs every order the ticket can write through the real command. On Citadel it is served by the raw-PHP deploy layer in [`deploy/`](https://github.com/waynestate/sourdough/blob/HEAD/deploy/): a Squire kit whose front controller serves `site/` behind HELMET's security headers. For local development, keep serving `site/` directly. ### Where the code lives The canonical repository is [enterprise-apps/sourdough](https://git.wayne.edu/enterprise-apps/sourdough) on git.wayne.edu. Open issues and merge requests there; tags are made there, by the maintainer, with an approver. GitHub ([waynestate/sourdough](https://github.com/waynestate/sourdough)) is a read-only push mirror of it: nobody pushes to it, and Packagist reads from it. git.wayne.edu is the starter culture now; GitHub is the slice Packagist eats. Sourdough is the app starter for the WSU stack, and it starts every app shape: raw PHP, raw PHP with a Vue SPA, Laravel with Blade, Laravel with Blade and Vue islands, and Laravel with Inertia and Vue. WELD is that last shape already built from it. One command scaffolds a new app with WayneUI (the interface), SESAME (auth), HELMET (baseline runtime), Pinstripe (coding standard), PROCTOR (checks), the Preflight CI components, Squire's deploy files and ADVISOR (the stack's MCP server) already in place, with its PHP floor read from CREED's policy. It is one PHP command, so it works on Windows, macOS, and Linux. ### Install ``` composer global require waynestate/sourdough ``` After `composer global require`, the `sourdough` command lives in `composer global config bin-dir --absolute`; put that directory on your PATH. Or scaffold without installing, with `composer create-project waynestate/sourdough`. ### Usage ``` sourdough new [dir] [options] ``` `dir` is the directory to create the app in. It is required unless you use `--describe`. Options: - `--raw` use the raw PHP base - `--laravel` use the Laravel base - `--vue` add a Vue front end - `--inertia` use Inertia/Vue (implies `--laravel`) - `--sail` run the Laravel app on Sail for local work: compose.yaml and laravel/sail in require-dev, MySQL 8.4 LTS; needs WSL2 on Windows, where `--docker` is the route that works natively - `--docker` generate a Dockerfile and compose.yaml for local work (native on every OS; amd64 and arm64): the app's own base images, pinned by digest, for everyday work (Citadel's own image and MySQL 5.6.51 are [Parity](https://git.wayne.edu/enterprise-apps/parity)'s job: every baked README's "Run it like Citadel" says how); MySQL 8.4; Playbook credentials reach the build only as a BuildKit secret, never a build arg - `--dry-run` print the plan and write nothing - `--name` app name (default: the basename of ``) - `--no-input` never prompt (Sourdough has no prompts) - `--json` with `--dry-run`, print the plan as JSON, with the bake's `steps` and the `next_steps` a real run prints - `--describe ""` describe what the app does; a model plans it (needs the `SOURDOUGH_LLM_*` env vars) - `--plan-only` with `--describe`, print the plan as JSON and write nothing - `--plan ` a ready-made plan file (JSON, or YAML ending in `.yaml` or `.yml`, matching `resources/plan.schema.json`), such as the `.sourdough/plan.yaml` every bake saves - `--playbook` kept for compatibility: Playbook is now the default - `--no-playbook` skip the Playbook wiring (for CI and automated tests only; WSU apps need Playbook) - `--no-advisor` skip the ADVISOR wiring (no `require-dev` entry, no `.mcp.json` git-ignore line of its own, no README section; the Laravel shapes still ignore `/.mcp.json` for Laravel Boost) Exit codes: `0` done, `1` refused (invalid flags, non-empty target, not available, model gave up), `2` tool error. By default the generated app requires `waynestate/playbook` (WSU's private shared-values package on git.wayne.edu): the VCS repository, the package in `require`, `config.gitlab-domains` so Composer sends your token to git.wayne.edu, the seven setting names in `.env.example`, a `composer playbook` script that shows whether Playbook is installed, and a "WSU values (PLAYBOOK)" README section that explains how to get read access. Before writing anything, `sourdough new` checks that this machine can read the package (a Composer credential, then a direct git probe); without read access it refuses with exit `1` and prints the how-to, and if it cannot reach git.wayne.edu it still generates the app but warns that `composer install` will need the connection. Non-interactive runs and CI environments skip the check. `--dry-run` runs the check but never refuses, and its JSON plan carries a `playbook` key with the mode, the access status and the probe that answered. After generation the Next steps point at `composer playbook`. `--playbook` is kept for compatibility and changes nothing; `--no-playbook` skips all of it. The two flags together are refused with exit `1`. Generated apps ship with ADVISOR wired in by default: `waynestate/advisor` lands in `require-dev`, `.mcp.json` is git-ignored (a client config starts a program for whoever opens the project), and the README gains an "ADVISOR" section. The Next steps print the install line once dependencies are in: ``` php vendor/bin/advisor install --client=claude --write ``` `--no-advisor` skips all of it. The three Laravel shapes also ship Laravel Boost as a dev-only tool, whatever the ADVISOR answer: `laravel/boost` in `require-dev`, a guarded `composer boost-update` after `composer update`, a `.gitignore` block for what `php artisan boost:install` writes (`/.mcp.json`, `/boost.json`, `/CLAUDE.md`, `/AGENTS.md`, `/.claude/skills/`, `/.junie/`), the stack's guidelines and two starter rules in `.ai/`, and `tests/Feature/BoostDevOnlyTest.php`. ADVISOR complements Boost: Boost knows Laravel, ADVISOR knows the stack. See [Laravel Boost, dev only](https://github.com/waynestate/sourdough/blob/HEAD/docs/guides/laravel.md#laravel-boost-dev-only). The app name (from `--name`, from the plan, or from the basename of ``) must start with a letter or number and use only letters, numbers, spaces, dots, dashes and underscores, at most 63 characters; anything else is refused before anything is written. ### Permutations | Flags | Permutation | |---|---| | (none) or `--raw` | Raw PHP with WayneUI's standalone path | | `--raw --vue` | Raw PHP + Vue SPA over JSON | | `--laravel` | Laravel + Blade | | `--laravel --vue` | Laravel + Blade + Vue islands | | `--laravel --inertia` (or `--inertia`) | Laravel + Inertia/Vue | All five permutations bake: raw PHP since 0.1.0, the three Laravel shapes since 0.1.5 and raw PHP + Vue since 0.1.6. `--raw --vue` is the raw PHP bake with a Vue 3 front end over it: PHP answers JSON under `/api/`, Vite builds the Vue app, and `src/Vite.php` loads it from the build or the dev server. Every bake takes its PHP floor from CREED's policy, not from a number baked into the template: the oldest PHP line still supported a year after the policy's refresh date (raised to what the Laravel major needs) becomes `require.php`, `config.platform.php` and the start of the CI test matrix. If the policy cannot be read, the bake falls back to the pinned `^8.3` and says so. `sourdough new` prints both a `PHP:` line and a `Support:` line, and every shape has an owner, a support window and a sunset path, so no starter goes stale on the counter. The rules are in [Support and sunset](https://github.com/waynestate/sourdough/blob/HEAD/docs/guides/support.md). Oracle is wired but dormant in every generated app. The settings `ORACLE_USERNAME`, `ORACLE_PASSWORD`, and either `ORACLE_TNS` or `ORACLE_HOST`, `ORACLE_PORT`, `ORACLE_SERVICE_NAME` ship commented out in `.env.example`; while they are empty, nothing connects and nothing errors. Once you fill them in, Laravel apps check the wiring with `php artisan oracle:check`, and raw PHP apps run queries through the `App\Oracle` helper, which takes values only as binds and answers mistakes with plain sentences. The Laravel shapes require `yajra/laravel-oci8` and declare `ext-oci8` 3.4.1 as a platform package, so the driver is ready the day the settings are filled in: most WSU apps need Oracle, and Citadel's images carry oci8 and Instant Client. The command finds the check file where it lives: `oracle-check.php` at the app root, where Squire's Laravel layout ships it, first, then `deploy/oracle-check.php`. ### Describe a plan Instead of choosing flags, describe what the app does and let a model plan it: ``` sourdough new --describe "A blog with posts and comments" ``` Sourdough asks an OpenAI-compatible model for a plan, validates it against `resources/plan.schema.json`, and prints it. The model kneads the dough, but you decide when the loaf is ready to bake: if the answer is not valid JSON, does not match the schema, or the model gives up after one retry, Sourdough refuses with a message pointing you to `--plan=` (exit `1`). You write the plan yourself and pass it in. To see the plan as JSON without writing anything: ``` sourdough new --describe "A blog with posts and comments" --plan-only ``` `--describe` stops at the plan: baking straight from a description is not built yet. Save the plan to a file and pass it with `--plan`, which bakes it: ``` sourdough new my-app --plan plan.json ``` `--plan` reads the file, validates it against the schema, and continues the normal generation flow using the plan's permutation and name. A file ending in `.yaml` or `.yml` is read as YAML; anything else as JSON. Every bake saves its plan in the app as `.sourdough/plan.yaml`: the recipe card taped inside the jar's lid. A `--plan` bake saves that plan (with `--name`, if you gave one); a bake from flags saves the shape, the name and all four parts. The card is a valid plan file, so `sourdough new other-app --plan=my-app/.sourdough/plan.yaml` bakes the same loaf again. See [Plan format](https://github.com/waynestate/sourdough/blob/HEAD/docs/reference/plan-format.md#the-saved-plan). #### Model configuration `--describe` needs three environment variables (no defaults, no key in code): - `SOURDOUGH_LLM_BASE_URL` the OpenAI-compatible endpoint, including the API path (usually `/v1`) - `SOURDOUGH_LLM_API_KEY` the API key - `SOURDOUGH_LLM_MODEL` the model name Any OpenAI-compatible endpoint works: a hosted API, a local server, or WarriorGPT. Sourdough does not care about the hostname; it only needs the base URL, key, and model. A plan is a small JSON object: ```json { "permutation": "raw", "parts": ["sesame", "helmet"], "name": "my-app", "models": [ { "name": "Post", "fields": [ { "name": "title", "type": "string" }, { "name": "body", "type": "text" } ] } ], "pages": ["/", "/posts"] } ``` `permutation`, `parts`, and `name` are required; `models` and `pages` are optional. `parts` is a subset of `sesame`, `helmet`, `proctor`, and `preflight`. ### The manifest Every app Sourdough generates carries a `.sourdough/manifest.json` recording what was generated: the Sourdough version, the template, the answers you chose, and a sha256 hash of every file, each marked `managed` (Sourdough owns it and will update it) or `seeded` (Sourdough wrote it once and you own it now: `.env.example`, `README.md`, and `package-lock.json` on the shapes with a front end). An app `sourdough adopt` took in has a third class, `yours`: a file that differed from the template on adoption day, which you own and feed takes over once it matches the template. The manifest is the starter's memory: it remembers what went into the loaf, so `feed` knows what to refresh and what to leave to rise on its own. `sourdough feed` reads it to bring template updates into your app without clobbering what you've changed. `sourdough manifest --check` lists the managed files that have drifted from the manifest: ``` sourdough manifest --check ``` Exit codes: `0` clean, `1` a managed file changed or is missing, `2` tool error (no manifest, or no `--check`). Seeded and yours files are never reported. They're yours. Commit the manifest. It's the record that keeps `feed` honest. Next to it sits `.sourdough/plan.yaml`, the plan the app was baked from. It is not in the manifest, so it is neither managed nor seeded: `feed` and `manifest --check` never read, rewrite or flag it, and you may edit it as the app grows. Commit it too. ### Feeding an app `sourdough feed` brings template updates into an app made with `sourdough new` (or taken in with `sourdough adopt`, below), without clobbering what you've changed. Install the new Sourdough, then, in the app, on a clean git tree: ``` sourdough feed --dry-run sourdough feed ``` Feed bakes your app's shape again with the answers in its manifest, then goes file by file: - a file the template did not change is left alone, whatever you did to it; - a managed file you never touched takes the template's new version; - a file you both changed is three-way merged by git (`git merge-file`), from the version Sourdough wrote last time; where you both changed the same lines, git's conflict markers go in the file (`<<<<<<< app` and `>>>>>>> sourdough `), never a silent overwrite; - new template files are added, and files the template dropped are removed only if you never changed them; - a file that already matches the template's new version is only recorded in the manifest (`record`); that is also how an app baked by 0.1.6 with `--sail` or `--docker` gets its oven into the manifest; - seeded files (`README.md`, `.env.example`, `package-lock.json`) are never touched. Then the manifest moves to the new base, and the template's version of each managed file you've changed is kept in `.sourdough/base/`, so the next feed can merge from it even when git history can't. Commit both. Exit codes: `0` fed cleanly (or nothing to feed), `1` fed with conflicts to resolve, `2` tool error (no manifest, no git, a dirty tree, conflicts left from the last feed, a manifest from a newer Sourdough). With `--dry-run` nothing is written: `0` the app is fresh, `1` feeding would change files. Every shape's pipeline runs it in a `sourdough-feed` job, next to `sourdough manifest --check`: an app that falls behind its template gets a warning (never a blocked deploy), hand edits to managed files are listed, and a broken record fails the job. `--json` prints the plan for machines. **Is my app fed, and still supported?** `sourdough check` answers both in one read-only run, the baker's poke test: the `Support:` line (the shape's status and its framework's end-of-security date), the manifest drift and whether a feed is due. Exit codes: `0` fed and supported, `1` needs attention (behind the template, a deprecated shape, or a Laravel major or PHP floor past security support), `2` tool error. Your own edits are listed and never fail it, and `--json` gives machines the same answer. Feed needs git and nothing else: git is the merge engine and the undo button (`git restore . && git clean -fd`). The Laravel shapes bake on a fresh `laravel/laravel` skeleton, so feeding one needs Composer and the network, the same as `sourdough new`; skeleton updates arrive as template updates. The full story is in [Keeping apps current](https://github.com/waynestate/sourdough/blob/HEAD/docs/guides/keeping-current.md). A fed starter is a happy starter. The deploy files in your app (`build.sh`, `scripts/release.sh`, the `.squire/` config, and their friends) come from Squire's exported copy, checked into this repository at `templates/squire/`. The copy is Squire 0.11.1's kit, so it ships a `.gitattributes` that pins line endings, and a Laravel release first refuses to run with no `APP_KEY` or with `APP_DEBUG` on in production (and warns when `APP_ENV` is not production), then `scripts/release.sh` asks PROCTOR's deploy gate (`proctor gate`, graded on the PHP that runs the release; `SQUIRE_PHP_RUNTIME` names another or `skip`) for a go or no-go before the frontend build and the migrations, keeps the verdict in `storage/squire/` (`SQUIRE_PROCTOR_RECORD_DIR`) as the next release's baseline, and after the optimize step restarts Laravel's long-lived processes (`php artisan reload`, or `queue:restart` and `schedule:interrupt` on an older Laravel; report only, `SQUIRE_ARTISAN_RESTART=0` turns it off). The image hardens too: the web's PHP loses its shell functions (`SQUIRE_PHP_DISABLE_FUNCTIONS` sets the list), opcache runs with production settings (`SQUIRE_OPCACHE_VALIDATE`), Apache answers `ServerTokens Prod`, and secrets can be read from `/run/secrets`. Session cookies are `SameSite=Lax` (`.squire/php.ini`), every image the kit builds from is named in full (`docker.io/library/...`) so Buildah and Podman take it, and the portable image ships the built assets without `node_modules/`. Squire owns them; Sourdough installs them as-is and records them in the manifest, so you never edit them by hand. To refresh them, run `composer squire-copy:sync`, which rewrites the copy from the installed `waynestate/squire` package, then verify it with `composer squire-copy:check` (part of `composer ci`). ### Adopting an app **Can Sourdough look after an app it did not make?** Yes: `sourdough adopt` writes the manifest an existing app would have had if Sourdough had baked it, and `feed` takes over from there. In the app, on a clean git tree, name the shape it already is (`raw`, `raw-vue`, `laravel-blade`, `laravel-blade-vue` or `laravel-inertia`): ``` sourdough adopt --shape raw --dry-run sourdough adopt --shape raw git add .sourdough && git commit -m "Adopt with Sourdough 0.4.2" sourdough feed --dry-run ``` ``` sourdough adopt [] --shape [--name ] [--sail | --docker] [--no-playbook] [--no-advisor] [--dry-run] [--json] [-v] ``` Adopt bakes the shape fresh in a scratch folder, through the same code as `new` and `feed`, and looks at each template path in the app, and only those: - `match`: the app's file is the template's (line endings aside), so it is `managed` and feed keeps it current; - `yours`: the file differs, so it is recorded as `yours` and never written, merged or reported, until the day your copy equals the template's and feed records it; - `seeded`: a file the template seeds (`README.md`, `.env.example`), yours as in every Sourdough app; - `missing`: the app has no such file; the first feed adds it, which is how Squire's kit, the pipeline with its `sourdough-feed` job, PHPStan and Pint reach an older app. It writes `.sourdough/manifest.json` and nothing else, and never reads a file the template does not ship. `--name` defaults to the folder's basename; a wrong name makes the files that carry it differ, and the report says so. Exit codes: `0` adopted (or a dry run printed its plan), `1` refused (a wrong or missing shape, bad oven flags, a missing folder, a manifest already there, a bad name, not a git repository, a dirty tree), `2` tool error (no git, a folder it cannot write, a failed bake). `--json` gives machines the report. For older Laravel apps, upgrade with Booster first: every hop brings more files level with the template. The whole walk-through is in [Adopt an existing app](https://github.com/waynestate/sourdough/blob/HEAD/docs/guides/adopt.md). Every starter was once somebody's leftover dough. ### 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. Exit 0, or 2 on a tool error (no scan yet, a bad option, an unreadable policy); 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). ### Testing Maintainers: how to build, test and release this project, and where its data comes from, is in [MAINTAINING.md](https://github.com/waynestate/sourdough/blob/HEAD/MAINTAINING.md). From the repo root: ``` docker run --rm -v "${PWD}:/app" -v stack-composer-cache:/tmp/cache -w /app composer:2.11.1@sha256:8de2184c6de224f4689e8f80ed5f5edaf0030b6b8b7839a22a2bcb6722ac87d0 composer install --no-interaction docker run --rm -v "${PWD}:/app" -w /app php:8.3-cli vendor/bin/phpunit docker run --rm -v "${PWD}:/app" -w /app php:8.4-cli vendor/bin/phpunit docker run --rm -v "${PWD}:/app" -v stack-composer-cache:/tmp/cache -w /app composer:2.11.1@sha256:8de2184c6de224f4689e8f80ed5f5edaf0030b6b8b7839a22a2bcb6722ac87d0 composer validate --strict docker run --rm -v "${PWD}:/app" -w /app php:8.4-cli php bin/sourdough new /tmp/demo --dry-run ``` The `stack-composer-cache` volume keeps Composer's downloads between runs; Docker creates it the first time. The smoke gate bakes a shape for real and runs the generated app's own checks; see the "Smoke gate" section of [MAINTAINING.md](https://github.com/waynestate/sourdough/blob/HEAD/MAINTAINING.md) for the full recipe. On Windows, `.\scripts\smoke-shape.ps1 ` runs it in one line. The proof harness runs that gate on every shape and every Laravel shape in each oven, one after another in Docker: it bakes each with this checkout, checks the manifest, feeds a bake of the last release forward, installs the app, runs its own suite, PROCTOR and `composer ci`, then boots it and fetches its front page. `sh scripts/proof.sh` on Linux and macOS, `.\scripts\proof.ps1` on Windows. What each run proves, and the Last run table, are on the [Proof](https://github.com/waynestate/sourdough/blob/HEAD/docs/reference/proof.md) page. The site accessibility gate runs Preflight's own a11y checker (vendored in `tools/a11y/check.mjs` from the 0.9.0 tag CI pins, held there by `tests/A11yCheckerPinTest.php`) over every page under `site/` in Docker, in light and dark at 320 px and 1280 px with the WCAG 1.4.10 reflow check: `sh scripts/a11y.sh` from Git Bash, Linux or macOS, `scripts\a11y.ps1` on Windows. It uses the same image and inputs as the a11y job in CI, so a page that passes here passes the pipeline. #### Tests in the apps it bakes The Laravel shapes (Blade, Blade + Vue islands, Inertia) come with Pest 4. The skeleton's PHPUnit example keeps running, `composer test` and `composer ci` run Pest, and the baked tests read `.env` when it exists, otherwise `.env.example`, on top of `phpunit.xml`. Their `.gitlab-ci.yml` runs the php-test matrix with `vendor/bin/pest` too, because PHPUnit refuses to load Pest files. Production refuses to boot on the tests' dummy `APP_KEY` (`app/Support/DummyAppKey.php`). The raw PHP shape is unchanged. Write new tests in Pest. ### CI Strongly recommended: a git.wayne.edu instance runner. Every baked `.gitlab-ci.yml` caches its downloads: Docker Hub images come through the group's GitLab Dependency Proxy when the GitLab has one (`IMAGE_PREFIX`, Docker Hub otherwise), and Composer and npm installs are cached per lock file. See [Dependency caching](https://github.com/waynestate/sourdough/blob/HEAD/docs/guides/ci.md#dependency-caching). Every baked pipeline also carries three gates from Preflight: an accessibility check of the app's own pages (signed in, at WCAG 2.2 AA, blocking), a CycloneDX bill of materials for Composer and, in the front-end shapes, npm, and Gitleaks over the repository. A `.deploy` template keeps any deploy job on protected refs, and each generated README lists the GitLab settings a file cannot hold. See [CI](https://github.com/waynestate/sourdough/blob/HEAD/docs/guides/ci.md#the-accessibility-gate). --- Source: https://sourdough.apps.wayne.edu/ A starter for Wayne State apps ## Sourdough Feed it and it grows. ![Sourdough logo: a starter jar whose starter has risen into a dome, well above the gold band that marks where it began](https://sourdough.apps.wayne.edu/brand/sourdough-avatar-512.png) Hungry. It has not been fed yet today. `sourdough new` makes a Wayne State app with the stack already in it: SESAME for sign-in, HELMET for the security headers, PROCTOR and Preflight for the checks, and Squire's files for deploying to Citadel. With no flags that's a raw PHP app, and you add WayneUI's standalone file with one download. All five shapes bake today, from raw PHP to Inertia. The whole recipe ``` $ composer global require waynestate/sourdough $ sourdough new my-app ``` **Want Laravel with Inertia and Vue?** Sourdough bakes it with `--inertia`. [WELD](https://weld.apps.wayne.edu/) is that shape already built, with the stack's product docs and site on top. [Start baking](https://sourdough.apps.wayne.edu/#start-title) [See the five loaves](https://sourdough.apps.wayne.edu/#loaves-title) Proofing log ### The proof What goes into the tub when you run `sourdough new`. 1. 08:00 **Mix.** `sourdough new` picks the shape; with no flags that's raw PHP. 2. 08:20 **Flour: WayneUI.** The interface, from WayneUI's standalone PHP file, which you download once. 3. 08:40 **Water: SESAME.** Sign-in. A fake driver locally, CAS in production. 4. 09:00 **Salt: HELMET.** Security headers, a hardened session, and `/up` for the load balancer. 5. 10:30 **Levain: PROCTOR.** The standards check. Preflight's CI components run it on every push, along with the tests, a Composer audit, an accessibility check of your own pages, a bill of materials and a secret scan. 6. 13:00 **Doubled.** Well past the gold band. A label goes on: `.sourdough/manifest.json`. 7. 14:00 **Divide and shape.** Cut into the five shapes the stack supports, every one of them ready to bake. On the cooling rack ### Five loaves, one starter These are the five app shapes the stack supports, and all five bake today. The proof harness bakes, boots and feeds forward every one of them: read [the latest proof](https://sourdough.apps.wayne.edu/docs/reference/proof.html). Score a loaf to see what's inside. Country boule #### Raw PHP Raw PHP with WayneUI's standalone path. No framework, no build. Out of the oven since 0.1.0 `sourdough new my-app --raw` The crumb - `public/index.php` HELMET boots first, then SESAME signs you in - `composer.json` helmet, sesame and Playbook, with pinstripe, proctor and advisor for dev - `pint.json` and `phpstan.neon` Pinstripe's standard: Pint on the per preset, PHPStan at level 8 - `.gitlab-ci.yml` Preflight components: PROCTOR, tests on PHP 8.3 to 8.5, audit, accessibility, SBOM and a secret scan, plus a `sourdough-feed` job - `build.sh` and `scripts/release.sh` Squire's Citadel deploy files - `.env.example` and `README.md` seeded: yours from day one - `.sourdough/manifest.json` the label on the jar Bâtard #### Raw PHP + Vue A Vue single-page app over JSON, on raw PHP. No framework, one build. Out of the oven since 0.1.6 `sourdough new my-app --raw --vue` The crumb - `public/index.php` the raw boot, then JSON under `/api/` and one page for Vue - `resources/js/App.vue` drawn with WayneUI's Vue components, pinned at 2.0.8 - `src/Vite.php` reads Vite's manifest, nonces every tag for HELMET - Next steps: `composer install`, `npm install`, `npm run build`, `composer serve` Baguette #### Laravel + Blade The classic Wayne State shape: Laravel with Blade views. Out of the oven since 0.1.5 `sourdough new my-app --laravel` The crumb A fresh Laravel skeleton from Composer with the stack wired in: SESAME through the Laravel adapter, HELMET's config, `/up` for liveness and `/ready` that asks the database, the cache and the scheduler, Pest 4, Laravel Boost for dev, Pinstripe's Laravel preset with Pint's findings in the merge request, PROCTOR and Preflight in CI, Squire's Laravel deploy files and the manifest. Oracle's `oci8` driver is required and waits, dormant, for its settings. Next steps: `composer install`, `cp .env.example .env`, `php artisan key:generate`, `php artisan migrate`, `php artisan serve`. Seeded loaf #### Laravel + Blade + Vue islands Blade pages with Vue islands, like seeds in the crust. Out of the oven since 0.1.5 `sourdough new my-app --laravel --vue` The crumb The Laravel + Blade bake under a front-end layer: Vite with the Vue plugin, and a `resources/js/app.js` registry that mounts a Vue 3 app on every `[data-vue-island]` element. Next steps add `npm install` and `npm run build` before `php artisan serve`. Tin loaf #### Laravel + Inertia/Vue Laravel with Inertia and Vue, as one app. Out of the oven since 0.1.5 `sourdough new my-app --inertia` The crumb Laravel with Inertia and Vue as one app: Inertia pages rendered by Vue, Ziggy routes, the stack packages, Squire's Laravel deploy files and the manifest. [WELD](https://weld.apps.wayne.edu/) is this shape already built, with the stack's product docs and site on top; you can also bake it yourself with `--inertia`. Not sure yet? [Place an order at the counter](https://sourdough.apps.wayne.edu/#order) and the ticket writes the command for you, or add `--dry-run` to any of these: it prints the plan and writes nothing. At the counter ### Place your order Pick a loaf, an oven and a name. The ticket writes the command, the bake and what to run after it, from the same code `sourdough new --dry-run --json` runs, so what you copy is what you get. Sourdough bakery #### Order ticket No. 1 For **my-app**, Raw PHP `sourdough new my-app --raw` ##### The bake 1. Copy the raw template into my-app 2. Replace {{app_name}} and {{app_slug}} in file names and contents 3. Wire ADVISOR into the app ##### Then run ``` cd my-app composer install php vendor/bin/advisor install --client=claude --write composer serve ``` The same plan `--dry-run --json` prints. Add `--dry-run` to see it on your own machine first. Recipe card No. 1 ### What's baked in Baker's percentages, roughly. The parts are Composer packages, so `composer update` updates them. Only the code that connects them lives in the template. **The parts of the stack in every Sourdough app, as ingredients** | Ingredient | Part | What it does in your app | | --- | --- | --- | | 100% Flour | [WayneUI](https://wayneui.apps.wayne.edu/) | The interface: WayneUI's standalone PHP file, fetched once into `public/`. | | 75% Water | [SESAME](https://sesame.apps.wayne.edu/) | Sign-in. The fake driver in development; the cas driver in production, with `SESAME_CAS_URL` and `SESAME_SERVICE_URL`. | | 2% Salt | [HELMET](https://helmet.apps.wayne.edu/) | The runtime baseline: security headers, session cookie flags, trusted proxies from `HELMET_PROXIES`, and `/up` answering `200 ok`. Every shape answers `/ready` too: in the Laravel shapes it answers 503 while the database, the cache or the scheduler is down, and the raw shapes add their own checks as the app grows. | | 20% Levain | [PROCTOR](https://proctor.apps.wayne.edu/) | The standards check. CI runs `vendor/bin/proctor check` on every push. The release script asks `proctor gate` for a go or no-go too, as a report unless you set `SQUIRE_PROCTOR=enforce`. | | 1 Oven | [Preflight](https://preflight.apps.wayne.edu/) | CI from `.gitlab-ci.yml`, pinned to Preflight 0.9.0: PROCTOR, tests on PHP 8.3, 8.4 and 8.5, a Composer audit, an accessibility check of your own pages at WCAG 2.2 AA that blocks, a bill of materials and a Gitleaks secret scan. | | 1 Recipe | [CREED](https://creed.apps.wayne.edu/) | The rules the loaf is judged by. Every bake reads its PHP floor from CREED's policy, and PROCTOR grades the app against the same file. | | 1 Basket | Release script | `build.sh` and `scripts/release.sh` come from Squire and run on Citadel at build and release time. Off Citadel, the app reads the same environment variables on OpenShift, Coolify or raw Docker. | | 1 Pinch | [ADVISOR](https://advisor.apps.wayne.edu/) | For your AI assistant: the stack's MCP server, in `require-dev`, answers from the stack's own docs. `--no-advisor` leaves it out. | Bake at `composer serve` until golden. Pinned above the bench ### Feeding schedule A starter you never feed goes flat. Every app Sourdough makes carries `.sourdough/manifest.json`: the Sourdough version, the template, the answers you chose, and a sha256 of every file. That's how `sourdough feed` knows which files it can update, and which ones you've kneaded. An app Sourdough did not make can get one too, on adoption day. 1. Bake day `sourdough new my-app` Makes the app and writes the manifest. Commit the manifest with the rest of the app. 2. Adoption day for a loaf we did not bake `sourdough adopt --shape raw` Sourdough can now look after an app it did not make. In the app, on a clean git tree, name the shape it already is: `raw`, `raw-vue`, `laravel-blade`, `laravel-blade-vue` or `laravel-inertia`. Adopt bakes that shape fresh, compares your files with it, and writes the one thing the app was missing: the manifest. Files that match get fed from then on, files that differ stay yours and are never overwritten, and files you lack arrive with the first feed. Your code is never touched. [Adopt an existing app](https://sourdough.apps.wayne.edu/docs/guides/adopt.html) walks through it. - **0**: adopted (or a dry run) - **1**: refused: not in git, a dirty tree, already adopted - **2**: no git, or the bake failed Adoption papers an old course finder, taken in ``` $ sourdough adopt --shape raw Adopting "course-finder" as a raw app (Raw PHP with WayneUI's standalone path) with Sourdough 0.4.2. Compared your app with a fresh raw bake: 41 template files. yours composer.json differs from the template: yours, never overwritten yours public/index.php differs from the template: yours, never overwritten seeded .env.example yours, as in every Sourdough app seeded README.md yours, as in every Sourdough app missing .gitlab-ci.yml the next sourdough feed adds it missing phpstan.neon the next sourdough feed adds it Adopted: 35 match, 2 yours, 2 seeded, 2 missing. Wrote .sourdough/manifest.json. Files the template does not ship are not recorded: Sourdough never reads or touches them. Next: git add .sourdough && git commit -m "Adopt with Sourdough 0.4.2" then sourdough feed --dry-run lists the 2 files the first feed adds. ``` 3. Any day the poke test `sourdough check` Bakers press the dough: if it springs back, it's ready. `sourdough check` is that poke for an app. In one read-only run it says whether the app is fed, which managed files you've kneaded, and whether its shape, and the Laravel or PHP line under it, still gets security fixes. It writes nothing, so run it any time. Your own edits are listed, never held against you: feed merges them. `sourdough manifest --check` is the drift half on its own, and every shape's pipeline runs both halves in its `sourdough-feed` job. - **0**: fed and supported - **1**: behind, deprecated, or past support - **2**: no manifest, or no git Poke test a course finder, two weeks after its last feed ``` $ sourdough check Support: supported, owned by Sourdough maintainers; PHP 8.3 gets security fixes until 2027-12-31 Manifest: clean: every managed file matches the manifest Feed: fresh: nothing to feed from Sourdough 0.5.0 OK: the raw app is fed and supported. ``` 4. Feeding `sourdough feed` Brings template updates into your app without clobbering what you changed. It bakes your shape again and lets git do a three-way merge, file by file; where you both changed the same lines, it leaves git's conflict markers for you instead of guessing. Run `--dry-run` first; every shape's pipeline runs it too, and warns when a feed is due. - **0**: fed (or already fresh) - **1**: fed, with conflicts to resolve - **2**: no manifest, no git, or a dirty tree #### Managed we keep feeding these - `public/index.php` - `composer.json` - `.gitlab-ci.yml` - Squire's deploy files: `build.sh`, `scripts/`, `deployments/`, `.squire/` - `.gitattributes`, `.gitignore` #### Seeded written once, yours now - `.env.example` - `README.md` - `package-lock.json` The lock comes only with a front end. Seeded files are never reported. They're yours to knead. #### Yours adopted, kept as you made them - `composer.json` - `public/index.php` Whatever differed on adoption day, like these two in the course finder. Never written, merged or reported. Make one match the template and the next feed takes it over. Quick start ### Your first loaf Sourdough is one PHP command, so the steps match on every system; only the shell changes. You need PHP 8.3 or newer and Composer. **Windows** PowerShell ``` # 1. Get the starter composer global require waynestate/sourdough # 2. Bake the app sourdough new my-app cd my-app # 3. Fetch WayneUI's standalone file once curl.exe -o public/wayne-ui.php https://wayneui.apps.wayne.edu/v2/releases/2.0.8/wayne-ui.php # 4. Install and serve composer install php vendor/bin/advisor install --client=claude --write composer serve ``` **macOS** Terminal (zsh) ``` # 1. Get the starter composer global require waynestate/sourdough # 2. Bake the app sourdough new my-app cd my-app # 3. Fetch WayneUI's standalone file once curl -o public/wayne-ui.php https://wayneui.apps.wayne.edu/v2/releases/2.0.8/wayne-ui.php # 4. Install and serve composer install php vendor/bin/advisor install --client=claude --write composer serve ``` **Linux** bash ``` # 1. Get the starter composer global require waynestate/sourdough # 2. Bake the app sourdough new my-app cd my-app # 3. Fetch WayneUI's standalone file once curl -o public/wayne-ui.php https://wayneui.apps.wayne.edu/v2/releases/2.0.8/wayne-ui.php # 4. Install and serve composer install php vendor/bin/advisor install --client=claude --write composer serve ``` ADVISOR answers questions about the stack from inside your AI assistant; skip it with `sourdough new --no-advisor`. To move to a newer WayneUI release, change the version in the URL above and run the fetch again. **`sourdough` not found?** Add the folder that `composer global config bin-dir --absolute` prints to your PATH. Then open `http://localhost:8000`: locally the app signs in with SESAME's fake driver. Hand it to your agent ### Recipes for your agent Four prompts for whatever coding agent you use. Copy one, or open it in OpenCode, Claude Code, Codex or ChatGPT. Each tells the agent what Sourdough put in the app and what it must leave alone, and each tells it to ask you before it guesses. #### Get started with Sourdough Installs Sourdough, makes a raw PHP app with WayneUI, serves it locally and runs the manifest check. A prompt for your coding agent. Copy it as it stands: ```text You are a coding agent helping a Wayne State University developer bake a new app with Sourdough, the app starter of WELD, the Wayne State application stack. Sourdough bakes all five shapes: raw PHP on WayneUI's standalone path (--raw or no flag), raw PHP + Vue SPA over JSON (--raw --vue), Laravel + Blade (--laravel), Laravel + Blade + Vue islands (--laravel --vue) and Laravel + Inertia/Vue (--inertia). Each comes with SESAME (sign-in), HELMET (security headers and the /up check), Pinstripe (coding standard), PROCTOR (checks), the Preflight CI components and Squire's deploy files already in it. Read first: - https://sourdough.apps.wayne.edu/llms.txt, the index of Sourdough's pages, each one as Markdown; llms-full.txt beside it holds the README too. Fetch what you need; do not work from memory. - ADVISOR, the stack's MCP server, if it is connected: get_project_status and read_project_docs for sourdough answer from the stack's own docs, and policy_lookup gives today's PHP support from CREED. If it is not connected, say so and work from the pages. How to add it: https://advisor.apps.wayne.edu/llms.txt Task: 1. Check that PHP 8.3 or newer and Composer are on the PATH, and say which versions you found. 2. Install the starter with `composer global require waynestate/sourdough`. If the sourdough command is then not found, add the folder that `composer global config bin-dir --absolute` prints to the PATH. 3. Bake the app with `sourdough new my-app --raw`, using the folder name I give you in place of my-app, and change into it. 4. Fetch WayneUI's standalone file once. Windows (PowerShell): `curl.exe -o public/wayne-ui.php https://wayneui.apps.wayne.edu/v2/releases/2.0.8/wayne-ui.php`. macOS and Linux: `curl -o public/wayne-ui.php https://wayneui.apps.wayne.edu/v2/releases/2.0.8/wayne-ui.php`. 5. Run `composer install`, then wire in ADVISOR with `php vendor/bin/advisor install --client=claude --write`, then `composer serve`, and tell me to open http://localhost:8000. Locally SESAME signs in with its fake driver. 6. Run `sourdough manifest --check` in the app and report what it says. Constraints: - Sourdough bakes all five shapes: raw PHP (--raw or no flag), raw PHP + Vue SPA over JSON (--raw --vue), Laravel + Blade (--laravel), Laravel + Blade + Vue islands (--laravel --vue) and Laravel + Inertia/Vue (--inertia). A --raw --vue app needs npm install and npm run build before composer serve shows the page. WELD is the Inertia/Vue shape already built, with the stack's product docs and site on top: https://weld.apps.wayne.edu/llms.txt - .sourdough/manifest.json records every file Sourdough wrote. Managed files are Sourdough's; .env.example and README.md are seeded and mine. Commit the manifest. - The deploy files (build.sh, scripts/release.sh, the .squire/ config) come from Squire. Never edit them by hand. - Never commit .env, and never paste a secret into a prompt or a file. - Give separate commands for Windows (PowerShell), macOS and Linux wherever they differ. - Ask me before you guess: a folder name, a PHP version you cannot read, or anything that touches a deploy. Output: what you ran and what it said, the app's files one level deep, then your questions. ``` #### Check what has drifted in a Sourdough app Lists the managed files that changed since Sourdough wrote them, shows what a feed would bring in, and suggests what to put back. It changes nothing. A prompt for your coding agent. Copy it as it stands: ```text You are a coding agent checking an app that Sourdough baked, at Wayne State University. Sourdough is the app starter of WELD, the Wayne State application stack. Every app it bakes carries .sourdough/manifest.json: the Sourdough version, the template, the answers chosen, and a sha256 hash of every file it wrote, each marked managed or seeded, or yours in an app Sourdough adopted. Read first: - https://sourdough.apps.wayne.edu/llms.txt, then llms-full.txt beside it: the README's manifest section says what managed, seeded and yours mean. - ADVISOR, the stack's MCP server, if it is connected: read_project_docs for sourdough and squire, and run_proctor_check for this app. If it is not connected, say so and work from the pages. - .sourdough/manifest.json, composer.json and public/index.php in this app. Task: 1. Run `sourdough manifest --check` at the app's root. Exit 0 is clean, 1 means a managed file changed or is missing, 2 is a tool error. 2. For each file it reports, say what changed, as far as you can tell, and whether it looks deliberate. 3. If ADVISOR is connected, call run_proctor_check for this app and list the findings. 4. Run `sourdough feed --dry-run` and list what a feed would update, merge, add, remove or leave in conflict. Exit 0 means fresh, 1 means feeding would change files, 2 is a tool error. 5. Change nothing. For each drifted file, propose whether to put it back or keep the change, and why. A kept change is fine: feed merges it with the template's. Constraints: - Seeded files (.env.example and README.md), and yours files in an adopted app, are mine and never count as drift. - The deploy files come from Squire, through Sourdough. Never hand-edit them to make a check pass. - Never run sourdough feed without --dry-run unless I say so: a real feed writes files. - Ask me before you guess, and before you touch anything that deploys. Output: a table (file, managed, seeded or yours, state, deliberate or not), the PROCTOR findings, then your proposals and your questions. ``` #### Bake a Laravel app with Sourdough Installs Sourdough, bakes one of the three Laravel shapes, serves it locally and runs the manifest check. A prompt for your coding agent. Copy it as it stands: ```text You are a coding agent helping a Wayne State University developer bake a new Laravel app with Sourdough, the app starter of WELD, the Wayne State application stack. Sourdough bakes three Laravel shapes: Laravel + Blade (--laravel), Laravel + Blade + Vue islands (--laravel --vue) and Laravel + Inertia/Vue (--inertia). Each comes with SESAME (sign-in), HELMET (security headers and the /up check), Pinstripe (coding standard), PROCTOR (checks), the Preflight CI components and Squire's deploy files already in it. Read first: - https://sourdough.apps.wayne.edu/llms.txt, the index of Sourdough's pages, each one as Markdown; llms-full.txt beside it holds the README too. Fetch what you need; do not work from memory. - ADVISOR, the stack's MCP server, if it is connected: get_project_status and read_project_docs for sourdough answer from the stack's own docs, and policy_lookup gives today's PHP support from CREED. If it is not connected, say so and work from the pages. How to add it: https://advisor.apps.wayne.edu/llms.txt Task: 1. Check that PHP 8.3 or newer and Composer are on the PATH, and say which versions you found. 2. Install the starter with `composer global require waynestate/sourdough`. If the sourdough command is then not found, add the folder that `composer global config bin-dir --absolute` prints to the PATH. 3. Ask me which shape I want: Blade (`--laravel`), Blade with Vue islands (`--laravel --vue`) or Inertia/Vue (`--inertia`), and whether I want `--sail` or `--docker` for the local runtime. Then bake the app with `sourdough new my-app` and those flags, using the folder name I give you in place of my-app, and change into it. 4. Run `composer install`, then `cp .env.example .env`, `php artisan key:generate` and `php artisan migrate`. For the islands and Inertia shapes, run `npm install` and `npm run build` before serving. With `--sail` or `--docker` the bake prints the oven's own Next steps; follow those when they differ. 5. Wire in ADVISOR with `php vendor/bin/advisor install --client=claude --write`, then serve the app with `php artisan serve`, and tell me to open http://localhost:8000. Locally SESAME signs in with its fake driver. 6. Run `sourdough manifest --check` in the app and report what it says. Constraints: - The app requires waynestate/playbook, WSU's private shared-values package on git.wayne.edu; the settings in .env.example come from it. If the bake refuses because this machine cannot read the package, tell me; do not pass --no-playbook, which is for CI and automated tests only. - .sourdough/manifest.json records every file Sourdough wrote. Managed files are Sourdough's; .env.example and README.md are seeded and mine. Commit the manifest. - The deploy files (build.sh, scripts/release.sh, the .squire/ config) come from Squire. Never edit them by hand. - Never commit .env, and never paste a secret into a prompt or a file. - Give separate commands for Windows (PowerShell), macOS and Linux wherever they differ. - Ask me before you guess: a folder name, a shape or an oven I have not named, or anything that touches a deploy. Output: what you ran and what it said, the app's files one level deep, then your questions. ``` #### Adopt an existing app with Sourdough Looks at an existing app with a dry run, picks the shape and the name with you, then writes the manifest and shows what the first feed would add. It changes no code. A prompt for your coding agent. Copy it as it stands: ```text You are a coding agent helping a Wayne State University developer bring an existing app under Sourdough, the app starter of WELD, the Wayne State application stack. Sourdough did not make this app. sourdough adopt writes the manifest the app would have had, .sourdough/manifest.json, so sourdough feed can keep it current from then on. It writes that one file and changes no code: files that match the template become managed, files that differ stay the app's own (yours) and are never overwritten, and files the app lacks are added by the first feed. Read first: - https://sourdough.apps.wayne.edu/llms.txt, then the Adopt an existing app guide it lists. Fetch what you need; do not work from memory. - ADVISOR, the stack's MCP server, if it is connected: read_project_docs for sourdough, and run_proctor_check for this app. If it is not connected, say so and work from the pages. - composer.json, package.json if there is one, and whether an artisan file sits at the app's root. Task: 1. Check that PHP 8.3 or newer, Composer and git are on the PATH, and say which versions you found. If the sourdough command is missing, install it with `composer global require waynestate/sourdough`. 2. Run `git status --short` at the app's root. If the folder is not a git repository, or the tree has changes, stop and tell me. Do not commit for me. 3. Propose the shape, one of raw, raw-vue, laravel-blade, laravel-blade-vue or laravel-inertia, with the evidence (artisan, inertiajs/inertia-laravel in composer.json, vue in package.json). Propose the name the app goes by, from composer.json. Ask me to confirm both. 4. Run `sourdough adopt --shape --name --dry-run` and summarize it: how many files match, are yours, seeded and missing, and any note (a name that looks wrong, an older Squire kit). 5. Only when I say so, run the same command without --dry-run, then `sourdough feed --dry-run`, and list the files the first feed would add. Constraints: - Pass --sail or --docker only for a Laravel app that runs on Sourdough's own oven files. An app with its own Docker setup gets neither. - Many yours files is a normal outcome, not a failure. For a Laravel app several majors behind, suggest upgrading with Booster first (https://booster.apps.wayne.edu/llms.txt): every hop brings more files level with the template. - Never edit, rename or delete the app's files to make more of them match. Never run sourdough feed without --dry-run unless I say so: a real feed writes files. - Never commit .env, and never paste a secret into a prompt or a file. - Give separate commands for Windows (PowerShell), macOS and Linux wherever they differ. - Ask me before you guess: the shape, the name, or anything that touches a deploy. Output: the shape and the name you propose with their evidence, the dry run's summary line with its yours and missing lists, then your questions. ``` The agent reads the same pages you do: [llms.txt](https://sourdough.apps.wayne.edu/llms.txt) lists them, [llms-full.txt](https://sourdough.apps.wayne.edu/llms-full.txt) holds them all in one file, and this page has a [Markdown twin](https://sourdough.apps.wayne.edu/index.md). Nothing here phones home. The buttons only copy text or open the tool you picked. The rest of the bakery ### Same kitchen, many ovens Sourdough is one part of the Wayne State app stack, and it starts every shape. [WELD](https://weld.apps.wayne.edu/) is the Inertia/Vue one already built from it: a Laravel app with Inertia and Vue, with the stack's product docs and site on top. #### In every loaf - [![WayneUI logo: a rounded frame holding a solid form, with a gold tab on the lower edge](https://sourdough.apps.wayne.edu/assets/marks/wayneui.svg) **WayneUI** the interface](https://wayneui.apps.wayne.edu/) - [![SESAME logo: an open door with a gold gap](https://sourdough.apps.wayne.edu/assets/marks/sesame.png) **SESAME** sign-in](https://sesame.apps.wayne.edu/) - [![HELMET logo: a white football helmet with a gold facemask](https://sourdough.apps.wayne.edu/assets/marks/helmet.png) **HELMET** runtime baseline](https://helmet.apps.wayne.edu/) - [![PROCTOR logo: a watchful eye with a gold square pupil](https://sourdough.apps.wayne.edu/assets/marks/proctor.png) **PROCTOR** the checks](https://proctor.apps.wayne.edu/) - [![Preflight logo: a runway with a gold center line](https://sourdough.apps.wayne.edu/assets/marks/preflight.png) **Preflight** shared CI](https://preflight.apps.wayne.edu/) #### From the same kitchen - [![CREED logo: a stone arch whose gold keystone holds the other stones in place](https://sourdough.apps.wayne.edu/assets/marks/creed.png) **CREED** the standards](https://creed.apps.wayne.edu/) - [![Pinstripe logo: a striped necktie with a gold tie bar](https://sourdough.apps.wayne.edu/assets/marks/pinstripe.png) **Pinstripe** the coding standard](https://pinstripe.apps.wayne.edu/) - ![Sourdough logo: a starter jar with a gold band](https://sourdough.apps.wayne.edu/brand/sourdough-avatar-256.png)**Sourdough** you are here - [![WELD logo: a welder's helmet](https://sourdough.apps.wayne.edu/assets/marks/weld.png) **WELD** Laravel and Vue](https://weld.apps.wayne.edu/) #### Also in the kitchen - [![Squire logo: a satchel with a gold buckle](https://sourdough.apps.wayne.edu/assets/marks/squire.png) **Squire** carries releases](https://squire.apps.wayne.edu/) - [![Parity logo: a spirit level with its gold bubble in the middle](https://sourdough.apps.wayne.edu/assets/marks/parity.png) **Parity** Citadel at home](https://parity.apps.wayne.edu/) - [![Rollcall logo: an open register with gold ticks](https://sourdough.apps.wayne.edu/assets/marks/rollcall.png) **Rollcall** every app, present](https://rollcall.apps.wayne.edu/) - [![ADVISOR logo: a speech bubble holding a gold compass needle](https://sourdough.apps.wayne.edu/assets/marks/advisor.png) **ADVISOR** the MCP server](https://advisor.apps.wayne.edu/) - [![Drawbridge logo: a castle tower lowering its bridge on a gold chain](https://sourdough.apps.wayne.edu/assets/marks/drawbridge.png) **Drawbridge** sign-in gateway](https://drawbridge.apps.wayne.edu/) - [![Booster logo: a syringe that is also a rocket, with one gold accent](https://sourdough.apps.wayne.edu/assets/marks/booster.png) **Booster** PHP upgrades](https://booster.apps.wayne.edu/) --- Source: https://sourdough.apps.wayne.edu/docs/agent-ready.html ## Agent ready [#](https://sourdough.apps.wayne.edu/docs/agent-ready.html#agent-ready) The front page is written for people and for the coding agents they use. Every page of this site answers a client that asks for `text/markdown` with the same page as Markdown, and nothing on it phones home: the buttons only copy text or open the tool you picked. ![The Sourdough front page: the whole recipe card with the two install commands, the Start baking and See the five loaves buttons, and the For your agent row with links to the prompts, the Markdown twin, llms.txt and ChatGPT](https://sourdough.apps.wayne.edu/docs/agent-ready/hero-menu-1440.png) ### The agent's reading list [#](https://sourdough.apps.wayne.edu/docs/agent-ready.html#the-agent-s-reading-list) - [llms.txt](https://sourdough.apps.wayne.edu/llms.txt) lists every page of the site with its title and description, points at the prompts and the source, and names the stack's other agent entry points. - [llms-full.txt](https://sourdough.apps.wayne.edu/llms-full.txt) holds the README and every page in one Markdown file. - Each page has a Markdown twin beside it (`index.md` next to `index.html`), linked from the page head with ``. An agent that fetches `llms.txt` gets a map; it then fetches only the pages it needs and works from them instead of from memory. ### Recipes for your agent [#](https://sourdough.apps.wayne.edu/docs/agent-ready.html#recipes-for-your-agent) The front page carries three prompts under [Recipes for your agent](https://sourdough.apps.wayne.edu/index.html#agents), ready for OpenCode, Claude Code, Codex CLI or ChatGPT. Each tells the agent what Sourdough put in the app and what it must leave alone, and each tells it to ask before it guesses. ![The Recipes for your agent section: three recipe cards, Get started with Sourdough, Check what has drifted in a Sourdough app and Bake a Laravel app with Sourdough, each with its prompt text, a Copy prompt button and Run it in buttons for OpenCode, Claude Code, Codex CLI and ChatGPT](https://sourdough.apps.wayne.edu/docs/agent-ready/agents-1440.png) #### Recipe No. 1: Get started with Sourdough [#](https://sourdough.apps.wayne.edu/docs/agent-ready.html#recipe-no-1-get-started-with-sourdough) Installs Sourdough, bakes a raw PHP app, fetches WayneUI's standalone file, serves it locally and runs the manifest check. The prompt points the agent at `llms.txt` first, then walks it through `composer global require waynestate/sourdough`, `sourdough new my-app --raw`, the WayneUI fetch, `composer install`, ADVISOR wiring, `php -S localhost:8000 -t public` and `sourdough manifest --check`. #### Recipe No. 2: Check what has drifted in a Sourdough app [#](https://sourdough.apps.wayne.edu/docs/agent-ready.html#recipe-no-2-check-what-has-drifted-in-a-sourdough-app) Runs `sourdough manifest --check` in an app Sourdough baked, lists the managed files that changed since Sourdough wrote them, and proposes what to put back. It changes nothing, and seeded files never count as drift. #### Recipe No. 3: Bake a Laravel app with Sourdough [#](https://sourdough.apps.wayne.edu/docs/agent-ready.html#recipe-no-3-bake-a-laravel-app-with-sourdough) Installs Sourdough, bakes one of the three Laravel shapes (Blade, Blade with Vue islands or Inertia/Vue) with the oven the developer chooses, serves it locally and runs the manifest check. The prompt points the agent at `llms.txt` first, then walks it through `composer global require waynestate/sourdough`, `sourdough new my-app` with the shape and oven flags, `composer install`, `cp .env.example .env`, `php artisan key:generate`, `php artisan migrate`, `npm install` and `npm run build` for the Vue shapes, ADVISOR wiring, `php artisan serve` and `sourdough manifest --check`. ![Recipe No. 1 with the OpenCode button chosen: the prompt rendered as a PowerShell command beside a bash or zsh tab, with a Copy command button](https://sourdough.apps.wayne.edu/docs/agent-ready/prompt-run-opencode-1440.png) Copy a prompt from the front page, or open it straight in your tool of choice. The commands in a prompt must stay the commands in these docs: the agent-ready check fails a prompt that runs a command the docs do not. --- Source: https://sourdough.apps.wayne.edu/docs/changelog.html ## Changelog [#](https://sourdough.apps.wayne.edu/docs/changelog.html#changelog) All notable changes to Sourdough are recorded here. The format follows Keep a Changelog; the project follows Semantic Versioning once 1.0 is out. ### Unreleased [#](https://sourdough.apps.wayne.edu/docs/changelog.html#unreleased) #### Changed [#](https://sourdough.apps.wayne.edu/docs/changelog.html#changed) - Fixed: the Squire copy docs name the `^0.11` dev dependency (they said `^0.10`), and StackPinsTest's comments name PROCTOR 0.16, the line the templates pin. Content only. - Changed: the deploy kit is Squire 0.11.1 (was 0.10.7): the release script, parity scripts, HAProxy pin and fallback base follow the new templates, and `waynestate/squire` is `^0.11` (the exported copy in `templates/squire/` moves with it). - `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). - Every generated app requires SESAME `^0.8`, Pinstripe `^0.4` and PROCTOR `^0.16` (was `^0.7`, `^0.3` and `^0.15`, which do not allow the current releases), and Sourdough's own dev dependency is Pinstripe `^0.4`. - Docs: each generated README says how to turn on the nightly run (a GitLab pipeline schedule reruns the full PHP test matrix); a test keeps scheduled pipelines from being skipped. - CI pins Preflight 0.9.0 (components and the a11y checker copy). - Every shape and the GitHub workflow pin Preflight 0.9.0 (commit fb73b53), like Sourdough's own pipeline. - Added: `sourdough check [dir] [--json]`, the baker's poke test: one read-only run that says whether an app is fed and supported. It prints the `Support:` line (the shape's status and owner and its Laravel major's or PHP floor's end-of-security date from CREED's policy), the manifest drift and whether a feed is due, then `OK` or a `Needs attention:` list. Exit `0` fed and supported, `1` behind the template, a deprecated shape or a line past security support, `2` the tool errors `feed --dry-run` stops on. The app's own edits are listed and never fail it. It writes nothing and needs no clean tree. BEST_PRACTICES 3.2 and backlog item 2 are done; `tests/CheckCommandTest.php` covers it. - Changed: Sourdough's own GitLab pipeline gains a blocking `smoke-floor` job that bakes the raw and Inertia shapes on PHP 8.3, the floor every shape pins in `config.platform.php`; the other smoke jobs bake on 8.5, so a template that quietly needed a newer PHP would have passed them. `tests/SmokeFloorTest.php` keeps the job's image on the templates' pin. No change to what a bake writes. - Docs: the front page and the README name Preflight 0.8.0, the release every pipeline pins (they still said 0.6.0), and `tests/PreflightPinTest.php` now fails when a sentence that names the pin on the front page, the README, MAINTAINING, BEST_PRACTICES or a docs page (not the changelog or upgrading notes) names another release. - CI pins Preflight 0.8.0. - Fixed: the front page's "Adopt an existing app" prompt asked the agent to run `sourdough adopt` with the values of `--shape` and `--name` missing: the `` and `` placeholders sat in the HTML unescaped, so browsers read them as unknown elements and the copied prompt, `index.md` and `llms-full.txt` lost them. They are escaped now, as is a raw `` in an old changelog entry, and `tests/SitePlaceholdersTest.php` fails on any element the page does not really use and on any flag left without its value. - Site: the order ticket has "Copy a link to this order", a link such as `https://sourdough.apps.wayne.edu/#order?loaf=laravel-inertia&oven=docker&name=Parking%20Permits&advisor=no` that opens the counter with the same loaf, oven, name and ADVISOR choice, so a lead can send a new developer the exact order. A loaf or oven that is not on the menu is ignored and the name goes through the usual rule, so a mangled link still lands on a good ticket. The button appears only once the script has opened the counter. - Docs: the every-OS guide says what to do when Windows will not run a script ("running scripts is disabled on this system"): on a Windows client with no execution policy set, PowerShell runs no script files at all, so it shows how to check the policy, set `RemoteSigned` for your own account, unblock a downloaded copy, or run one script with its own policy. It no longer says the generator's scripts are never affected. BEST_PRACTICES 5.3 says the same. - Docs: BEST_PRACTICES says what the code does today: 1.6 (each shape baked into a temp directory, the Laravel ones offline from the fixture skeleton) is `Checked`, 5.1 (`.gitattributes` pins in every shape, `GitattributesPinsTest`) is `Enforced`, 5.3 (Squire's `parity.sh` and `parity.ps1` in every shape) is `Checked`, and each line of the gap list says whether it is done (and where) or what is still open. - Site: the front page has an order counter (`#order`), the command half of the "new app" page (BEST_PRACTICES 1.8). Pick a loaf, an oven and a name and its ticket writes the `sourdough new` command, the bake and the next steps to copy, read from `site/assets/order-menu.json`, which `composer site:order-menu` builds from the same plan code as `sourdough new --dry-run --json`. `composer ci` fails when the menu is stale, and `tests/OrderMenuTest.php` runs every order the ticket can write through the real command. It checks names with the generator's rule and offers only the ovens a shape takes. - Added: `sourdough new --dry-run --json` carries `next_steps`, the lines a real bake prints under "Next steps:" for that shape and oven (Sail, Docker or the bench, with or without ADVISOR). The plan now owns them (`Plan::$nextSteps`), so the printed list and the JSON can never disagree; the printed output is unchanged. - Docs: the maintaining guide, the troubleshooting page and the README name Preflight 0.6.0, the release CI and the templates pin (they still said 0.1.4 or 0.5.0). - Added: the Laravel shapes include Preflight's `mysql56-migrate` component, so every pipeline runs the migrations against MySQL 5.6.51 (D-078); every Preflight pin moves to 0.6.0. - Changed: new bakes require PROCTOR `^0.15` (was `^0.12`) in the raw `composer.json` and both Laravel overlays, and the front page's deploy layer requires `^0.15` (locked 0.15.0). PROCTOR 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. - Docs: the shapes guide's quick start says each `sourdough new` line runs the same in Windows PowerShell as in sh (one PHP command, no bash or WSL needed). - Docs: MAINTAINING no longer says "in 0.1" for the shapes; three BEST_PRACTICES backlog lines carry a status, and the one that named a `sourdough check` command says it is not built yet. - Changed: the GitHub workflow calls Preflight 0.5.0's reusable workflow (pinned to its release commit), the same release as the GitLab pipeline; it was on 0.1.4 because GitHub's copy of Preflight had no later tag. - Fixed: the manifest line-ending test normalises the kit's `parity.ps1` before it starts, so it passes on a Windows checkout, where `.gitattributes` writes `.ps1` files with CRLF. - Docs: the README and templates reference name the Squire 0.10.7 kit and PROCTOR `^0.12` (was 0.10.6 and `^0.11`). - Changed: new bakes require PROCTOR `^0.12` (was `^0.11`) in the raw `composer.json` and both Laravel overlays, and the front page's deploy layer requires `^0.12` (locked 0.12.0). PROCTOR 0.12 adds two warning-only checks (`composer-cooldown`, `lock-tracked`); nothing breaks. - Added: sourdough feed prints the Support: line (owner, status and the framework's end-of-security date from CREED's policy) on every run, so the app's sourdough-feed CI job keeps showing when its framework stops getting security fixes; --json carries it as support. - Site: the front page's stale facts are current (every shape answers `/ready`, not only the Laravel ones, and the "Also in the kitchen" shelf links Parity's site instead of its repository, without the "coming soon" tag). - Added: generated Laravel apps turn on HELMET's fixed 4xx page (`helmet.error_pages`, env `HELMET_ERROR_PAGES`, default true in the app's `config/helmet.php`), so an `abort()` message never reaches a visitor; the raw shapes already had HELMET's neutral error page. - Added: every app shape's `composer.json` sets Composer's release cooldown (`config.policy.cooldown.period`: `"3 days"`), CREED's 2026-11-03 decision; Composer 2.11 waits that long before it installs a newly published version. - Changed: every app shape's root `.gitattributes` pins `*.ps1`, `*.bat` and `*.cmd` to CRLF and `*.sh` to LF (CREED every-OS rule); the Laravel shapes append the pins to the skeleton's file. - 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. The templates' Squire copy (`templates/squire/`) is 0.10.7 too. - Added: raw and raw + Vue apps answer GET /ready through HELMET's readiness option, and in production an uncaught exception gets HELMET's neutral error page (the full detail goes to the log). Locally, PHP still shows the error. - Docs: the templates reference's rules table, the Squire kit version (0.10.6) in the README and the templates reference, and BEST_PRACTICES 2.1 and backlog item 6 say what the generator does today. - Changed: the docs, agent-ready and deploy kits are Squire 0.10.6 (was 0.10.5): the docs builder and agent-ready generator see every file on Docker Desktop mounts. The `templates/squire/` copy and the lock move to 0.10.6 with them. - 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. - Version mentions: ADVISOR ^0.3 in the templates and generator, Squire kit 0.10.5 re-export, docs stamps current. #### Fixed [#](https://sourdough.apps.wayne.edu/docs/changelog.html#fixed) - Fixed: a fresh app installs again right after a stack release; the Composer cooldown now exempts the stack's own packages (`policy.cooldown.ignore`: `["waynestate/*"]`), which the templates require at their newest versions. ### 0.4.2 (2026-11-09) [#](https://sourdough.apps.wayne.edu/docs/changelog.html#0-4-2-2026-11-09) #### Added [#](https://sourdough.apps.wayne.edu/docs/changelog.html#added) - Added: every shape's README gains "Run it like Citadel" at the end of "Run it locally": the [Parity](https://git.wayne.edu/enterprise-apps/parity) commands that run the app on Citadel's PHP image, Apache, `php.ini`, proxy and MySQL 5.6.51, beside the everyday bench (`composer serve` or `php artisan serve`), which stays. Parity is a separate install, so Sourdough bakes no `parity.json`: `parity init --from-squire` writes it from the Squire kit every shape already ships, and that was proofed on a raw and a Blade bake (init, check, up and test). The raw shapes add `--no-cron`, because Parity would otherwise offer Laravel's scheduler to an app with no `artisan`, and say plainly that Citadel sets no `APP_ENV`, so a page boots as production and asks for CAS settings Parity 0.1.0 cannot set yet. The Laravel shapes add `npm install` for the Blade lock file and two `parity shell --user citadel` lines that migrate MySQL 5.6.51 and cache it, because the first deployment reads only `.env`. README is a seeded file, so apps you already baked keep theirs; copy the section from a fresh bake if you want it. New `tests/ParityReadmeTest.php` holds all five shapes to it. #### Changed [#](https://sourdough.apps.wayne.edu/docs/changelog.html#changed-1) - Docs: Parity joins the party. The README cast, the docs overview, Same kitchen, many ovens and the front page's "Also in the kitchen" shelf carry Parity next to Squire, with its spirit-level mark: the stack's new tool that runs Citadel on your computer (its PHP image, its proxy and MySQL 5.6.51). It has no site yet, so it links to its repository on git.wayne.edu and hangs on the shelf with the dashed "coming soon" tag. Squire packs the loaf for the trip; Parity checks it rises the same in the home oven. - Docs: the pages that pick a local runner say when to use Parity. Building on Laravel gains "Run it like Citadel: Parity" with a which-to-use-when list (the bench, Sail or `--docker` while you write code; Parity before a release, after a PHP or Laravel upgrade, or for a bug that only shows on Citadel), and Every developer, every operating system, Quick start, Commands and the README's `--docker` line point at it. The `--docker` and `--sail` README sections drop "swap in Squire's Citadel-parity image when it exists" and "local parity with Citadel's database is not possible": Parity runs Citadel's MySQL 5.6.51 today. They also say that those ovens point `.env` at their own MySQL, so set `DB_CONNECTION=sqlite` for Parity runs, or the first deployment stops at the migrate step with `Access denied` (proofed on a Blade bake). ### 0.4.1 (2026-11-09) [#](https://sourdough.apps.wayne.edu/docs/changelog.html#0-4-1-2026-11-09) #### Added [#](https://sourdough.apps.wayne.edu/docs/changelog.html#added-1) - Added: the Laravel shapes (Blade, Blade + Vue islands, Inertia) carry the Pinstripe extras WELD carries. A `composer lint:gitlab` script writes Pint's findings as a GitLab Code Quality report (`pint-codequality.json`, `[]` when clean, ignored by git); the `composer-ci` job runs it in `after_script`, so it still reports when `composer ci` fails, and keeps it as a `codequality` artifact for seven days, which puts Pint's findings in the merge request widget. Each bake also gets `tests/Unit/PinstripeWiringTest.php`, the app's own test that Pinstripe is a dev dependency, that `phpstan.neon` includes its Laravel preset and leaves the level and the bans to it, and that `pint.json` is Pinstripe's `laravel.json` plus the three recorded skips for Squire's files (`deploy`, `health.php`, `oracle-check.php`). A fed app whose `pint.json` skips more paths fails that test until each extra skip is written into the test with its reason. The raw shapes are unchanged: they use Pinstripe's per preset and have no Laravel wiring to guard. New `tests/PinstripeLaravelTest.php` holds every Laravel overlay and pipeline to the same extras. #### Changed [#](https://sourdough.apps.wayne.edu/docs/changelog.html#changed-2) - Changed: the GitHub `smoke` matrix blocks: `continue-on-error: true` is gone, because every shape baked green there (as on GitLab, whose smoke jobs block since 0.4.0). A red shape now fails the GitHub workflow too. #### Fixed [#](https://sourdough.apps.wayne.edu/docs/changelog.html#fixed-1) - Fixed: Sourdough's own tests pass on a tag build. Two `ManifestTest` tests expected the manifest's `sourdough_version` to be `dev`, but from a checkout sitting on a release tag Composer reports that tag, so `Manifest::packageVersion()` rightly says `0.4.0`; the 0.4.0 tag pipelines failed on it on both GitLab and GitHub. Branch pipelines never saw it (Composer reports a `dev-` branch there), and neither did a local Docker run, where git refuses the copied files as another user's and Composer falls back to its `no-version-set` placeholder. The tests now accept `dev` or a release, and the new `Manifest::versionFrom()` (which `packageVersion()` now calls) is tested on its own: a release stays as it is, and nothing, a branch or the placeholder becomes `dev`. No change to what a bake writes. ### 0.4.0 (2026-11-09) [#](https://sourdough.apps.wayne.edu/docs/changelog.html#0-4-0-2026-11-09) #### Upgrading [#](https://sourdough.apps.wayne.edu/docs/changelog.html#upgrading) - Upgrading: Pinstripe 0.3 may fail apps that build SQL by joining strings. Feed moves every shape to Pinstripe `^0.3`, and PHPStan then fails a variable concatenated, interpolated or `sprintf()`'d into the SQL given to `oci_parse()`, PDO, mysqli or Laravel's `DB::select()` and friends. Bind the value instead, or type your own whole-SQL helper's parameter `literal-string`. The fix, with an example, is in the [Upgrading page's 0.4.0 section](https://sourdough.apps.wayne.edu/docs/upgrading.html#0-4-0-2026-11-09). #### Changed [#](https://sourdough.apps.wayne.edu/docs/changelog.html#changed-3) - Changed: Sourdough's own GitLab smoke jobs (`smoke-raw`, `smoke-raw-vue`, `smoke-blade`, `smoke-blade-vue`, `smoke-inertia`) block the pipeline: `allow_failure: true` is gone from `.smoke-base`, because every shape baked green on CI. The scheduled `proof` job, which extends the same base, now fails a scheduled pipeline when it is red; started by hand it still only warns. The GitHub `smoke` matrix keeps `continue-on-error: true` for now. - Changed: every shape's `.gitlab-ci.yml` pins the Preflight CI components to the 0.5.0 release SHA (`60314791565a264e97cb210813ef4f3e76512402` with `# 0.5.0`, was 0.4.0), and Sourdough's own pipeline names the `0.5.0` tag. Inputs and job names are unchanged. What 0.5.0 brings a baked app: every Composer default is 2.11.1 by digest, and on PROCTOR 0.11 (which the shapes require) the raw shapes' proctor job also keeps PROCTOR's JSON report as `proctor.json`, the file Rollcall reads. Sourdough's own composer-audit include drops its `image` input (a `composer:2` digest), because 0.5.0's default is `composer:2.11.1` by digest. The vendored a11y checker is unchanged at 0.5.0; `tests/PreflightPinTest.php`, `tests/A11yCheckerPinTest.php` and `tests/RawGeneratorTest.php` expect the new pin. - Changed: every shape requires Pinstripe `^0.3` in `require-dev` (was `^0.1`; the raw shapes' `composer.json` and both Laravel overlays), and so does Sourdough itself (locked 0.3.0, was 0.1.4, with `spaze/phpstan-disallowed-calls` 4.15.0 new in the lock). This crosses two 0.x minors, and both break code that uses what they ban: 0.2.0 bans `eval()`, `extract()`, `var_dump()`, `dd()`, `dump()` and `Http::withoutVerifying()`, and 0.3.0 bans SQL joined from strings, TLS checks turned off, and Laravel's `dd()` and `dump()` methods. The raw shapes' `src/Oracle.php` now types `query()`'s `$sql` as `literal-string` (PHPDoc only, no behavior change), so the joined-SQL ban passes the helper and checks every caller instead; on the old `string` type a fresh raw bake failed PHPStan at its `oci_parse()` call, which `tests/PinstripeRawTest.php` now catches. - Changed: every shape requires ADVISOR `^0.2` in `require-dev` (was `^0.1`; `RawGenerator::ADVISOR_VERSION`, the raw shapes' `composer.json` and both Laravel overlays), the same pin WELD carries. ADVISOR 0.2.0 is a dev-only MCP server, so no app code changes; `--no-advisor` still leaves it out. - Changed: the deploy kit is Squire 0.10.3 (was 0.10.2), in the checked copy (`templates/squire/`, which every bake takes) and in the front page deploy layer (`deploy/`); Sourdough's dev dependency is locked at 0.10.3. The kit's comments name what they used to cite by internal item ID, and nothing else changes. `squire init --check` on `deploy/` and `composer squire-copy:check` pass. - Changed: the proctor job on Sourdough's own deploy layer (`deploy/`) blocks the pipeline: its `allow_failure: true` is gone, because `proctor check` on `deploy/` passes on PROCTOR 0.11.1 (warnings only). #### Docs [#](https://sourdough.apps.wayne.edu/docs/changelog.html#docs) - Docs: the Docker commands in the README's and the Testing guide's "From the repo root" blocks pin the CI image, `composer:2.11.1@sha256:8de2184c...`, instead of the floating `composer:2`, like MAINTAINING and the `composer ci` line already did. - Docs: the README's which-command table no longer says `rollcall report` always exits 0: it exits 0, or 2 on a tool error (no scan yet, a bad option, an unreadable policy), the same words as WELD's table. ### 0.3.0 (2026-11-09) [#](https://sourdough.apps.wayne.edu/docs/changelog.html#0-3-0-2026-11-09) #### Added [#](https://sourdough.apps.wayne.edu/docs/changelog.html#added-2) - Added: the `sourdough adopt` command, so `sourdough feed` can look after an app Sourdough did not make: `sourdough adopt [] --shape [--name ] [--sail | --docker] [--no-playbook] [--no-advisor] [--dry-run] [--json] [-v]`. It writes `.sourdough/manifest.json` and nothing else, and prints each template path as `yours`, `seeded` or `missing` (`match` too with `-v`); a top-level folder whose every file is missing prints as one line, and `--json` lists every path. `--shape` is required (the refusal names the shape the app looks like), and the name defaults to the folder's. It refuses, with exit 1, an existing manifest, a leftover `.sourdough/base/`, a name the template cannot use, a folder outside git and a dirty tree; no git, a folder it cannot write and a failed bake are exit 2. A dry run writes nothing and turns the git and writable checks into notes. The wrong-name note now comes at two hinted files, not three, so a raw or laravel-blade app gets it too. Feed's "no manifest" message now says `sourdough adopt --shape `. New `tests/AdoptCommandTest.php`, `tests/AdoptFeedTest.php` and the fixture `tests/fixtures/adopt/legacy-raw/`. - Added: the adopt engine's edge cases, still with no command. A template path that is a symlink, or sits under a symlinked folder, is `yours` ("a symlink: Sourdough never writes through links") even when the link points nowhere, and so is a file whose `realpath()` leaves the app (a Windows junction). A file named in another case (`readme.md` for `README.md` on a case-insensitive disk) is `yours`, named as the disk has it. A file more than twice the template's size plus 1 KiB is `yours` without being read. A `yours` file that lacks the name the template writes into it says so, and two of those add a note that the `--name` may be wrong. The plan's notes also carry the deprecated-shape notice and a note when `.squire.json` records an older or newer Squire kit than the one Sourdough bakes. Adopt refuses a `.sourdough/base/` left from a manifest that is gone. New `tests/AdoptEdgeCasesTest.php`. - Added: the engine behind the coming `sourdough adopt` (`src/Adopt/`), with no command yet. Given an existing app, a shape and a name, it bakes that shape into a scratch dir through the same Baker `new` and `feed` use, then looks at each template path in the app, and only those: no file is `missing` (left out of the manifest, so the next feed adds it), a file the template seeds is `seeded`, a file equal to the template's (line endings aside) is `match` and recorded as managed, and anything else is `yours`. Every recorded hash is the template's, the answers are the ones `new` would record plus `adopted: true`, and applying writes `.sourdough/manifest.json` and nothing else. It refuses an app that already has a manifest. `Permutation::flags()` now gives the flags a shape implies, for `new --plan` and adopt alike. New `tests/AdoptTest.php`: a lost manifest on every shape and oven adopts back to the bake's record, an edited app keeps its edits and its own files, a CRLF checkout matches, and feed then treats each status as the spec says. - Added: the manifest has a third file class, `yours`, for the coming `sourdough adopt`: a template file an adopted app keeps its own version of. `sourdough feed` never writes, merges, removes or reports a yours file and keeps no base copy of it, so the generated `sourdough-feed` job stays green; once the app's copy equals the template's, feed records it and manages it from then on. `sourdough manifest --check` skips yours files, as it skips seeded ones. Nothing writes the class yet, and `schema` stays 1. New `tests/FeedYoursClassTest.php`. - Added: deprecations fail the tests, in Sourdough's own suite and in every shape it bakes (BEST_PRACTICES 4.13, now `Enforced` for the suites). The phpunit config sets `failOnDeprecation` and `failOnPhpunitDeprecation` and skips indirect deprecations; the Laravel shapes get it on the skeleton's `phpunit.xml` at bake time, plus `tests/Support/ReportsDeprecationsToPhpUnit.php`, because Laravel's error handler drops deprecations while testing. Template code bakes clean on PHP 8.5, and the one PHPUnit deprecation in Sourdough's own tests (a doc-comment data provider) is now an attribute. - Added: the front-end shapes (raw + Vue, Blade + Vue, Inertia) ship a `package-lock.json`, seeded so npm owns it after the bake, and their `frontend` job installs it with `npm ci --ignore-scripts`, then fails on a high or critical `npm audit` finding (BEST_PRACTICES 4.10, now `Enforced`). New `tests/TemplateNpmLockTest.php` keeps each lock in step with its `package.json`, the smoke jobs install with `npm ci`, and apps already baked get the template's lock from `sourdough feed` only when they have none. - Added: the Laravel shapes (Blade, Blade with Vue, Inertia) ship `tests/Feature/JobLimitsTest.php`, which fails on any queued job under `app/Jobs` without Laravel's `#[Tries]` and `#[Timeout]` (the older `$tries` and `$timeout` properties count too) or with a timeout at or above the queue connection's `retry_after`; it passes while there are no jobs and is tested on fixture jobs that break each rule (WELD W18, W20). `stubs/job.queued.stub` and `stubs/job.batched.queued.stub` make `php artisan make:job` write `#[Tries(3)]` and `#[Timeout(45)]`, and `tests/LaravelJobLimitsTest.php` holds every Laravel shape to both. - Added: tests/KitRoutesAbsentTest.php: no Laravel shape ships Fortify, Breeze or Jetstream, a routes/auth.php, or registration, password reset, email verification or two-factor routes (BEST_PRACTICES 2.2, backlog 5). - Added: the generated README carries a Support section with the support line `sourdough new` prints (status, owner and the end-of-security date from CREED's policy), on every shape (BEST_PRACTICES 2.4). - Added: WORKER_HEARTBEAT_MAX_AGE=0 turns the scheduler heartbeat check off, so an app that runs no scheduler still answers 200 on /ready. - Added: new bakes take the PHP floor from CREED's `policy.json` (BEST_PRACTICES 4.2, now `Enforced`). Sourdough requires `waynestate/creed` `^0.1` and reads its policy, or the file `SOURDOUGH_POLICY` names. As of the policy's `refreshed_on`, the floor is the oldest PHP line still supported 365 days later, bounded by the Laravel major's PHP range on the Laravel shapes. It is written into `composer.json` (`require.php`, `config.platform.php`), the `.gitlab-ci.yml` matrix and the README on all five shapes. A policy that cannot be read bakes on the pinned fallback (`^8.3`, tested on 8.3, 8.4 and 8.5) and says so. Today's output is unchanged. `sourdough new` prints a `PHP:` line, and `--dry-run --json` gains a `php` object. `tests/PhpFloorTest.php` changes the policy's floor and checks every shape. - Added: every shape has an owner role, a support status and a sunset path (BEST_PRACTICES 3.7, now `Checked`). The new "Support and sunset" guide (`docs/guides/support.md`) is the policy (the window lengths are a proposal), and `resources/shapes.json` holds the fields. `sourdough new` prints a `Support:` line with the framework's end of security from CREED, and `--dry-run --json` gains `support`. A deprecated shape prints a notice on every `new` and `feed`, and feeding a removed shape names its replacement. `tests/ShapeSupportTest.php` holds the catalog to the rules. - Added: every shape's pipeline carries three gates from Preflight 0.3.1 (BEST_PRACTICES 4.15, 6.4 and 6.5, now `Enforced`; 3 practices remain `Not yet`). Accessibility: an `a11y-pages` job boots the app with SESAME's fake driver and saves its pages (`/`, plus `/dashboard` signed in on the Laravel shapes), and the `a11y` component checks them at WCAG 2.2 AA, blocking. Bill of materials: the `sbom` component keeps `sbom.cdx.json`, and the front-end shapes' `frontend` job adds `sbom-npm.cdx.json` from CycloneDX's npm tool. Secrets: the `secret-detection` component runs Gitleaks, and a hidden `.deploy` template keeps any future deploy job off merge requests and on protected refs. Each generated README's new "Pipeline" section lists the GitLab settings a file cannot hold. New `tests/TemplateCiGatesTest.php`, plus `testBakedPipelineCarriesTheCiGates` in every generator test, holds all five shapes to it. - Added: the Laravel + Blade + Vue islands shape has its own `.gitlab-ci.yml` with a `frontend` job (it used to inherit the Blade pipeline, which never built its front end). - Added: the Laravel shapes (Blade, Blade with Vue, Inertia) ship Laravel Boost ^2.10 in require-dev, the stack's guidelines in `.ai/guidelines/wayne-state.md` (managed) and starter rules in `.ai/rules/` (seeded), a `.gitignore` block for what `boost:install` writes (`/.mcp.json`, `/boost.json`, `/AGENTS.md`, `/CLAUDE.md`, `/.claude/skills/`, `/.junie/`; `.agents/` stays tracked for Booster), a guarded `composer boost-update` appended to Laravel's `post-update-cmd`, a README section, and `tests/Feature/BoostDevOnlyTest.php`, which fails when Boost leaves require-dev or packages-dev. `tests/BoostWiringTest.php` holds the wiring; BEST_PRACTICES 2.3 is `Enforced`. - Added: every app with a front end ships an `.npmrc` with a one-day npm cooldown (`min-release-age=1`), a `.nvmrc` and `engines.node >=22` in its `package.json`; the shapes without a front end get none of it (BEST_PRACTICES 4.9 and 4.11 are `Checked` by the generator tests). - Added: the Laravel shapes schedule a heartbeat each minute and register HELMET's readiness route at /ready with a scheduler check; while the cache stamp is missing or older than WORKER_HEARTBEAT_MAX_AGE seconds (default 180) /ready answers 503, so a stopped scheduler shows up instead of quietly dropping jobs. /up stays the liveness answer and never looks at the cache (WELD W23). - Added: the Laravel shapes can run the queue from the scheduler, for Citadel where nothing supervises a worker: with QUEUE_WORKER_MODE=scheduler (the new .env.example default) routes/console.php starts queue:work --stop-when-empty --max-time=50 --tries=3 every minute with withoutOverlapping(10); QUEUE_WORKER_MODE=none leaves the queue to a supervisor. QueueWorkerScheduleTest covers both (WELD W19). - Added: the two Laravel shapes ship tests/Feature/SchedulerNamingTest.php, which fails on any scheduled closure without ->name() (WELD W21). - Added: CI runs Preflight's a11y component (0.3.1) on site/, every page in light and dark at 320 and 1280 px with the WCAG 1.4.10 reflow check, blocking. - Added: the Laravel shapes (Blade, Blade with Vue, Inertia) test that a POST without a CSRF token gets 419, and that a matching token or a same-origin request passes (CsrfTest, WELD W27). - Added: Laravel apps (Blade, Blade with Vue, Inertia) refuse to boot in production with APP_DEBUG on (ProductionDebug, beside the dummy-key guard). - Added: every shape's `.gitlab-ci.yml` runs a `sourdough-feed` job (BEST_PRACTICES 3.2, now `Checked`): on the shape's `composer` image, through `${IMAGE_PREFIX}` and the Composer cache, it installs the newest Sourdough release and runs `sourdough manifest --check` and `sourdough feed --dry-run`. Drift in managed files is listed and never fails (feed merges it); a template release the app has not fed exits 1, which `allow_failure: exit_codes: [1]` shows as a warning, so it never blocks a deploy; exit 2 (no manifest, a newer manifest, leftover conflict markers, a failed bake) fails the job. Apps already baked get the job with their next `sourdough feed`. New `tests/TemplateFeedJobTest.php` holds every shape to the same job and runs its lines on fresh, edited, older and broken bakes of all five shapes and both ovens. BEST_PRACTICES 1.1, 1.2 and 1.3 are `Enforced` and name the tests that hold them. #### Changed [#](https://sourdough.apps.wayne.edu/docs/changelog.html#changed-4) - Changed: new bakes require HELMET `^1.3` (was `^1.0`), SESAME `^0.7` (was `^0.6`) and PROCTOR `^0.11` (was `^0.8`) in the raw `composer.json` and both Laravel overlays, and the Laravel overlays CREED `^0.1.8` (was `^0.1`). SESAME 0.7 and PROCTOR 0.11 are minor moves across a 0.x line: SESAME's `NativeSession` now warns once per request when the session cookie lacks HttpOnly, Secure or a Lax or Strict SameSite (the raw shapes call `helmet_boot()` before `session_start()`, and the kit's `php.ini` sets Lax, so a baked app stays quiet), and PROCTOR 0.9 to 0.11 add checks that mostly warn (`case-clash` and Boost or Debugbar in `require` fail). The front page's deploy layer moves to CREED `^0.1.8`, HELMET `^1.3` and PROCTOR `^0.11` (locked 0.1.8, 1.3.0 and 0.11.1; were 0.1.7, 1.0.0 and 0.8.0), and Sourdough's own CREED requirement to `^0.1.8` (Pinstripe locked 0.1.4, was 0.1.0). BEST_PRACTICES 4.4, 4.6 and 5.2 name the new constraint, and 4.6 and 5.2 lose the gaps that waited for it. - Changed: every shape bakes Squire 0.10.2's kit (was 0.10.0), and the front page's deploy layer runs it too (`squire update`; `squire init --check` passes; the dev dependency stays `^0.10`, locked 0.10.2). `.squire/php.ini` sets `session.cookie_samesite = Lax` (it was empty), so a raw app's session cookie gives SESAME 0.7 nothing to warn about; the kit's Dockerfiles name every image in full (`docker.io/library/...`) so Buildah and Podman build them, the fallback base copies Composer 2.11.1 from a `COMPOSER_IMAGE` stage, and the portable image drops `node_modules/` after the frontend build. A fed app takes the three files on its next `sourdough feed`, like any kit move. - Changed: Composer 2.11.1 everywhere a pipeline, Dockerfile or documented command names it (was 2.10.3, which Squire calls unmaintained; 2.11.1 fixes GHSA-c968-33g3-wh7p and GHSA-fm2w-xgf2-f9fh), pinned by its multi-arch list digest (`sha256:8de2184c...`, arm64 included): every shape's `composer-ci`, `sourdough-feed` and `a11y-pages` jobs, the Docker oven's `composer-bin` stage, Sourdough's own `composer-ci` and `wayneui-copies` jobs, the smoke image and the smoke jobs' checksummed phar (cache key `smoke-tools-composer-2.11.1-node-22.23.4`). A fresh bake picks it up; an existing app takes it on its next `sourdough feed`. - Changed: the deploy kit is Squire 0.10.0 (was 0.9.0): no kit file changed, so the record moves to 0.10.0, and the dev dependency on waynestate/squire is now ^0.10 (locked 0.10.0). The README, the templates reference and the docs index name the 0.10.0 kit too. - Changed: the Laravel shapes' SESAME config defaults the CAS protocol to 2.0, as SESAME does, because WSU's CAS is believed to refuse the cookieless /p3/ validation CAS 3.0 uses; set SESAME_CAS_PROTOCOL=3.0 for a CAS server that answers it. - Changed: BEST_PRACTICES.md closes backlog 6, now that PROCTOR has all four checks it asked for: 4.6 is `Checked` on PROCTOR main (`vite-secrets` warns on secret-looking `VITE_` names, not released yet), 4.4 names `app-key` and `env-outside-config` for a committed `.env` and `env()` outside config, and 5.2 names 0.9.0's `case-clash`. Baked apps get `vite-secrets` and `case-clash` once the shapes move past PROCTOR `^0.8`. - Changed: every shape bakes Squire 0.9.0 (was 0.8.0; the dev dependency is `^0.9`), and the front page's deploy layer moves from kit 0.7.1 to 0.9.0, gaining the portable image files. A Laravel release now stops before anything installs when `APP_KEY` is unset or `APP_DEBUG` is true in production and warns when `APP_ENV` is not production (BEST_PRACTICES 4.14, `Checked` for the release half; every Laravel shape's generator test pins it), and the release gate grades the PHP that runs it (`SQUIRE_PHP_RUNTIME`). - Changed: the Vue shapes' npm audit blocks on high or critical advisories in runtime dependencies only (--omit=dev); a second run lists dev-only findings without failing. - Changed: in the Laravel shapes (Blade, Blade with Vue, Inertia), `/ready` checks the database and the cache as well as the scheduler heartbeat (`app/Health/DatabaseReady.php`, `app/Health/CacheReady.php`), and answers 503 when one fails while `/up` stays liveness and never asks (WELD W11). The route moves from `routes/web.php` to `bootstrap/app.php`, outside the web group, as HELMET's readiness guide asks, so a probe no longer writes a session row or sets a cookie. `tests/Feature/ReadyChecksTest.php` breaks each dependency in turn, and `tests/LaravelReadyChecksTest.php` holds every Laravel shape to it. - Changed: the front-end templates floor Vite at ^6.4.1, the CVE-2025-62522 fix line, and ignore \*.local, where Vite keeps local secrets (BEST_PRACTICES 4.12). - Changed: every app shape and Sourdough's own CI pin Preflight 0.4.0 (87d9b6f; the proctor job clones the full history, so the override-approver check can read git blame). - Changed: the Laravel shapes' `config/helmet.php` holds only the app's `policy_path` override, and HELMET's provider merges the rest from the package (BEST_PRACTICES 3.6). The old 403-line copy had fallen behind HELMET: it had no Playbook lookup for `HELMET_PRESET`, and no `session.secure`, metrics storage or warn settings. Feed replaces an unchanged copy, and an edited one gets a conflict to keep your own keys. 3.6 lists the template code still waiting for a library, starting with `config/sesame.php`, which skips Playbook's CAS URL and defaults CAS to protocol 3.0. - Changed: a Laravel bake drops the skeleton's `CLAUDE.md` and `AGENTS.md` when they hold only Laravel's Boost bootstrap block (`boost:install` writes them again); a file with other guidance is kept and stays in git. The overlay merge appends `pre-` and `post-` Composer hooks to the skeleton's instead of replacing them, and a new `gitignore-additions.txt` control file adds ignore lines once. - Changed: `--no-advisor` removes only ADVISOR's own `.mcp.json` line; the Laravel shapes keep `/.mcp.json` ignored for Boost. - Changed: BEST_PRACTICES.md marks 18 practices with their true status on main (exit codes, output, kit features off, Boost, the Laravel window, MySQL 5.6, env config, VITE\_ secrets, Composer in CI, npm ci, Vite on localhost, the PHP matrix, APP_KEY, CRLF, Docker images, three OSes, templates as archives, boring startup); 9 remain Not yet. - Changed: every image in the baked CI files is pinned by digest: composer:2.10.3 now carries its multi-arch list digest, like the Node image already did. - Changed: the smoke jobs download Composer 2.10.3 and Node 22.23.4 once into a CI cache, check each sha256, and reuse them, instead of fetching both from the internet in every job. - Changed: the deploy layer and the templates/squire copy run Squire's kit 0.7.1 (was 0.7.0): .squire/php.ini no longer sets the deprecated session.sid\_\* lines. - Changed: the scheduled queue worker in the Laravel shapes sets --timeout=45, below the connection's retry_after (Laravel's default 90), and QueueWorkerScheduleTest checks the two (WELD W20). - Changed: every shape bakes Squire 0.8.0 (was 0.7.1): generated apps get the portable image (`.squire/portable.Dockerfile` and `.squire/portable/`), one image that runs as web, worker, scheduler or migrate for OpenShift, Coolify and raw Docker, and the READMEs say how to build it. - Changed: the local a11y scripts run Preflight's own checker (vendored from 0.3.1 and pinned by a test), so they check what CI checks: axe-core 4.14.0, 320 and 1280 px, and the reflow check. - Changed: every app shape and Sourdough's own CI pin Preflight 0.3.1 (b90323b; fixed cache keys, and caches saved even when a job fails). - Changed: every app shape's CI saves its Composer and npm caches even when a job fails, so a retry after a dropped download fetches only what is missing. - Changed: new bakes require SESAME ^0.6 (was ^0.5); SESAME 0.6.0 has no breaking change for an app that keeps its driver. - Changed: new bakes start on the Squire 0.7.0 deploy kit: the release script restarts queue workers and the scheduler after optimize (report only; SQUIRE_ARTISAN_RESTART=0 turns it off), and the image drops shell functions from the web's PHP (SQUIRE_PHP_DISABLE_FUNCTIONS), turns on production opcache (SQUIRE_OPCACHE_VALIDATE) and reads secrets from /run/secrets. Sourdough's own deploy layer moves too. - Changed: every app shape's CI caches Composer and npm downloads under a fixed key, so a lock change downloads only what changed. - Changed: HELMET moves to `^1.0`, its first stable release, wherever this repo requires it. - Changed: every shape requires PROCTOR ^0.8 (was ^0.7): the raw `composer.json` and both Laravel overlays. Breaking for apps you feed whose deploy scripts have Windows line endings, which PROCTOR 0.8's `crlf-deploy-script` fails; the upgrading page has the steps. The deploy layer requires PROCTOR ^0.8 (locked 0.8.0). #### Fixed [#](https://sourdough.apps.wayne.edu/docs/changelog.html#fixed-2) - Fixed: the raw and raw + Vue pipelines' header comment says the components are pinned to the Preflight 0.4.0 release commit (it said 0.3.0; the pin was already 0.4.0), and the comment on Sourdough's own deploy-layer PROCTOR job no longer lists findings PROCTOR 0.11 does not report. Comments only. - Fixed: the manifest leaves out database/database.sqlite, so sourdough feed never treats an app's database as a template file and WELD's regen gate does not see it as drift. - Fixed: Laravel bakes (blade, blade-vue, inertia) create an empty database/database.sqlite when .env.example uses sqlite, as Laravel's own installer does, so the printed php artisan migrate runs without a prompt. - Fixed: the Laravel shapes' ProductionDebugTest passes the app's own Pint check and every case asserts something. - Fixed: the docs menu closes with Escape and hands focus back to its button (docs kit synced from Squire). - Fixed: scripts/a11y.ps1 works on a Windows checkout with CRLF line endings; it strips the carriage returns from the shell command it hands to Docker, which sh rejected with a syntax error. - Fixed: the docs kit's copy button no longer covers the first line of code when it says Copied or Failed: over the code it keeps its resting width and shows a check or a cross when the word does not fit (docs kit synced from Squire). - Fixed: `sourdough manifest --check` forgives line endings, as `sourdough feed` does. The raw shapes' `.gitattributes` checks `*.ps1` out with CRLF, so every clone of a fresh raw app reported `scripts/parity.ps1` as changed. `tests/ManifestCommandTest.php` covers it. - Fixed: BEST_PRACTICES.md practice 3.4 counts the 0.2.0 tag among the releases that follow the release steps. #### Docs [#](https://sourdough.apps.wayne.edu/docs/changelog.html#docs-1) - Docs: the upgrading guide's 0.3.0 section says what a feed brings an app baked with 0.2.0 (the HELMET, SESAME, PROCTOR and CREED moves, Composer 2.11.1, the Squire 0.10.2 kit), the five breaking cases with a fix for each, what SESAME 0.7's cookie check means for a raw app, and the steps and checks, with `sourdough adopt` at the top for apps Sourdough did not make. The README gains a status line, and the install guide, docs index and front page ticket say 0.3.0. - Docs: MAINTAINING's "Who maintains it" names the stack maintainer as a role, not a person, and says to open an issue on git.wayne.edu to reach them; a CI comment, a test comment and BEST_PRACTICES 4.3 stop citing internal decision numbers. - Docs: `sourdough adopt` is documented. A new guide, Adopt an existing app (`docs/guides/adopt.md`, in the nav after The manifest), joins a `sourdough adopt` section in the commands reference, the `yours` class in the manifest guide, a troubleshooting entry for each refusal, and updates to the README, MAINTAINING, BEST_PRACTICES, keeping-current, CI, upgrading and docs index pages. On the front page, the feeding schedule gains an Adoption day row with a real adopt report and a Yours jar, a fourth agent prompt adopts an existing app, and the chalk rows now write themselves on even when a jump or a quick scroll skips past their edge. - Docs: the README, docs pages and front page catch up with main. Preflight 0.4.0 replaces 0.3.1 and 0.3.0 in the CI guide, MAINTAINING, troubleshooting (the 0.4.0 SHA), BEST_PRACTICES and the vendored a11y checker line; the templates reference names Squire 0.9.0's kit (`^0.9`) and SESAME `^0.6`; the front-end pages show the runtime-only `npm audit --omit=dev`; the CI guide names the Laravel shapes' `proctor-root` job; "in 0.1" claims are gone, and `--describe` is said to stop at the plan. The README says Sourdough starts every shape and that the Laravel shapes keep `oci8` ready. The front page no longer says the generated CI skips `sourdough manifest --check`, lists `package-lock.json` as seeded, adds CREED and ADVISOR to the recipe card and the CI gates to the proofing log, names the release that first baked each loaf, and its footer links the docs and git.wayne.edu. `site/llms.txt` and `llms-full.txt` are titled Sourdough again (they said `# .`): the README's title moves out of the centered HTML block the agent-ready kit drops. - Docs: the CI guide, MAINTAINING and BEST_PRACTICES name Preflight 0.3.1 (the release the templates pin), and the --no-input help no longer names Sourdough 0.1. ### 0.2.0 (2026-11-08) [#](https://sourdough.apps.wayne.edu/docs/changelog.html#0-2-0-2026-11-08) #### Added [#](https://sourdough.apps.wayne.edu/docs/changelog.html#added-3) - Added: `tests/PreflightPinTest.php`: one Preflight version across every shape's pipeline and Sourdough's own GitLab pipeline; no component `image` input with a registry prefix; every Docker Hub component in a shape takes the shape's `IMAGE_PREFIX`. BEST_PRACTICES 4.3 is `Enforced` by it. `tests/TemplateCiCacheTest.php` now checks the `${IMAGE_PREFIX}/` rule on the app's own jobs only. - Added: a third agent recipe on the front page, for the Laravel shapes (Blade, Blade with Vue islands and Inertia/Vue), and the stale "join the rack" line is gone. - Added: every bake saves its plan in the app as `.sourdough/plan.yaml` (ADR-0014, decision 3), after the bake succeeds: a `--plan` bake saves that plan with the name the app got, a bake from flags saves the shape, the name and all four parts. The file is not in the manifest, so it is neither managed nor seeded: `sourdough feed` and `sourdough manifest --check` never read, rewrite or flag it, and feed writes none for apps baked before. `--plan` now reads YAML plans (`.yaml` or `.yml`) as well as JSON, through the same schema, so the saved plan bakes the same loaf again. Sourdough requires `symfony/yaml` `^7.4`. `tests/SavedPlanTest.php` and `tests/FeedCommandTest.php` cover it. #### Changed [#](https://sourdough.apps.wayne.edu/docs/changelog.html#changed-5) - Changed: every shape's `.gitlab-ci.yml` pins the Preflight CI components to the 0.3.0 release SHA (`23038dfe767f6ef60e3b2efca1128f53d9acdff7` with `# 0.3.0`, was 0.1.4; Preflight 0.2.0 and later need GitLab 18.7 or later). From Preflight 0.3.0 each Docker Hub component adds the registry prefix itself (`image_prefix`, D-054), so the includes pass `image_prefix: "${IMAGE_PREFIX}"` and drop their `image` inputs, which only carried the prefix in front of the components' own defaults: the components and the app's own jobs follow one proxy rule. Apps already baked take it with `sourdough feed`; a Preflight include an owner added with a prefixed `image` keeps the plain name (docs/upgrading.md). - Changed: Sourdough's own GitLab pipeline pins the Preflight components to the `0.3.0` release tag (was 0.1.4), and their `image` inputs are plain names (the components add the proxy prefix); the jobs Sourdough defines itself keep `${CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX}/`. The GitHub workflow stays on Preflight 0.1.4: GitHub's copy of Preflight has no tag after 0.1.4 yet (D-069). - Changed: the `--docker` setup publishes its ports on 127.0.0.1 only, so the dev server and Vite are not reachable from the network (SOURDOUGH-25). - The front page's deploy layer (`deploy/`) runs Squire's kit 0.6.0 (was 0.5.0): `scripts/release.sh` asks PROCTOR's deploy gate for a go or no-go on each release (a report, not a stop, unless `SQUIRE_PROCTOR=enforce`), and `.env.squire.example` lists the new setting. The layer's pins move to HELMET `^0.4` (locked 0.4.0) and PROCTOR `^0.7` (locked 0.7.0). - Docs: the Docker commands in the README and docs mount the shared `stack-composer-cache` volume, so Composer downloads are cached between runs. - Changed: apps start on the Squire 0.6.0 deploy kit (was 0.4.0). The copy in `templates/squire/` comes from Squire 0.6.0, and the dev dependency is `^0.6`. - Changed: a baked app's `scripts/release.sh` asks PROCTOR's deploy gate (`proctor gate`) for a go or no-go instead of running `proctor check`, right after `composer audit` and before the frontend build and the migrations, so `SQUIRE_PROCTOR=enforce` stops a no-go before it touches the database. The verdict goes to `storage/squire/proctor-gate.json` (new setting `SQUIRE_PROCTOR_RECORD_DIR`, listed in `.env.squire.example`; the folder ignores itself) and becomes the baseline the next release is ratcheted against, so a failure that is already live is held and only a new one blocks. With a PROCTOR that has no `gate` the step warns and runs `proctor check` as before. - Changed: new apps in every shape require HELMET `^0.4` (was `^0.3`), SESAME `^0.5` (was `^0.4`) and PROCTOR `^0.7` (was `^0.6`); CREED stays `^0.1` (0.1.7 today). PROCTOR 0.7 brings `proctor gate`, which the kit's release script now asks; HELMET 0.4's request metrics stay off until `HELMET_METRICS_STORAGE` is set. `tests/StackPinsTest.php` checks all three in every template composer file. - Changed: the Laravel shapes' `config/sesame.php` names SESAME 0.5's `cas.require_pending_login` (env `SESAME_CAS_REQUIRE_PENDING_LOGIN`, default on), with a note to leave it on; the Laravel adapter already hands the cas driver the session. - Changed: every shape's `.gitlab-ci.yml` caches its downloads. Docker Hub images in the app's own jobs are `${IMAGE_PREFIX}/`, digest pins kept, and the Preflight components get the same prefix as their `image_prefix` input; `IMAGE_PREFIX` defaults to `docker.io`, and a `workflow:` rule sets it to the group's GitLab Dependency Proxy when the GitLab has one. Composer and npm installs extend `.composer-cache` (keyed on `composer.lock`) and `.npm-cache` (keyed on `package-lock.json` and `package.json`). A project variable `IMAGE_PREFIX=docker.io` skips the proxy. New `tests/TemplateCiCacheTest.php` keeps every shape that way. Apps already baked take it with `sourdough feed`. #### Fixed [#](https://sourdough.apps.wayne.edu/docs/changelog.html#fixed-3) - Fixed: the pipeline's PROCTOR jobs no longer pass `--policy`, which PROCTOR 0.7 refuses in CI; PROCTOR checks against the CREED policy it bundles. - Fixed: BEST_PRACTICES.md's "Keeping generated apps current" tags match the code, each naming the file that holds it: 3.1 (record where the app came from) and 3.3 (merge, not overwrite) are `Enforced` by the manifest and `sourdough feed`, 3.2 (a check that fails CI) is `Partly enforced` (`feed --dry-run` and `manifest --check` exist; no template runs them in CI yet), 3.4 (tags and migration notes) is `Documented` in the release steps, and 3.5 (compatibility CI) is `Checked` by the smoke gate, which still only warns. They all said `Not yet` or `Documented`. 4.3 keeps `Partly enforced` and now names its templates and test. - Fixed: BEST_PRACTICES.md describes Sourdough as it is (0.1.7, all five shapes bake, `manifest` and `feed` ship) instead of a tool with no code on main, and practice 6.1 (wire the stack in by default) is `Enforced` by the generator tests in every shape; it said only the raw shape generated. - Fixed: the local parity fallback image builds when the host's uid or gid already belongs to an account in the image (a host gid of 1001, like GitHub's runners, collided with the container user's default). - Fixed: `scripts/parity.ps1` builds the fallback image with the host's uid and gid (1000 on Windows, the current user's ids on Linux and macOS) instead of a fixed 1000, so the app container starts when the bind-mounted source belongs to another user. - Fixed: the raw shapes (`--raw`, `--raw --vue`) sign in with CAS in production. `public/index.php` called `DriverFactory::make($config)` with no HTTP client, so with `APP_ENV=production` the cas driver refused to boot; it now passes a Guzzle client (10 second timeout, no redirects, TLS verification on), a `nyholm/psr7` request factory and the app's `NativeSession`, which SESAME 0.5's cas driver needs for its pending-login marker (a ticket is accepted only for a sign-in this browser started). The raw template requires `guzzlehttp/guzzle` `^7.9 || ^8.0` and `nyholm/psr7` `^1.8`. ### 0.1.7 (2026-11-07) [#](https://sourdough.apps.wayne.edu/docs/changelog.html#0-1-7-2026-11-07) #### Added [#](https://sourdough.apps.wayne.edu/docs/changelog.html#added-4) - Added: `sourdough feed` brings template updates into an app made with `sourdough new`, without clobbering what the app changed (ADR-0014, decision 4). It bakes the app's shape again with the answers in its manifest and goes file by file: files the template did not change are left alone, untouched managed files take the new version, files both sides changed are three-way merged by `git merge-file`, same-line changes get git's conflict markers (`<<<<<<< app` ... `>>>>>>> sourdough `) and never a silent overwrite, new template files are added, dropped ones are removed only when untouched, binary files are never merged (the template's copy lands as `.sourdough-new`), and seeded files are never touched. The base for a merge is found by its manifest hash, in `.sourdough/base/` (the template's version of each changed managed file, kept by the previous feed) or anywhere in the app's git history; with no base, both versions are marked. Feed then moves the manifest to the new base. It runs only on a clean git tree, refuses while the last feed's markers are unresolved, and refuses a manifest from a newer Sourdough. `--dry-run` prints the plan and writes nothing (exit `0` fresh, `1` feeding would change files, so it works as a CI gate), `--json` prints the plan for machines; a real feed exits `0` fed cleanly, `1` fed with conflicts, `2` tool error. It needs git and nothing else. Every shape is covered by `tests/FeedCommandTest.php`, and the smoke gate now checks that a fresh bake of each shape has nothing to feed. - Added: the proof harness, `scripts/proof.sh` (Linux, macOS) and `scripts/proof.ps1` (Windows), and the Proof page (`docs/reference/proof.md`) with its dated Last run table. In Docker, one after another, it runs the smoke gate on all five shapes and on every Laravel shape with `--sail` and with `--docker` (eleven runs), and feeds a bake of the last release (read from this changelog) forward in each. It writes `proof-out/last-run.md`, a summary and every step log, and exits `1` when any run fails. A GitLab `proof` job runs it by hand or on a schedule that sets `SOURDOUGH_PROOF` to `1`, never on a push, and keeps the results as an artifact. `tests/ProofHarnessTest.php` keeps the two scripts, the gate, the CI job and the table listing the same runs. - Added: the smoke gate checks more of every loaf. Right after the bake, `sourdough manifest --check` must be clean. Every shape runs its own suite as its own step (the count goes in the proof table) and `composer proctor`. The Laravel shapes now boot too, on Laravel's own router: `/` must answer with the shape's home page (the Blade page, the built Vue islands, or the Inertia `Home` page), `/dashboard` after SESAME's fake sign-in, `/nope` 404 and `/up` 200; the raw shape's `/` must carry its home page in WayneUI's shell. A second argument, `--sail` or `--docker`, proves a Laravel shape's oven (the scaffold's files, install, suite, PROCTOR), and `SMOKE_FEED_FROM=` bakes that release from Packagist and feeds it forward. `scripts/smoke-shape.ps1` takes `-Oven` and `-FeedFrom` to match. - Added: the Laravel shapes ship skeleton feature tests (`tests/Feature/SkeletonTest.php`, Pest, next to the starter's example tests): `/up` answers 200, the home page answers 200 for a guest (the Blade page, the built Vue island, or the Inertia `Home` component), a guest at `/dashboard` goes to the sign-in flow, the dashboard renders for a signed-in user after SESAME's fake sign-in (with the islands view's `data-vue-island="counter"` island and the Inertia `Dashboard` component checked too), a missing page answers 404, and `UserResolver::refreshUser()` turns a stored user array back into the `User` by username, or `null` when the username no longer exists. Each baked Laravel suite grows from two tests to nine, and the proof table quotes the new counts. #### Changed [#](https://sourdough.apps.wayne.edu/docs/changelog.html#changed-6) - Changed: the front page's deploy layer (`deploy/`) runs Squire's kit 0.5.0 (was 0.4.0): `.squire/base-fallback.Dockerfile` and `scripts/parity.ps1` take the new templates, so `squire init --check` passes. `site/assets/stack-env.js` takes the stack's one copy, with bindingless catch blocks. - Changed: The canonical repository is git.wayne.edu (ADR-0021); docs, links and package metadata no longer point at the archived nougat copy. - Changed: the Inertia shape bakes on Inertia 3: `inertiajs/inertia-laravel` `^3.0` and `@inertiajs/vue3` `^3.0` (PHP 8.2+, Laravel 11+, ESM only, no bundled Axios). The root view marks its title `data-inertia` instead of the bare `inertia` attribute, and Inertia now hands the first page to Vue in a `