# ADVISOR: everything in one file
> ADVISOR is an MCP server for the Wayne State app stack. Your coding agent asks it about our standards, supported versions, docs and checks, and it answers read-only from the stack's own files.
The README and the Markdown twin of every page, joined. The index is https://advisor.apps.wayne.edu/llms.txt. Written by Squire's agent-ready kit; do not edit.
---
## README
Source: https://github.com/waynestate/advisor/blob/HEAD/README.md
## ADVISOR
Front page: [`site/index.html`](https://github.com/waynestate/advisor/blob/HEAD/site/index.html), a static field map of the stack (open it in a browser).
On Citadel it is served by the raw-PHP deploy layer in [`deploy/`](https://github.com/waynestate/advisor/blob/HEAD/deploy/): a Squire kit whose front controller serves `site/` behind HELMET's security headers. For local development, keep serving `site/` directly.
Checks: `composer ci` (the same command runs on GitLab and GitHub).
Documentation: the full docs live at [`site/docs/index.html`](https://github.com/waynestate/advisor/blob/HEAD/site/docs/index.html), built from `docs/` by the shared docs builder (`composer docs`). The docs wear the front page's look through the builder's `theme` key in `docs/docs.json`: [`docs/_header.html`](https://github.com/waynestate/advisor/blob/HEAD/docs/_header.html) is the sheet head every docs page gets (keep its links in step with the front page's), and [`docs/theme/advisor.css`](https://github.com/waynestate/advisor/blob/HEAD/docs/theme/advisor.css) holds the paper, Fraunces titles, code ground, callouts and the derived dark mode; the build copies it to `site/docs/theme/`. Edit those two files, never `site/assets/docs.css` or `docs.js` (Squire's kit), then run `composer docs`. The back of the map, now with the same legend as the front.
### Where the code lives
The canonical repository is [enterprise-apps/advisor](https://git.wayne.edu/enterprise-apps/advisor) on git.wayne.edu: clone it over SSH as `git@git.wayne.edu:enterprise-apps/advisor.git`, or over HTTPS as `https://git.wayne.edu/enterprise-apps/advisor.git`. Open issues and merge requests there; tags are made there, by the maintainer, with an approver. CI runs on git.wayne.edu, on its instance runner.
GitHub ([waynestate/advisor](https://github.com/waynestate/advisor)) is a read-only push mirror of it: nobody pushes to it, and Packagist reads from it.
An advisor with office hours in two buildings is just hard to find. Ours keeps one office: git.wayne.edu.
> Every WSU student has an advisor. Now every WSU app does too, and this one answers email.
ADVISOR is an MCP server for the Wayne State application stack, a bit like Laravel Boost but for WSU. It orients a
developer who is new to the stack and gives their coding agent nine read-only tools into it: the CREED standards and
policy, PROCTOR results, the upgrade path, the WayneUI markup contract and migration guide, SESAME and HELMET
guidance, and the parts list.
Ask it "which PHP can I build on?" and it answers from the policy file, with the date and the source, instead of from
whatever the model remembers.
It is read-only. It cannot write a file, run a shell command, or call out to the network. The two things it
can start are the app's own `vendor/bin/proctor` and Booster's read-only `plan`, both with a fixed argument shape.
### Where it sits in WELD
The stack is the Wayne State application stack. WELD, Wired, Everything, Linked, Deployed, is its Laravel starter app.
You can add ADVISOR to a WELD app or to any other Wayne State PHP app, and in either case it is the part of the stack
that talks to your coding agent.
| Part | What it is |
|---|---|
| **WayneUI** | interface (project 0) |
| **CREED** | version policy and written standards |
| **PROCTOR** | checks an app |
| **SESAME** | sign-in inside the app |
| **HELMET** | runtime baseline |
| **Sourdough** | starter |
| **Preflight** | CI components |
| **Pinstripe** | coding standard |
| **Booster** | upgrades |
| **Rollcall** | fleet census |
| **Drawbridge** | sign-in gateway |
| **Squire** | deploy kit |
| **Parity** | Citadel on your computer |
| **ADVISOR** | MCP server |
| **WELD** | the Laravel starter app |
ADVISOR serves a bundled copy of what these projects publish (see "Served content"), so it works offline, and it does
not replace Laravel Boost. Boost knows Laravel; ADVISOR knows WSU. Run both.
### Install
PHP 8.3 or newer (8.3, 8.4 and 8.5 are tested). Add it to the app as a dev dependency:
```
composer require --dev waynestate/advisor
```
The command is then `php vendor/bin/advisor`. This works the same on Windows, macOS and Linux, because it is one PHP
command and not a shell script.
ADVISOR is on Packagist: `composer require --dev waynestate/advisor:^0.3`. No extra repository needed.
### Quick start
1. Print the config your MCP client needs, and read it:
```
php vendor/bin/advisor install --client=claude
```
2. Write it into the project when you are happy with it:
```
php vendor/bin/advisor install --client=claude --write
```
3. Open the project in your client and approve the `advisor` server by name when it asks.
The command it registers is always the same fixed string, `php vendor/bin/advisor mcp`, with `ADVISOR_ENABLED=1` in
its environment. Clients: `claude` (`.mcp.json`), `warriorgpt` (`.mcp.json`), `cursor` (`.cursor/mcp.json`), `vscode`
(`.vscode/mcp.json`) and `codex` (TOML, printed only; paste it into `~/.codex/config.toml`).
#### One line for Claude Code
If you would rather type it than generate it, this does the same as `install --client=claude --write`; project scope
keeps it out of your other projects, and the same "do not commit it" warning applies:
```
claude mcp add --scope project advisor -e ADVISOR_ENABLED=1 -- php vendor/bin/advisor mcp
```
#### No PHP on your PATH? Use Docker
If PHP is not on your PATH, point the client at Docker instead. Run it from the project root, the folder that holds
`vendor/`, with a hand-written `.mcp.json` like this:
```json
{
"mcpServers": {
"advisor": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"--network",
"none",
"-v",
".:/app:ro",
"-w",
"/app",
"-e",
"ADVISOR_ENABLED=1",
"-e",
"ADVISOR_PROJECT_ROOT=/app",
"-e",
"ADVISOR_GROUPS=stack",
"-e",
"ADVISOR_READ_ONLY=1",
"composer:2.11.1@sha256:8de2184c6de224f4689e8f80ed5f5edaf0030b6b8b7839a22a2bcb6722ac87d0",
"php",
"vendor/bin/advisor",
"mcp"
]
}
}
}
```
The container has no network, and the project is mounted read-only. `ADVISOR_GROUPS=stack` keeps the tools that start
programs (proctor, upgrade_path) off, because those need the app's own PHP. Some clients want an absolute path in
place of `.` for the mount; give them one. Advice comes in; nothing goes out. This file is written by hand, so keep it
out of git like the generated one.
`install` never replaces a different existing `advisor` entry unless you pass `--force`, keeps your other servers, and
warns when the file is not in `.gitignore`. A client config starts a program on whoever opens the project, so do not
commit a generated one; this repository ignores `.mcp.json` for that reason.
Run the client from the folder that holds `vendor/`. If it starts somewhere else, set `ADVISOR_PROJECT_ROOT`.
#### Laravel apps
ADVISOR also ships a Laravel adapter on `laravel/mcp`, auto-discovered by the service provider. With it, the same
server runs as `php artisan mcp:start advisor`, beside Boost. Publish the config if you want it in the app:
```
php artisan vendor:publish --tag=advisor-config
```
Settings come from the same `ADVISOR_*` variables, read through `config/advisor.php`. The same rules apply: off unless
`ADVISOR_ENABLED` is set, and never in production.
Boost's project rules (`.ai/rules`) are for your app's own decisions. Keep CREED's rules out of them: a project rule
adds to CREED and never overrides it, and your agent reads CREED's through `list_stack_rules`. The Laravel guide has
the details.
### What it offers
Nine tools, all read-only. Each one says where its answer came from:
| Tool | Does |
|---|---|
| `list_projects` | The stack's projects, WayneUI first, with built or proposed state, package and version. |
| `get_project_status` | One project: state, package, version, PHP constraint, its floor under today's policy, next step. |
| `read_project_docs` | A project's README, best practices, or (WayneUI only) markup contract and 1.x to 2.x migration guide, paged. |
| `policy_lookup` | Support state for a runtime or tool (and an optional version) from CREED, as of today, worked out by CREED's own reader (`waynestate/creed`), the one PROCTOR carries a copy of. A version older than every one the policy lists is answered as end of life, with a note. |
| `list_stack_rules` | CREED handbook rules, each with its file and line, filtered by app permutation, chapter and a word query (`query: "session cookie"`). |
| `owner_of` | Answers "which project owns X?" from the bundled ownership table, built from the stack's one-owner-per-rule decision first: the owner, its role, the projects around it, and the decision each answer comes from. Pass a topic or the whole question ("who owns composer audit"). |
| `playbook_lookup` | A shared value by key, or every key: an environment variable of the same name wins, then Playbook; secret-looking keys are refused. |
| `run_proctor_check` | Runs the app's own `vendor/bin/proctor check` against the bundled policy and returns the findings. |
| `upgrade_path` | Plans the app's PHP and/or Laravel upgrade, one supported hop at a time, via Booster's read-only `plan`. Inputs: from_php (the version the app runs today, when the project names none), to_php, to_laravel. |
The groups split by what they may start: `stack` never starts a program, `proctor` starts the app's own
`vendor/bin/proctor`, and `booster` starts Booster's read-only `plan` (never `run`). Set `ADVISOR_GROUPS=stack`
when you want ADVISOR as pure reference material.
| Resource | Serves |
|---|---|
| `advisor://policy` | CREED's policy file. |
| `advisor://creed/` | One per handbook chapter. |
| `advisor://guide/` | Hand-written guides; the first is "Connect to Oracle on Citadel". |
Prompts: `orient_me` and `plan_upgrade`.
Here is what that looks like when you ask. Each numbered control point is one of the tools above, with the arguments the
front page's own route table sends:
Everything ADVISOR returns is labeled as reference data. PROCTOR in CI, not ADVISOR, decides pass or fail.
### Configuration
ADVISOR reads the process environment only, never a file. The placeholders are in `.env.example`.
| Variable | Default | Meaning |
|---|---|---|
| `ADVISOR_ENABLED` | off | Must be `1` or `true`, or the server refuses to start. `advisor install` sets it in the client config. |
| `ADVISOR_ENV` | `APP_ENV`, then `local` | `production` or `prod` always refuses to start. |
| `ADVISOR_PROJECT_ROOT` | the working directory | The folder `run_proctor_check` may look inside. Paths outside it are refused. |
| `ADVISOR_READ_ONLY` | on | Set to `0` or `false` to allow tools that write. None exist yet. Read-only wins over `ADVISOR_GROUPS`. |
| `ADVISOR_GROUPS` | all | Comma list of tool groups to offer (`stack`, `proctor`, `booster`). See below for what each group may start. |
| `ADVISOR_PROCTOR_TIMEOUT` | `120` | Seconds before a PROCTOR run is stopped (1 to 900). |
| `ADVISOR_BOOSTER_TIMEOUT` | `60` | Seconds before a Booster plan is stopped (1 to 900). A plan is local and fast, so the default is shorter than a PROCTOR run. |
| `ADVISOR_BOOSTER_BIN` | none | Where `upgrade_path` finds Booster when the app has no `vendor/bin/booster` of its own: the path to booster's `bin/booster` (or a `booster.phar`). The app's own `vendor/bin/booster` always wins. |
| `ADVISOR_MAX_CHARS` | `20000` | Largest piece of text one doc call returns (1000 to 45000). |
| `ADVISOR_AUDIT_LOG` | off | A file for a one-line-per-call audit log: time, tool, a hash of the arguments, outcome, duration. Arguments are hashed, never written. |
| `ADVISOR_LOG_LEVEL` | `warning` | Log level on stderr (`debug` to `emergency`). |
| `ADVISOR_STACK_DIR` | none | Folder holding the sibling stack repos; used only by `content:generate`. |
| `ADVISOR_PRIVATE_DENYLIST` | none | A file (kept outside the repo) with private strings to strip from the bundle; used by `content:generate` and the public-posture test. See "Releasing". |
| `ADVISOR_MODULES_FILE` | none | An extra module manifest (see "Modules"). |
A bad value stops the server with a message on stderr. It does not guess.
### Commands
```
php vendor/bin/advisor mcp # serve over stdio (your client starts this)
php vendor/bin/advisor install [--client=claude] [--write] [--force] [--path=.]
php vendor/bin/advisor content:verify # check the bundled content against its manifest
php vendor/bin/advisor content:generate [--sources=
] [--check]
php vendor/bin/advisor stack-parts [--write=] [--check=]
php vendor/bin/advisor doctor [--json] # check the install when the server does not show up
```
Stdout carries only protocol messages. Logs, warnings and stray output go to stderr, so a client never sees garbage.
### When it doesn't show up
You added the config, opened the project, and the `advisor` server is not in the list. Run:
```
php vendor/bin/advisor doctor
```
It checks the six things that keep a server from appearing, in plain words, and changes nothing:
- **php**: the PHP on your machine satisfies ADVISOR's own `composer.json` (8.3 or newer).
- **php-path**: which `php` your client will start. Clients start `php` by name, so they get the first one on the PATH. A warning when there is none, or when it is not the PHP running doctor (then run doctor with that one too). Doctor only looks; it never runs what it finds.
- **content**: the bundled `data/` still matches its manifest.
- **client:claude**, **client:warriorgpt**, **client:cursor**, **client:vscode**: each client's MCP config: is the file there, does it have the `advisor` entry, and is the script it points at in the project? A missing file is a warning, not a failure; you only need the one client you use.
- **mcp**: the server starts. Doctor boots it in-process and asks for its tools.
- **stdio**: the real thing. Doctor starts `php vendor/bin/advisor mcp` as a child process, the way your client does, and asks it to initialize, list its tools and answer one `policy_lookup` call. Every stdout line must be protocol, and the child must exit 0 when its input closes. The pass line names your OS and PHP version, so on Windows it is the proof that stdio works there.
A `fail` is something to fix; a `warn` is something you may not care about. The exit code is `0` when nothing failed and `1` when something did; `--json` prints the findings as JSON.
The advisor will see you now.
### Served content
The handbook, policy, project docs, the WayneUI markup contract and WayneUI's 1.x to 2.x migration guide in `data/`
are generated from the sibling stack repositories by `content:generate` and verified at start-up against
`data/manifest.json` (a SHA-256 for every file). If a file does not match, the server refuses to start rather than
serve it. Files are cleaned on the way in: line endings are normalized and invisible characters (the TAG block,
zero-width and bidirectional controls) are stripped. Each project entry also carries its version when the project
publishes one (composer.json, else package.json, else the newest CHANGELOG heading).
Image boilerplate is trimmed from the project docs, on the way in and again when `read_project_docs` serves them: centred hero, badge and cast blocks, lone images whose target is relative or a GIF (linked or not), and rows of nothing but badges. Prose, tables and code blocks are left alone, and the bundled file itself is never rewritten at read time, so its manifest hash still holds.
Beside the generated docs, hand-written guides are kept by hand in `generator/guides/` (one Markdown file per slug),
the same way the ownership table is kept. Each is bundled into `data/guides/` and served as `advisor://guide/`;
the first is "Connect to Oracle on Citadel".
To refresh it, with the stack repos checked out side by side:
```
php vendor/bin/advisor content:generate --sources=/path/to/stack
php vendor/bin/advisor content:generate --sources=/path/to/stack --check # exits 1 on drift
```
CI cannot see the sibling repositories, so `composer ci` runs `content:verify`, which needs none of them.
### Releasing
ADVISOR is a public repository, so the bundle must not carry internal names. The public-posture test always checks
generic shapes (ADR numbers, open-question numbers, design-doc paths, the coordination repo). Private strings
(hostnames, people) are loaded from the file named by `ADVISOR_PRIVATE_DENYLIST` and checked only when the file is
present.
To release:
1. Set `ADVISOR_PRIVATE_DENYLIST` to a file kept outside the repository (one literal or `regex:` pattern per line,
`#` comments).
2. In GitLab CI, the file comes from a masked file-type CI variable.
3. Regenerate the bundle with the file present: `php vendor/bin/advisor content:generate --sources=/path/to/stack`.
4. Run `composer ci` to confirm the public-posture test passes.
The file is never committed. The bundle is regenerated with the file present before every release.
### Modules
Each stack project can ship its own ADVISOR tools. Modules load only from a manifest (`modules.json`), only from
the `Waynestate\` namespace, and only if they implement the `Module` interface. Nothing scans a folder.
Squire ships the first one: list `Waynestate\Squire\Advisor\SquireModule` in a manifest of your own, point
`ADVISOR_MODULES_FILE` at it, and your agent gains `squire_doctor` and `squire_drift`, both read-only.
### Running the checks
Maintainers: how to build, test and release this project, and where its data comes from, is in [MAINTAINING.md](https://github.com/waynestate/advisor/blob/HEAD/MAINTAINING.md).
```
composer ci
```
That runs `composer validate --strict`, `content:verify`, `stack-parts --check=README.md`, PHPUnit, Pint, the
agent-ready check (`site/index.md`, `llms.txt`, `llms-full.txt`), PHPStan (level 8, Pinstripe's raw preset, included
from `vendor/waynestate/pinstripe`), `composer audit` and the docs site check (`site/docs/` is current and every link
resolves). No PHP on your machine? Use Docker:
```
docker run --rm -v "${PWD}:/app" -v stack-composer-cache:/tmp/cache -w /app composer:2.11.1@sha256:8de2184c6de224f4689e8f80ed5f5edaf0030b6b8b7839a22a2bcb6722ac87d0 sh -c "composer install --no-interaction && composer ci"
```
Tests drive the real SDK server in-process with a small MCP client, snapshot `tools/list`, and start
`bin/advisor mcp` as a subprocess to prove stdout stays clean. To accept an intended change to the tool list, run
`ADVISOR_UPDATE_SNAPSHOTS=1 vendor/bin/phpunit`, then review and commit the diff.
### Proof run
The proof run is dev tooling, not part of the served product. It walks a corpus of app folders through the real
`bin/advisor mcp` server over stdio and writes one JSONL line per app, whose outcome is `pass`, `flagged`,
`tool-error` or `not-applicable`. Each unit is copied into a scratch folder before the server sees it; `.env`,
`auth.json` and `.git` are left behind (`.env.example` comes along), and the copy is removed when the unit is judged.
The log holds no paths and no unit directory names.
```
php bin/proof.php --units=FILE --corpus=DIR --work=DIR --out=FILE --proctor-bin=FILE --booster-bin=FILE
```
### Accessibility check
The `a11y` job in GitLab CI is Preflight's `a11y` component: axe-core 4.14.0 over `site/index.html` and
`site/docs/**/*.html`, WCAG tags only, in light and dark color schemes at 320 and 1280 px widths, plus the
reflow check for WCAG 1.4.10.
ADVISOR's own checker, `scripts/a11y/check.mjs`, runs too, as the `a11y-extra` job. It loads the same pages in light and dark themes at phone (390 px) and desktop (1440 px) width, plus one reduced-motion pass, and also requires one ``, a `lang` attribute, a non-empty title, and no horizontal scroll at phone width. Run it from the repo root (works in PowerShell):
```
docker run --rm -v "${PWD}:/app" -e npm_config_cache=/npm-cache -v stack-npm-cache:/npm-cache -w /app/scripts/a11y mcr.microsoft.com/playwright:v1.65.0-noble sh -c "npm install --no-audit --no-fund && node check.mjs"
```
It also runs as the `a11y-extra` job in GitLab CI.
### Safety, in short
- Off unless enabled; refuses production; refuses to start on a bad setting or a content file that fails its hash.
- Read-only by default; no tool takes a command, a URL or a free path.
- Every result is cleaned of invisible characters and labeled as data; secrets in PROCTOR output are redacted.
- `run_proctor_check` runs one fixed program with an argument array and an allowlisted environment, never a shell.
- `upgrade_path` runs Booster's read-only `plan` the same way: one fixed program, an argument array, an allowlisted command, never a shell. It plans; it never runs a hop.
- No network calls, and no model calls, from ADVISOR itself.
- The threat model, each threat mapped to the rules that answer it, is in BEST_PRACTICES.md, "Threat model".
See `BEST_PRACTICES.md`, and `OPEN_QUESTIONS.md` for what is decided, assumed and not yet built.
### Why "ADVISOR"
Because registration is open, the advisor will see you now, and unlike the real one it knows which PHP version you are
allowed to be on. A little Creed energy too: it will tell you who you are, in `composer.json`, whether you like it or not.
### License
MIT. Copyright Wayne State University.
---
Source: https://advisor.apps.wayne.edu/
The Wayne State app stack, surveyed
## ADVISOR
ADVISOR stands for Answers, Directions, Versions, Integrations, Standards, Onboarding and Resources.
What applies, and what's next.
An MCP server for the stack, a bit like Laravel Boost but for Wayne State. Your coding agent connects to it and gets nine read-only tools: CREED's rules and support dates, each project's docs, PROCTOR and Booster's upgrade plan. Ask it “which PHP can I build on?” and it answers from CREED's policy file, with the date and the source, instead of from whatever the model remembers.
`$ composer require --dev waynestate/advisor`
PHP 8.3 or newer. ADVISOR is on Packagist: `composer require --dev waynestate/advisor:^0.3`.
**Works alongside [WELD](https://weld.apps.wayne.edu/).** You can add ADVISOR to a WELD app or to any other Wayne State PHP app.
[Ask the map](https://advisor.apps.wayne.edu/#ask) [Get directions](https://advisor.apps.wayne.edu/#directions)
The ADVISOR mark: a speech bubble holding a gold compass needle.
The magic trick, minus the magic
### Ask the map
Type a question you'd ask your coding agent. The map draws the route ADVISOR takes to answer it: which tools it calls, and which project the answer comes from.
An illustration of how your agent uses ADVISOR's tools. This page calls nothing; the real server runs on your machine, beside your app.
Control descriptions
#### Route card
“Which PHP can I build on?”
1. **Start:** your app, where your coding agent is working
2. **ADVISOR** takes the question
3. Tool `policy_lookup` with `component: php`
4. **Finish:** CREED, `policy.json`
Answer, as reference data
PHP 8.4 and 8.5 are in active support, 8.2 and 8.3 get security fixes only, and 8.1 is past its end of life.
Source: CREED `policy.json`, worked out for today.
**Field book What your agent gets back**
Climb: 0 m. Everything on this route is read-only.
Read this before you set off
### Legend
ADVISOR has nine tools. These six are the ones you'll use most; the others are `owner_of`, `playbook_lookup` and `upgrade_path`. Every tool is read-only, and every answer names its source.
#### Tools
- **`list_projects`**: The stack's projects, WayneUI first, each marked built or proposed.
- **`get_project_status`**: One project: its state, package, PHP constraint, its floor under today's policy, and its next step.
- **`read_project_docs`**: A project's README or best practices, paged. For WayneUI, its markup contract too.
- **`policy_lookup`**: Whether a PHP, Laravel, Node, MySQL, Vue or Inertia version is supported today, from CREED. For Composer, the minimum version.
- **`list_stack_rules`**: CREED handbook rules with their file and line, filtered by your app's shape, by chapter, or by a few words such as `session cookie`.
- **`run_proctor_check`**: Runs your app's own `vendor/bin/proctor check` against the bundled policy and returns the findings.
#### Prompts
- `orient_me` a first walk round the stack, ending in three next steps
- `plan_upgrade` plans the next upgrade hop from the policy, PROCTOR and Booster's plan
#### Resources
- `advisor://policy` CREED's policy file
- `advisor://creed/` one per handbook chapter
- `advisor://guide/` hand-written guides; first: Connect to Oracle on Citadel
#### Map symbols
- your app
- a tool call
- where the answer lives
**Run it next to Laravel Boost.** Boost knows Laravel and ADVISOR knows Wayne State, so they don't overlap. In a Laravel app the same server also runs as `php artisan mcp:start advisor`.
**Add a project's own tools.** Squire ships an ADVISOR module. List `Waynestate\Squire\Advisor\SquireModule` in a `modules.json` manifest, point `ADVISOR_MODULES_FILE` at it, and your agent gains `squire_doctor` and `squire_drift`, both read-only. The loader takes only what a manifest lists, so nothing sneaks onto the map.
Turn-by-turn
### Directions
Three steps and a check-up, the same on Windows, macOS and Linux, because ADVISOR is one PHP command rather than a shell script.
1. ### Add it to your app
Add it as a dev dependency. It won't start in production anyway.
```
composer require --dev waynestate/advisor
```
2. ### Print the client config, and read it
This writes nothing yet. Use your client's name: `claude`, `warriorgpt`, `cursor` or `vscode`. For `codex` it prints TOML to paste into `~/.codex/config.toml`.
```
php vendor/bin/advisor install --client=claude
```
```
{"mcpServers":{"advisor":{"command":"php","args":["vendor/bin/advisor","mcp"],"env":{"ADVISOR_ENABLED":"1"}}}}
```
3. ### Write it, then approve it by name
Then open the project in your client and approve the `advisor` server when it asks. Don't commit the file it writes. It starts a program for anyone who opens the project, so `install` warns you if it isn't in `.gitignore`.
```
php vendor/bin/advisor install --client=claude --write
```
4. ### Get a check-up
Doctor starts the server the way your client will, as a child process over stdio, and says in plain words what passed. A `warn` you may not care about; a `fail` is something to fix. On Windows, its `stdio` line is the proof that the one command works there too.
```
php vendor/bin/advisor doctor
```
```
pass php: PHP 8.4.14 satisfies ^8.3
pass php-path: Clients will start /usr/bin/php, the PHP running this check.
pass content: data/ matches its manifest.
pass client:claude: claude is configured to start ADVISOR.
warn client:cursor: .cursor/mcp.json is not present, so cursor will not start ADVISOR.
pass mcp: The server starts and offers 9 tools.
pass stdio: `php bin/advisor mcp` runs as a child process on Linux (PHP 8.4.14): clean stdout, 9 tools, policy_lookup answered, exit 0 (412 ms).
```
Where `install --write` puts it
- claude`.mcp.json`
- cursor`.cursor/mcp.json`
- vscode`.vscode/mcp.json`
- codex`printed only (TOML)`
- warriorgpt`.mcp.json`
Every one starts the same fixed command, `php vendor/bin/advisor mcp`. Run your client from the folder that holds `vendor/`, or set `ADVISOR_PROJECT_ROOT`.
#### Other commands
```
# serve over stdio (your client starts this)
php vendor/bin/advisor mcp
# check the bundled content against its manifest
php vendor/bin/advisor content:verify
# when the server doesn't show up in your client
php vendor/bin/advisor doctor
# every check, in the advisor repo itself
composer ci
```
#### Laravel apps
The Laravel adapter runs on `laravel/mcp` and is auto-discovered. If you want the settings in your app, publish the config:
```
php artisan vendor:publish --tag=advisor-config
```
Read out at the start line
### Briefings for your agent
Your coding agent can set ADVISOR up for you. Copy a briefing, or open it directly in OpenCode, Claude Code, Codex or ChatGPT. Each one lists the steps and the limits, and tells the agent to ask you before it guesses.
#### Get started with ADVISOR
The agent installs ADVISOR, shows you the client config before writing it, and asks its first question once it's connected.
A prompt for your coding agent. Copy it as it stands:
```text
You are a coding agent helping a Wayne State University developer connect ADVISOR to the app in this folder. ADVISOR is the MCP server of WELD, the Wayne State application stack: read-only tools that answer from CREED's policy and the stack's own docs, with the date and the source, instead of from memory.
Read first:
- https://advisor.apps.wayne.edu/llms.txt, the index of ADVISOR's pages, each one as Markdown. Work from them, not from memory.
- This app's composer.json and its .gitignore.
- Which coding agent you are. ADVISOR writes the config for claude, warriorgpt, cursor and vscode, and prints TOML for codex. For any other client (OpenCode, for one), print the claude config, translate it by hand, and show me before you write it.
Task:
1. Add ADVISOR as a dev dependency with `composer require --dev waynestate/advisor` (PHP 8.3 or newer).
2. Print the client config and show it to me: `php vendor/bin/advisor install --client=claude`, with your client's name in place of claude. Write nothing yet.
3. When I say yes, run it again with --write, and check that the file it wrote is in .gitignore.
4. If the server does not show up, run `php vendor/bin/advisor doctor` and tell me what it found.
5. Once it is connected, call list_projects, then policy_lookup for PHP, and tell me which PHP this app can build on today, with the date and the source.
Constraints:
- ADVISOR is a dev dependency and refuses to run in production. Never move it into require, and never set ADVISOR_ENV to production.
- Never commit a generated client config: it starts a program on whoever opens the project.
- The command it registers is always php vendor/bin/advisor mcp. Do not change it.
- Give separate commands for Windows (PowerShell), macOS and Linux wherever they differ.
- Ask me before you guess, and before you pass --force.
Output: the config you propose, the commands you ran, the doctor result if you ran it, then your questions.
```
#### Or take the Laravel route
#### ADVISOR in a Laravel app, beside Boost
Uses the laravel/mcp adapter and adds ADVISOR to your client next to Boost, without touching Boost's entry.
A prompt for your coding agent. Copy it as it stands:
```text
You are a coding agent adding ADVISOR to a Laravel app at Wayne State University, beside Laravel Boost. ADVISOR is the MCP server of WELD, the Wayne State application stack. Boost knows Laravel; ADVISOR knows WSU. Run both.
Read first:
- https://advisor.apps.wayne.edu/llms.txt, then the README it links: Install, Quick start, Laravel apps and Configuration.
- composer.json, composer.lock, config/, .gitignore, .env.example, and any MCP client config already in the project (Boost writes one).
Task:
1. Add ADVISOR with `composer require --dev waynestate/advisor`. Its service provider is auto-discovered, and its Laravel adapter runs on laravel/mcp.
2. If I want the settings in the app, publish them with `php artisan vendor:publish --tag=advisor-config`. They land in config/advisor.php and read the same ADVISOR_* variables.
3. Choose with me how the client starts it: `php vendor/bin/advisor install` for my client, or the Laravel way, `php artisan mcp:start advisor`. Either way it needs ADVISOR_ENABLED=1 in its environment.
4. Add it beside Boost's entry without touching Boost's. Then ask ADVISOR policy_lookup for PHP and Laravel, and list_stack_rules with the permutation that fits this app (laravel-blade, laravel-blade-vue or laravel-inertia-vue).
Constraints:
- Keep Boost. ADVISOR does not replace it.
- Off unless ADVISOR_ENABLED is set, and never in production: keep it in require-dev.
- Never commit a generated client config, and never pass --force over an entry you did not write.
- Give separate commands for Windows (PowerShell), macOS and Linux wherever they differ.
- Ask me before you guess, and before you change anything Boost owns.
Output: the client config with both servers in it, the commands you ran, the rules list_stack_rules returned, then your questions.
```
Your agent can read this page too. [llms.txt](https://advisor.apps.wayne.edu/llms.txt) lists the pages, [llms-full.txt](https://advisor.apps.wayne.edu/llms-full.txt) has all of them in one file, and this page has a [Markdown twin](https://advisor.apps.wayne.edu/index.md). The buttons only copy text or open the tool you picked. This page sends nothing back to us.
Hatched on the map, for a reason
### Out of bounds
An advisor can tell you what's required. It cannot sit the exam for you, and this one cannot touch your files.
- **Off unless you turn it on.** No `ADVISOR_ENABLED`, no server. `production` always refuses.
- **Read-only.** No tool takes a command, a URL or a free path, and none of them writes a file.
- **No network, no model calls.** It serves a bundled copy of the stack's docs, so it works offline.
- **Verified content.** At start-up, every bundled file is checked against a SHA-256 manifest. If one doesn't match, the server won't start.
- **Answers are data.** Every result is labeled as reference text and cleaned of invisible characters. Pass or fail is PROCTOR's call in CI.
- **Two fixed programs.** `run_proctor_check` starts only your app's own PROCTOR, with an allowlisted environment. `upgrade_path` starts only Booster's read-only `plan`, never `run`. Both get an argument array and a timeout, and neither goes through a shell.
Adjoining sheets
### The neighborhood
ADVISOR answers from a bundled copy of what these projects publish. Here is who lives where.
- [WayneUI](https://wayneui.apps.wayne.edu/)the interface, project 0
- [CREED](https://creed.apps.wayne.edu/)the standards and policy
- [PROCTOR](https://proctor.apps.wayne.edu/)checks an app
- [Preflight](https://preflight.apps.wayne.edu/)shared CI
- [Pinstripe](https://pinstripe.apps.wayne.edu/)the coding standard
- [SESAME](https://sesame.apps.wayne.edu/)sign-in
- [HELMET](https://helmet.apps.wayne.edu/)the runtime baseline
- [Sourdough](https://sourdough.apps.wayne.edu/)starts an app in any of the five shapes
- [WELD](https://weld.apps.wayne.edu/)the Laravel starter app
- ADVISORyou are here
- [Booster](https://booster.apps.wayne.edu/)upgrades, one hop at a time
- [Rollcall](https://rollcall.apps.wayne.edu/)the fleet census
- [Drawbridge](https://drawbridge.apps.wayne.edu/)the sign-in gateway
- [Squire](https://squire.apps.wayne.edu/)the deploy kit
- [Parity](https://parity.apps.wayne.edu/)Citadel on your computer
Here be roadmaps
### Not yet surveyed
The edges of the map. None of these is built yet, so none of them gets a command here.
- Coming soon
### Ask ADVISOR on the web
A chat page. First we need to pick a model and decide what data it may see, and it will need its own accessibility review.
- Coming soon
### Tools that write
Things like starting an app with Sourdough or applying a Booster hop. When they come, they stay off until you set `ADVISOR_READ_ONLY=0`.
- Coming soon
### HTTP transport
stdio first. Remote needs a threat model before it needs a port.
---
Source: https://advisor.apps.wayne.edu/docs/changelog.html
## Changelog [#](https://advisor.apps.wayne.edu/docs/changelog.html#changelog)
All notable changes are listed here. The format follows Keep a Changelog; versions follow Semantic Versioning.
### \[Unreleased\] [#](https://advisor.apps.wayne.edu/docs/changelog.html#unreleased)
#### Added [#](https://advisor.apps.wayne.edu/docs/changelog.html#added)
- Added: `advisor install --runner=docker|php`. A project with a compose file or `parity.json` defaults to `docker` (the MCP client starts ADVISOR inside the app container through `docker compose run`), anything else to `php`; switching runner needs `--force`.
- Added: each file in `content/manifest.json` can carry a `source_commit`, read straight from the source repository's `.git` with no git call. `content:verify` ignores it, and `content:generate` prints one line per project with its short commit.
#### Changed [#](https://advisor.apps.wayne.edu/docs/changelog.html#changed)
- Changed: the ownership table no longer marks TELLER and Rolodex as paused (both released 0.1.0); they stay out of the bundled projects for now.
- Changed: `deploy/` requires PROCTOR `^0.16` (was `^0.15`, which does not allow 0.16), whose `ci-pipelines` check no longer asks for a GitHub workflow (D-069).
- Changed: the dev dependency Pinstripe is `^0.4` (was `^0.3`, which does not allow 0.4.0); 0.4.0 adds two opt-in Rector presets and changes no rule this repo uses.
- Changed: the deploy kit is Squire 0.11.1 (was 0.10.7): the release script fetches PROCTOR when `--no-dev` left it out and installs the frontend from a `yarn.lock`, the HAProxy pin is current, the fallback base follows the app's PHP line, and the parity scripts carry the deprecation note.
- CI pins Preflight 0.9.0 (components and the a11y checker copy).
- CI: the GitHub workflow calls Preflight 0.9.0's reusable workflow (commit fb73b53), the release the GitLab pipeline pins.
- Docs: native Windows and macOS are proven: the first green native-os run (43577372340) is recorded, and open question 1 is answered.
- Docs: the docs home page says the current release is 0.3.1 (it said 0.3.0). Content only.
#### Fixed [#](https://advisor.apps.wayne.edu/docs/changelog.html#fixed)
- Fixed: CI no longer stops `composer ci` after 300 seconds (`config.process-timeout` is 0; the job's own timeout still applies).
### \[0.3.1\] - 2026-11-11 [#](https://advisor.apps.wayne.edu/docs/changelog.html#0-3-1-2026-11-11)
#### Added [#](https://advisor.apps.wayne.edu/docs/changelog.html#added-1)
- Added: every tool publishes a real output schema in `tools/list` (it was an open `{"type": "object"}`): closed, every field typed and described, with the fields always present marked required. A contract test checks each schema's shape and validates every answer the tool tests produce against it (opis/json-schema, already a dependency), the `playbook_lookup` and `run_proctor_check` paths included. Practice 2.8 (structured content with an output schema) is met.
- Added: `advisor doctor` has a `stdio` check: it starts `php bin/advisor mcp` as a child process, the way a client does, asks it to initialize, list its tools and answer one `policy_lookup` call, and passes only when every stdout line is JSON-RPC and the child exits 0. The pass line names the OS and PHP version, so one run on a Windows PHP answers open question 1. A `php-path` check says which `php` on the PATH a client will start, and warns when there is none or it is not the PHP running doctor (open question 10). Doctor still changes nothing and runs nothing from a config file.
- Added: a `native-os` GitHub workflow runs `advisor doctor` (with its new stdio check) and the stdio and doctor tests on Windows and macOS, PHP 8.3 and 8.5, on every push to main and every tag, and writes doctor's output to the run summary. It is separate from `ci.yml`, so the CI badge still means `composer ci`; the full suite stays Linux only.
- Added: `list_stack_rules` takes an optional `query` ("session cookie", or the whole question "what does the stack say about sessions?"): only the rules whose heading or text holds every word come back, matched case-insensitively at word starts, with question words and a plural s ignored. It combines with `permutation` and `chapter`, keeps the handbook order and paging, and says so when nothing matches. Still nine tools.
- Site: Directions gains a fourth turn, "Get a check-up": `php vendor/bin/advisor doctor` and a healthy readout (doctor's own wording, abridged) whose lines ink in one by one, the stdio stamp landing last; with reduced motion the readout is simply there. The intro says "Three steps and a check-up".
- Site: the route card gains a field book, "What your agent gets back": open it and every tool step on the plotted route shows the structured content that call returns, as abridged JSON (long strings cut, lists shortened with "N more"). The readouts are `site/assets/readouts.json`, written by a test from the real tools (PROCTOR's report is a marked sample, since the page cannot run PROCTOR), and the test fails when a call on the map is missing, refused, or comes back in a different shape. Lines ink in one by one; with reduced motion they are simply there.
- Docs: the Laravel guide says how Boost's project rules (`.ai/rules`, filed by Boost's `record-rule` tool) and CREED's rules live together: CREED rules stay in CREED and come through `list_stack_rules`, a project rule adds to them and never overrides one, and CREED wins a disagreement. Best-practices rule 5 points there instead of saying the two never overlap.
- Added: the a11y gate (`scripts/a11y/check.mjs`) opens every disclosure before axe runs, so the field book and anything else behind a click is checked at both widths and in both themes.
#### Fixed [#](https://advisor.apps.wayne.edu/docs/changelog.html#fixed-1)
- Fixed: the front page's routes for Booster, Drawbridge, HELMET, Parity, Preflight, ROLLCALL and Squire called `read_project_docs` without `doc`, which the tool refuses; they now ask for `doc: readme`. The new readouts test found it. The README route map (`docs/readme/route.svg`, redrawn by the readme-art kit from the page's own routes) and its alt text say `doc: readme` too.
#### Changed [#](https://advisor.apps.wayne.edu/docs/changelog.html#changed-1)
- CI pins Preflight 0.8.0.
- Changed: the deploy layer requires PROCTOR ^0.15 (locked 0.15.0, was ^0.12): 0.13 checks the release cooldown against the CREED policy and 0.14 adds `script-pair`; 0.15 adds `mysql56-ci`; all of these only warn, nothing breaks.
- Changed: the 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.
- Changed: the deploy layer requires PROCTOR ^0.12 (locked 0.12.0, was ^0.11): two new warning-only checks, nothing breaks.
- Site: the front page's stale facts are current (Squire ships an ADVISOR module, `squire_doctor` and `squire_drift`, so "Modules from each project" leaves "Not yet surveyed" for the Legend; the README, the Modules guide and the 0.2.0 upgrade note say so too).
- Changed: the deploy kit is Squire 0.10.7 (was 0.10.6): it ships a `.gitattributes` that pins line endings, so the deploy layer clears PROCTOR's line-ending warnings.
- Changed: the docs, agent-ready and deploy kits are Squire 0.10.6 (docs and agent-ready tools were the 0.9.0 bytes, deploy was 0.10.2): the docs builder and agent-ready generator see every file on Docker Desktop mounts, and `oracle-check.php` loses its D-046 reference.
### \[0.3.0\] - 2026-11-09 [#](https://advisor.apps.wayne.edu/docs/changelog.html#0-3-0-2026-11-09)
#### Added [#](https://advisor.apps.wayne.edu/docs/changelog.html#added-2)
- Added: Parity is in the parts list (`generator/projects.seed.json`), after Squire: Citadel on your own computer (Citadel's PHP image, its proxy and MySQL 5.6) for any app, with or without Squire, as one Go command line for every OS on Docker or Podman (Podman recommended). `list_projects`, `get_project_status` and `read_project_docs` know it, and the stack-parts table in the README and the "Where it sits" page has fifteen rows.
- Added: `owner_of` answers "local development" (and Parity, run Citadel locally, the parity kit, Podman) with Parity: the stack's local-development answer, which replaces Squire's parity group. The deploy-files row says Squire's old parity group is deprecated, and names Parity as the one that runs `build.sh`, `deployments/` and the health check the way Citadel does.
- Added: the front page puts Parity on the map (the Reflecting Pool, top left) with a route for "Can I run my app like Citadel on my laptop?" (`get_project_status`, then `read_project_docs` for Parity) and a chip that asks it, and in the neighborhood, linked to its repository on git.wayne.edu until its site is live. The neighborhood is five across, three on a tablet and two on a phone with the odd one centered. The README cast and the readme-art kit gain Parity's mark (copied from Parity's own brand files, resized only).
#### Changed [#](https://advisor.apps.wayne.edu/docs/changelog.html#changed-2)
- Changed: the generator counts a Go module (`go.mod`) as built, like a Composer or npm package, and no longer reads a `CHANGELOG.md` heading marked unreleased (`## 0.1.0 (unreleased)`) as a published version.
- Changed: Squire's role in the parts list names what goes onto Citadel (build.sh, deployments/, the release script, the health check, the portable image) and points local runs at Parity; the front page's deploy answer does the same.
- Changed: the `wayneui-copies`, `composer-ci` and `content-drift` CI jobs and the documented Docker commands (README, MAINTAINING, Contributing, Docker, Proof) use `composer:2.11.1` pinned by its multi-arch list digest (`sha256:8de2184c...`; was `composer:2.10.3`). 2.10 is no longer maintained, and 2.11.1 fixes GHSA-c968-33g3-wh7p and GHSA-fm2w-xgf2-f9fh.
- Changed: the deploy kit is Squire 0.10.2 (was 0.10.1): the kit's Dockerfiles name every image in full (`docker.io/library/...`), the fallback base takes Composer from a `COMPOSER_IMAGE` stage, `.squire/php.ini` sets `session.cookie_samesite = Lax`, and the portable image drops `node_modules/` after the frontend build. `squire init --check` passes.
- Changed: the front page deploy layer requires CREED ^0.1.8 and HELMET ^1.3 (locked 0.1.8 and 1.3.0; were ^0.1 at 0.1.7 and ^1.0 at 1.0.1) and locks PROCTOR 0.11.1 (was 0.11.0). ADVISOR's dev tools take Pinstripe ^0.3 (locked 0.3.0, was ^0.1 at 0.1.0); before 1.0 a minor step can break, and Pint, PHPStan on Pinstripe's raw preset and the tests pass on it. The GitHub workflow pins Preflight 0.1.4's commit (`79029cc`, was an untagged commit before 0.1.4); the GitHub mirror of Preflight has no newer tag.
- Changed: CI pins the Preflight components to 0.5.0 (was 0.4.0). The composer-audit job drops its own `composer:2@sha256:b6dc...` image input, since 0.5.0's default is `composer:2.11.1` by digest, and the proctor job keeps PROCTOR's JSON report as `proctor.json` for Rollcall. The a11y component is the same at 0.5.0, so `scripts/a11y/` does not change.
- Changed: the proctor job on the front page deploy layer blocks the pipeline (no `allow_failure`). Its stale reason (unbounded constraints, CI files missing in `deploy/`) no longer holds: `vendor/bin/proctor check --format=codequality` in `deploy/` passes on PROCTOR 0.11.1 with warnings only.
- Docs: MAINTAINING's "Who maintains it" names a role, the stack maintainer, instead of a person, and says to reach them with an issue on git.wayne.edu. The CI cache comment says what the internal decision ID stood for.
- data: resync 2026-11-09 evening against each stack repo's main (booster:d0216d2 creed:33ff9bc drawbridge:7b5a2ee helmet:993ac13 pinstripe:a94f979 preflight:89a788f proctor:b0ac5ce rollcall:969622c sesame:70dcab1 sourdough:c99fd24 squire:0567cb3 weld:b168229 wayne-ui:dedc66f, and this branch for ADVISOR's own docs): versions in `projects.json` move to CREED 0.1.8, PROCTOR 0.11.1, SESAME 0.7.2, HELMET 1.3.0, Sourdough 0.3.0, Preflight 0.5.0, Booster 1.14.0, Rollcall 1.1.0, Drawbridge 0.6.0 and Squire 0.10.3, with the readmes, best practices and handbook chapters that moved since the 08:45 pass.
- Changed: data resynced from the stack (2026-11-09 night) against each stack repo's main (booster:c708793 creed:89f4b8c drawbridge:ee81fd7 helmet:fe05f93 pinstripe:a94f979 preflight:9cad07d proctor:be21475 rollcall:74850b8 sesame:033b140 sourdough:b56dd35 squire:0567cb3 weld:8e496d4 wayne-ui:dedc66f, and this branch for ADVISOR's own docs): the handbook's code chapter and its rules say the disabled-TLS and joined-SQL bans are built in Pinstripe 0.3.0 (they said Planned), the docs name Preflight 0.5.0 and SESAME `^0.7`, the accessibility chapter names Preflight's `a11y` component at 0.5.0, and `projects.json` moves to Sourdough 0.4.0 and Booster 1.15.0.
- Docs: `.env.example` says no write tools exist "yet" (it said "in 0.1"), as the README and docs already do.
- data: resync 2026-11-09 late night against each stack repo's main (booster:c708793 creed:6267c2a drawbridge:e45e2a8 helmet:5c7c1f2 pinstripe:bf2726d preflight:62a0c76 proctor:3efbc73 rollcall:0039490 sesame:03f78b1 sourdough:2117d25 squire:c553d29 weld:5168fb1 wayne-ui:dedc66f parity:34a5589, and this branch for ADVISOR's own docs): Parity's README is bundled as `docs/parity/readme.md`, and `projects.json` moves to Sourdough 0.4.1, Squire 0.10.4 and WELD 0.2.0, with the Drawbridge, Pinstripe, Preflight, Rollcall, Sourdough, Squire and WELD docs that moved.
- Docs: the Proof page's "Last run" table records `composer ci` on the 0.2.0 release commit on 2026-11-09 (282 tests, 1535 assertions; the 2026-11-07 run had 249).
### \[0.2.0\] - 2026-11-09 [#](https://advisor.apps.wayne.edu/docs/changelog.html#0-2-0-2026-11-09)
#### Added [#](https://advisor.apps.wayne.edu/docs/changelog.html#added-3)
- Added: docs/threats/ explains four threats (prompt injection, path traversal, command injection, data exfiltration), where each applies, the code and tests that stop it, and what risk is left (backlog row 16).
- Added: upgrade_path takes from_php, so a project with no composer.json or no php constraint still gets a plan (Booster's --from-php); the 2026-11-08 proof run found 71 such refusals.
#### Changed [#](https://advisor.apps.wayne.edu/docs/changelog.html#changed-3)
- Changed: the deploy kit is Squire 0.10.1 (was 0.10.0): `.squire/base-fallback.Dockerfile` copies Composer 2.11.1 (was 2.10.3, no longer maintained), and the deploy layer requires PROCTOR ^0.11 (locked 0.11.0, was ^0.8 at 0.8.0).
- Changed: the deploy kit is Squire 0.10.0 (was 0.7.1): release.sh keeps Composer and npm download caches in the app folder and the gate takes SQUIRE_PHP_RUNTIME; the compose file, health.php and .env.squire.example follow the template, and the portable image files are added.
- Changed: ADVISOR reads the policy through CREED's own reader (waynestate/creed ^0.1.8) instead of a mirrored copy, so policy_lookup and get_project_status answer exactly what PROCTOR decides; a line marked current (vue 3, inertia 2 and 3) now reads as active, where the mirror gave no state. A version the policy does not list keeps ADVISOR's answers: older than every line is end of life with a note, newer is refused with the same message.
- Docs: the README, MAINTAINING and the contributing page list everything `composer ci` runs (the agent-ready and docs site checks were missing); "What it offers" says `policy_lookup` answers end of life for a version older than the policy lists and names `upgrade_path`'s `from_php` input, as the README does; the docs overview says what main carries since 0.1.7; and the front page footer links the docs, git.wayne.edu and the GitHub mirror.
- Changed: CI pins the Preflight components to 0.4.0 (the proctor job clones the full history, so the override-approver check can read git blame).
- Changed: the deploy layer runs Squire's kit 0.7.1 (was 0.6.0): `.squire/php.ini` no longer sets the deprecated `session.sid_*` lines, web requests get a `disable_functions` list and Apache hardening (`.squire/php-web.ini`, `.squire/apache-hardening.conf`), and opcache gets production settings with `SQUIRE_OPCACHE_VALIDATE` as the one switch.
- Changed: the front page deploy layer requires HELMET ^1.0 (lock at 1.0.1, was 0.4.0), like the rest of the stack; its shared front controller already runs on HELMET 1.0 in Squire, Sourdough and Pinstripe.
- Changed: policy_lookup answers end of life (with a note) for a version older than every one the policy lists, instead of refusing; the 2026-11-08 proof run found 13 such refusals for PHP 5.5 to 7.3.
- Changed: CI's accessibility gate is Preflight's a11y component (light and dark, 320 and 1280 px, and the WCAG 1.4.10 reflow check); ADVISOR's own page checks (one h1, lang, title, reduced motion) stay as the a11y-extra job.
- Docs: BEST_PRACTICES gains a threat model: eleven threats, each mapped to the rules that answer it and to OWASP Top 10:2025, OWASP ASVS 5.0 or NIST SSDF, plus what is out of scope (ADVISOR-16).
- Changed: CI pins the Preflight components to 0.3.1 (fixed cache keys, and caches saved even when a job fails; D-072).
- Changed: CI saves its Composer and npm caches even when a job fails, so a retry after a dropped download fetches only what is missing (D-072).
- Changed: CI caches Composer and npm downloads under a fixed key, so a lock change downloads only what changed (D-072).
- Fixed: OPEN_QUESTIONS.md names the Preflight commit the GitHub workflow really pins and says the README badges are real.
- Fixed: the docs menu closes with Escape and hands focus back to its button (docs kit synced from Squire).
- Changed: the deploy layer requires PROCTOR ^0.8 (locked 0.8.0).
- Changed: the pipeline pins every Preflight CI component to 0.3.0 ([preflight@0.3.0](mailto:preflight@0.3.0)); component image inputs are plain image names, since Preflight adds the Dependency Proxy prefix itself.
- data: resync 2026-11-08 morning (booster:9d76fee drawbridge:829f465 helmet:e96f7f6 sesame:aea6871 proctor:181bb7e rollcall:2a053b9 creed:e7818c4 sourdough:2182baf weld:bf9c2e4 squire:5276918 preflight:3aa18d2 pinstripe:b56f077 advisor:e82d901 wayne-ui:dedc66f): HELMET's README matches its code (the presets set proxies only, so the app picks its log file; a relative CSP report path is valid), and Drawbridge's third-party-cookie sign-out practice now runs in a real browser engine.
- data: resync 2026-11-08 (booster:b8b5e5a drawbridge:a7c42fb helmet:b8196b9 sesame:7195b63 proctor:97c2005 rollcall:091bd8b creed:e7818c4 sourdough:2182baf weld:bf9c2e4 squire:34bd199 preflight:3aa18d2 pinstripe:54790ca advisor:fcc5974 wayne-ui:dedc66f): the policy gains CREED's `sessions` block (SESAME and Drawbridge session lifetimes), and PROCTOR's README gains its ADVISOR module section.
- data: resync 2026-11-07 late (booster:4fbf3ed drawbridge:a7c42fb helmet:b8196b9 sesame:2302725 proctor:e00dda4 rollcall:45b0837 creed:be2a0b2 sourdough:2182baf weld:bf9c2e4 squire:55b89c7 preflight:3aa18d2 pinstripe:54790ca advisor:4d8f41a wayne-ui:dedc66f): the word-name sweep (Rollcall, Squire, Preflight, Drawbridge in prose), WELD 0.1.5, PROCTOR's crlf-deploy-script check.
- Changed: the GitLab pipeline pins the Preflight components to 0.2.0 (was 0.1.0 and 0.1.2).
- 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).
- CI caches Composer and npm downloads per lock file (`.composer-cache`, keyed on `composer.lock` and `deploy/composer.lock`, and `.npm-cache`), so a pipeline stops fetching every package from Packagist and npm on every run. Images already come through the Dependency Proxy.
- data: resync 2026-11-07 evening (booster:d99b049 creed:39fa8c3 drawbridge:27cc793 helmet:902b522 pinstripe:cdabcb0 preflight:f26584b proctor:e9ede7e rollcall:06dcfda sesame:b5a0c09 sourdough:181b884 squire:dba0686 weld:2746423 wayne-ui:dedc66f advisor:45c8379): README and best-practices updates from Drawbridge, Preflight, PROCTOR, Rollcall, SESAME and Sourdough, and ADVISOR's own README. Versions in `projects.json` are unchanged.
- data: Sourdough's entry lists all five shapes, `--raw --vue` included (it said that shape was not available yet), and its next step names `sourdough feed`, which ships (it said feed was a later release).
- Changed: the a11y-extra job runs Playwright 1.65.0 and axe-core 4.14.0 on the image digest Preflight 0.4.0 pins (was Playwright 1.49.1 and axe-core 4.10), so ADVISOR's own page checks and the stack's a11y gate use one engine.
- data: resyncs from 2026-11-08 03:40 through 2026-11-09 08:45 against each stack repo's main: Preflight 0.4.0 pins and its must-fail fixtures, PROCTOR 0.9.0 (the entrypoint-migrate, gitattributes, preflight-gates and mysql-minimum rules), Squire 0.9.0, SESAME 0.6.2 (strict-mode sessions, CAS 2.0, the Eloquent refresh fix), HELMET 1.0.1 and its ribbon list, Rollcall 1.0.0, Pinstripe 0.3.0, Booster 1.12.0, Drawbridge 0.4.0, CREED handbook tags and WELD's regen gate.
#### Fixed [#](https://advisor.apps.wayne.edu/docs/changelog.html#fixed-2)
- Fixed: a docs truth pass (2026-11-09). The install page lists `waynestate/creed` and the Symfony `^7.4 || ^8.0` range; "Where it sits" names all four Preflight components; the best-practices and contributing pages stop listing the threat model as not built; the commands page gives doctor's exit code 2; the threat pages cite the lines the code is on today; OPEN_QUESTIONS lists every optional setting. The front page's ask box says Drawbridge is an OpenID Connect client for Entra ID (it said SAML), names SESAME's OpenID Connect driver, carries Laravel 13's real active-support date and MySQL 5.6 from the policy, and writes Booster, Preflight, Squire, Rollcall and Drawbridge as words.
- Fixed: the docs and the front page keep their Docs link in the header on a phone (it used to vanish below 900px with the section links), the docs sidebar opens scrolled to the page you are on with a thin scrollbar, Troubleshooting's symptoms are h2 headings under the h1 (they skipped to h3), and the Overview's tagline sits under its title.
- 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: the front page's version chip shows the full version the docs show (Sheet 0.1.7, was Sheet 0.1). It carries `data-docs-version` now, so the docs builder (synced from Squire) rewrites it at every release and `composer docs:check` fails while it is stale.
- Fixed: the docs overview's tagline (What applies, and what's next.) has a paragraph's room above and below, in the map's display face, instead of sitting tight on the text under it.
- The pipeline's PROCTOR jobs no longer pass `--policy`, which PROCTOR 0.7 refuses in CI; PROCTOR checks against the CREED policy it bundles.
- The Docker commands in the README, MAINTAINING.md and the contributing and proof docs mount the shared Composer cache (`-v stack-composer-cache:/tmp/cache`), and the accessibility gate's command mounts the npm cache, so a local run does not download every package again.
- The front page's parts list says Sourdough starts all five app shapes; it said "the raw PHP starter".
### \[0.1.7\] - 2026-11-07 [#](https://advisor.apps.wayne.edu/docs/changelog.html#0-1-7-2026-11-07)
#### Changed [#](https://advisor.apps.wayne.edu/docs/changelog.html#changed-4)
- The front page's deploy layer (`deploy/`) completes Squire's kit 0.5.0: `oracle-check.php`, which the 0.5.0 `squire update` did not add, is written and recorded, so `squire init --check` passes. `site/assets/stack-env.js` takes the stack's one copy, with bindingless catch blocks.
- The canonical repository is git.wayne.edu (ADR-0021); docs, links and package metadata no longer point at the archived nougat copy.
#### Added [#](https://advisor.apps.wayne.edu/docs/changelog.html#added-4)
- `owner_of` answers from an ownership table rebuilt from the stack's decisions, the one-owner-per-rule table first (version policy, lock file, `composer audit`, MySQL 5.6, `/up`, deploy files, CI contents, the parts list), then app wiring, sign-in and the coding standard. Every match carries `decision`, the decision it comes from, named by title and date. Rows gain `aliases` ("composer.lock", ".gitlab-ci.yml", "/up"), question words are ignored ("who owns composer audit" works), words match at word starts, and exact topic or alias matches come first. `content:verify` requires the decision and refuses an alias that names two rows.
- `read_project_docs` trims image boilerplate again at read time, so docs bundled before a trim rule existed are served clean without editing `data/docs`. The trim (now `Content\ImageTrim`, shared with the generator) also drops linked hero images (an image Markdown wrapped in a link) and rows of nothing but badges, which the generator used to let through (Sourdough's README hero and badge row).
- The Proof page records its last run.
- data: resync 2026-11-06 night (booster:8c57a15 drawbridge:a60990a helmet:8a79b46 sesame:2505033 proctor:038d632 rollcall:aed8dd9 creed:0f6ab20 sourdough:b2644b3 weld:baf8e60 squire:88fd2ec preflight:a5ed45a pinstripe:eb03078 advisor:c3964c5 wayne-ui:9e1e762): Booster, CREED handbook and best practices, PROCTOR, Preflight and SESAME docs, the abandoned_packages policy, and the released versions of Booster, PROCTOR, Sourdough and others.
- data: resync for the 2026-11-07 releases (Booster 1.10.0, CREED 0.1.7, Drawbridge 0.3.0, HELMET 0.4.0, Preflight 0.2.0, PROCTOR 0.7.0, Rollcall 0.1.10, SESAME 0.5.0, Sourdough 0.1.7, Squire 0.6.0, WELD 0.1.4; Pinstripe stays 0.1.4).
### \[0.1.6\] - 2026-11-06 [#](https://advisor.apps.wayne.edu/docs/changelog.html#0-1-6-2026-11-06)
#### Added [#](https://advisor.apps.wayne.edu/docs/changelog.html#added-5)
- data: resync 2026-11-05 evening (booster:eaf2758 drawbridge:aa403f3 helmet:36cb918 sesame:ae2fb9e proctor:33c329a rollcall:fc4cc43 creed:d919161 sourdough:bdb831d weld:6da94b9 squire:335c4e4 preflight:7913c45 pinstripe:347a34e wayne-ui:66d5539 advisor:4fdc7b0)
- data: resync 2026-11-05 late (booster:5b25715 drawbridge:19698ea helmet:417129a sesame:ae2fb9e proctor:33c329a rollcall:fc4cc43 creed:d919161 sourdough:bdb831d weld:6da94b9 squire:9384c1d preflight:7913c45 pinstripe:347a34e wayne-ui:66d5539 advisor:ba8b7e1)
- data: resync 2026-11-06 morning (booster:fc8e42e drawbridge:265c57d helmet:bca4c25 sesame:67a7fae proctor:33c329a rollcall:a8aaac5 creed:15cc9cc sourdough:387773e weld:a88d703 squire:6a6a352 preflight:734728d pinstripe:7d71088 wayne-ui:7c237a2 advisor:31544c6): Booster 1.9.0, WELD 0.1.3, the CREED and ROLLCALL docs brand pass, proof pages for Preflight, Pinstripe, ROLLCALL and WELD.
- data: resync 2026-11-06 afternoon (booster:bf1bd59 drawbridge:131ea28 helmet:8718bbf sesame:af9e764 proctor:5a8d5ca rollcall:6e9d4a8 creed:cbf2163 sourdough:7444c3c weld:6eb9c42 squire:8bbc9c7 preflight:f1c56ac pinstripe:e329dd7 wayne-ui:9e1e762 advisor:8d3d2f6): accessibility gates on SESAME, Booster, CREED, Preflight, PROCTOR and HELMET, and the Booster dogfood fixes for the front-end hops.
- data: resync 2026-11-06 evening (booster:bf1bd59 drawbridge:d0fa5b4 helmet:8718bbf sesame:af9e764 proctor:5a8d5ca rollcall:6e9d4a8 creed:cbf2163 sourdough:173b14a weld:82ee1a6 squire:8bbc9c7 preflight:f1c56ac pinstripe:e329dd7 advisor:a7d58f2 wayne-ui:9e1e762): accessibility gates on WELD and DRAWBRIDGE, the Sourdough raw PHP + Vue shape.
- Added: a proof run (scripts/proof/ProofRunner.php, bin/proof.php) that walks a corpus of app folders through the real `bin/advisor mcp` server over stdio and keeps one JSONL line per app (pass, flagged, tool-error or not-applicable); dev tooling, not part of the served product.
- Added: an accessibility gate (scripts/a11y/check.mjs) that loads every HTML page under site/ in a real browser and fails on any axe-core WCAG violation, in light and dark themes at phone and desktop width, plus a reduced-motion pass; runs as the a11y job in GitLab CI.
- Added: a docs site (site/docs/) built by the shared docs builder from docs/, checked in composer ci.
#### Changed [#](https://advisor.apps.wayne.edu/docs/changelog.html#changed-5)
- Changed: resynced the bundled content (data/) with the stack as of 2026-11-05, including Booster 1.8.2 and 1.8.3, DRAWBRIDGE (session store, secret files, GitHub references removed), HELMET (H21 partly enforced, warn_broad_proxies), SESAME (CAS login bound to its browser), PROCTOR, ROLLCALL, CREED handbook chapters, Sourdough (--sail, --docker, Pest 4) and the WELD and SQUIRE guides; the Sourdough role now lists every shape that generates; the docs builder and kit follow SQUIRE 97744a4, which keeps the changelog page h1 itself.
- Changed: the docs pages wear the front page's look: the same sheet head and main menu (Docs marked current), Fraunces titles with a plotted maroon route, the legend's mono labels, commands on the dark code ground with the gold Copy tab, callouts drawn as map marks (note, tip, out of bounds), the green footer band, and a dark mode derived from the Directions band. Motion only without a reduced-motion preference. Source: `docs/_header.html` and `docs/theme/advisor.css` through the builder's `theme` key. The front page site owes a Quick Update.
- Changed: the bundled data is resynced with the stack's main branches of 2026-11-03 (afternoon): SESAME S45 and the DRAWBRIDGE module floor (from branch heads awaiting main), HELMET H42 4xx pages, H43, H53 and H41 notes; SESAME S4, S41, S42 and S27; plus the Booster, Preflight, PROCTOR and Squire docs that moved.
- Changed: the bundled data is resynced again (evening): PROCTOR composer-audit-off, not-audited, scoped overrides and the ignore-entries count; Pinstripe Node 22/24/26 matrix, the Laravel + Vue fixture and ADR-0001; plus the other projects docs that moved on main.
- Changed: the bundled data is resynced with the stack's main branches (late evening of 2026-11-03): Sourdough (Playbook required by default, released HELMET/SESAME/PROCTOR pins in the templates, Preflight pinned to a SHA), Squire (release workflow, docs builder gates), WELD, HELMET 0.3, SESAME 0.4, Preflight, Booster and Drawbridge docs; ADVISOR's own version reads 0.1.5.
- Changed: the bundled data is resynced again (night of 2026-11-03): the Pinstripe and Squire readmes moved; Booster, ROLLCALL and WELD docs were already current.
- Changed: the bundled data is resynced again (late night of 2026-11-03): Sourdough (`composer playbook` script), HELMET, Preflight and Squire readmes moved; WELD docs were already current.
- Changed: symfony/console and symfony/process accept ^8.0 as well as ^7.4, so apps on Pest 5 / PHPUnit 13 can install ADVISOR.
- Changed: the docs builder and kit are resynced from Squire's unified builder (theme hook, callouts, code tabs, task lists, copy button fix).
#### Fixed [#](https://advisor.apps.wayne.edu/docs/changelog.html#fixed-3)
- Fixed: the proof runner keeps the tool binary paths out of the error text: each of the proctor, booster and advisor binary paths is shortened to its file name before the scratch and corpus folders are masked as /app.
- Fixed: front-page scroll reveals start hidden from first paint (plain CSS under `html.motion`, set in `` before the body parses) instead of fading out after load, so unscrolled below-the-fold content sits at opacity 0 rather than being caught mid-fade; the motion class is only set where IntersectionObserver exists, so a page that hides content can always bring it back.
- Fixed: docs code blocks that scroll sideways are keyboard focusable (`tabindex="0"`), satisfying the scrollable-region-focusable rule. Since the resync with Squire's unified docs builder, the kit's docs.js does this for every block that overflows, tabs included.
- Fixed: the changelog docs page keeps its `# Changelog` heading, so the page has exactly one level-1 heading (a comment now sits above the heading in CHANGELOG.md, so the shared builder keeps it).
- Fixed: table-of-contents sub-links carry the base `docs-toc__item` class again, so they get the block display and padding that keep them at or above the 24px target size (and their hover color).
#### Security [#](https://advisor.apps.wayne.edu/docs/changelog.html#security)
- The front-page deploy layer moves to Symfony 7.4.23 (symfony/http-foundation and symfony/yaml advisories, including CVE-2026-118514).
### \[0.1.5\] - 2026-11-03 [#](https://advisor.apps.wayne.edu/docs/changelog.html#0-1-5-2026-11-03)
- Changed: the deploy layer requires HELMET ^0.3 and PROCTOR ^0.4 (locked at 0.3.0 and 0.4.0) and sets minimum-stability to stable, which clears PROCTOR 0.4's new minimum-stability warning. HELMET 0.3 reads an empty `HELMET_PROXIES=` as trust nobody; the front page sets only the `citadel` preset, so nothing changes for it. The front page site owes a Quick Update.
- Changed: the deploy layer's Squire kit is refreshed to 0.5.0 (updated `base-fallback.Dockerfile`, `scripts/release.sh` and `scripts/parity.ps1`). The front page site owes a Quick Update.
- Changed: the bundled data is resynced with the 2026-11-03 releases: Booster 1.8.0, Preflight 0.1.4, PROCTOR 0.4.0, Pinstripe 0.1.2, CREED 0.1.6, ROLLCALL 0.1.9, HELMET 0.3.0, SESAME 0.4.0, Drawbridge 0.1.1, Sourdough 0.1.5, Squire 0.5.0 and WELD 0.1.2 (versions in `projects.json`), and with each project's main since the last pass (PROCTOR's new `composer-config` and `composer-audit` rule ids, Booster's newcomer-friendly install and run notes, Preflight's `job_name` inputs, and updates to the Drawbridge, Pinstripe, ROLLCALL, SESAME, HELMET, Squire and Sourdough docs).
- Added: one Playbook settings resolver (`Waynestate\Advisor\Playbook\Settings`, ADR-0018). A name resolves from the real environment first, then the Playbook package, then a `.env.playbook` file in the project root; secret-looking names are still refused. `playbook_lookup` now uses it, so it answers from `.env.playbook` when the package is not installed (same output shape), and the "how to get it" text now includes the `.env.playbook` download for Linux, macOS and Windows.
- Changed: `.env.playbook` is git-ignored; the agent-ready files (`site/llms.txt`, `site/llms-full.txt`) are regenerated.
- Changed: docs and package metadata name nougat as the canonical repository, with git.wayne.edu and GitHub as read-only mirrors, until git.wayne.edu has CI runners.
### \[0.1.4\] - 2026-11-03 [#](https://advisor.apps.wayne.edu/docs/changelog.html#0-1-4-2026-11-03)
- Changed: CI pulls its Docker Hub images through the GitLab Dependency Proxy (the group's CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX), so pipelines no longer hit Docker Hub's anonymous pull limit.
### \[0.1.3\] - 2026-11-02 [#](https://advisor.apps.wayne.edu/docs/changelog.html#0-1-3-2026-11-02)
#### Added [#](https://advisor.apps.wayne.edu/docs/changelog.html#added-6)
- Added: hand-written guides bundled from generator/guides/ and served as advisor://guide/; first guide: Connect to Oracle on Citadel.
- Added: policy_lookup returns latest_patch; the bundled docs drop hero images, badges and GIFs.
- Added: WayneUI's migration guide (MIGRATING.md) is bundled as the migrating doc, and every project entry carries its version when it publishes one (composer.json, else package.json, else the newest CHANGELOG heading).
- Docs: a one-line `claude mcp add` and a Docker `.mcp.json` for machines without PHP.
- Added: composer content:drift and an optional CI job that fail when data/ no longer matches the sibling repos.
#### Changed [#](https://advisor.apps.wayne.edu/docs/changelog.html#changed-6)
- Changed: the deploy layer's Squire kit is refreshed to 0.3.3 (release options can now live in ./.env.squire).
- Changed: the deploy layer's Squire kit is refreshed to 0.3.4 (the local .env.squire file is now git-ignored).
### \[0.1.2\] - 2026-10-29 [#](https://advisor.apps.wayne.edu/docs/changelog.html#0-1-2-2026-10-29)
#### Added [#](https://advisor.apps.wayne.edu/docs/changelog.html#added-7)
- Added: agent-ready site (prompt blocks, Markdown twins, llms.txt), from Squire's kit.
- `playbook_lookup` tool: answers "what is the value of X?" for WSU shared values. An environment variable of the same name wins, then the private `waynestate/playbook` package (Playbook) supplies the rest; without it the tool says how to get it instead of failing. Keys that look like secrets (ending in SECRET, PASSWORD, TOKEN or KEY) are refused. `waynestate/playbook` is suggested, never required.
#### Changed [#](https://advisor.apps.wayne.edu/docs/changelog.html#changed-7)
- Changed: docs copies resynced; proof results now live on proof.apps.wayne.edu.
- Changed: project names written as words except acronyms.
#### Fixed [#](https://advisor.apps.wayne.edu/docs/changelog.html#fixed-4)
- Fixed: stale capability claims in the site and docs.
### \[0.1.1\] - 2026-10-29 [#](https://advisor.apps.wayne.edu/docs/changelog.html#0-1-1-2026-10-29)
#### Added [#](https://advisor.apps.wayne.edu/docs/changelog.html#added-8)
- `owner_of` tool: answers "which project owns X?" from a new bundled `data/ownership.json` table (sourced from `generator/ownership.json`, verified by `content:verify`). Fuzzy match: every word of the topic must appear in a row's topic or role; a no-match answer lists every known topic.
#### Changed [#](https://advisor.apps.wayne.edu/docs/changelog.html#changed-8)
- `upgrade_path` moves from the `stack` group to a new `booster` group, so `ADVISOR_GROUPS=stack` offers reference tools only and never starts a program. `ADVISOR_GROUPS` now accepts `stack`, `proctor` and `booster`.
- PHPStan includes Pinstripe's `raw.neon` preset (`waynestate/pinstripe` 0.1.0 as a dev dependency) instead of a hand copy of its settings; two docblocks were tightened to satisfy the preset's method-signature checks. Pint already used the `per` preset, so `pint.json` is unchanged.
### \[0.1.0\] - 2026-10-29 [#](https://advisor.apps.wayne.edu/docs/changelog.html#0-1-0-2026-10-29)
First build, aimed at 0.1.0.
#### Added [#](https://advisor.apps.wayne.edu/docs/changelog.html#added-9)
- Read-only MCP server over stdio (`php vendor/bin/advisor mcp`) on the official `mcp/sdk` 0.9.0, speaking both the legacy `initialize` handshake and the 2026-07-28 per-request form.
- Seven tools: `list_projects`, `get_project_status`, `read_project_docs`, `policy_lookup`, `list_stack_rules`, `run_proctor_check`, `upgrade_path`. Resources `advisor://policy` and `advisor://creed/`. Prompts `orient_me` and `plan_upgrade`.
- `upgrade_path`: plans the app's PHP and/or Laravel upgrade, one supported hop at a time, by running BOOSTER's read-only `plan` (never `run`) against the bundled policy. New settings `ADVISOR_BOOSTER_TIMEOUT` (default 60) and `ADVISOR_BOOSTER_BIN` (fallback when the app has no `vendor/bin/booster` of its own).
- Bundled, hash-verified content (CREED handbook and policy, project docs, the WayneUI markup contract) with a generator, `content:generate --check` and `content:verify`.
- `advisor install` for Claude, WarriorGPT, Cursor, VS Code (written) and Codex (printed).
- Laravel adapter on `laravel/mcp` (`php artisan mcp:start advisor`), so ADVISOR runs beside Laravel Boost.
- Safety: off unless enabled, refuses production, read-only by default, path confinement, allowlisted child environment, redaction, invisible-character stripping, manifest-only module loading, argument-hash audit log.
- `composer ci`: validate, content verify, PHPUnit, Pint, PHPStan level 8 (Pinstripe settings), audit. CI files for GitLab (PREFLIGHT 0.1.0) and GitHub.
---
Source: https://advisor.apps.wayne.edu/docs/contributing.html
## Contributing [#](https://advisor.apps.wayne.edu/docs/contributing.html#contributing)
This page tells you how to make a change to ADVISOR, what rules the change must keep, and what work is still open.
### Where changes go [#](https://advisor.apps.wayne.edu/docs/contributing.html#where-changes-go)
Development happens on git.wayne.edu, the canonical repository: [enterprise-apps/advisor](https://git.wayne.edu/enterprise-apps/advisor) (clone `git@git.wayne.edu:enterprise-apps/advisor.git` over SSH, or `https://git.wayne.edu/enterprise-apps/advisor.git` over HTTPS). Changes, issues and merge requests go there, CI runs there on its instance runner, and tags are made there by the maintainer, with an approver. GitHub ([waynestate/advisor](https://github.com/waynestate/advisor)) is a read-only push mirror of git.wayne.edu for Packagist: nobody pushes to it.
### Build and test [#](https://advisor.apps.wayne.edu/docs/contributing.html#build-and-test)
| Task | Command |
| --- | --- |
| Install | `composer install` |
| All checks (what CI runs) | `composer ci` |
| Regenerate `data/` from the stack repos | `php bin/advisor content:generate --sources=` |
| Check `data/` against the repos | add `--check` to the line above (exit 1 on drift) |
| Check `data/` against its manifest | `composer content:verify` |
| Regenerate the parts table in the README | `php bin/advisor stack-parts --write=README.md` |
| Diagnose a client setup | `php vendor/bin/advisor doctor` (in an app) |
`composer ci` runs `composer validate --strict`, `content:verify`, `stack-parts --check=README.md`, PHPUnit, Pint, the agent-ready check, PHPStan, `composer audit` and the docs site check (`composer docs:check`). CI cannot see the sibling repos, so it verifies the manifest; regenerating is a local step.
With only Docker:
```
docker run --rm -v "${PWD}:/app" -v stack-composer-cache:/tmp/cache -w /app composer:2.11.1@sha256:8de2184c6de224f4689e8f80ed5f5edaf0030b6b8b7839a22a2bcb6722ac87d0 sh -c "composer install --no-interaction && composer ci"
```
Snapshot tests are updated with `ADVISOR_UPDATE_SNAPSHOTS=1` (`$env:ADVISOR_UPDATE_SNAPSHOTS = "1"` in PowerShell) before `vendor/bin/phpunit`. The same run rewrites the front page's field book readouts (`site/assets/readouts.json`) from the real tools; the readouts test fails only when a call on the map is missing, refused, or changes shape, so a content resync does not need it.
### Rules a change must keep [#](https://advisor.apps.wayne.edu/docs/contributing.html#rules-a-change-must-keep)
Every change to ADVISOR must keep the following practices:
1. **Read-only first.** Every tool states all four hints (read-only, destructive, idempotent, open-world). A tool that writes is left out unless `ADVISOR_READ_ONLY` is turned off, and that switch beats tool groups. Enforced (contract test).
2. **Narrow tools, closed schemas.** No tool takes a command, a URL or a free path. Schemas set `additionalProperties: false`, and arguments are validated again on our side. Enforced (contract test).
3. **Run other programs the safe way.** Fixed program, argument array, allowlisted environment, a timeout, and no shell. Paths are resolved and must stay inside the project root. Enforced.
4. **Keep stdout clean.** Only protocol lines go to stdout; logs, warnings and stray output go to stderr. Enforced (subprocess test).
5. **Strip invisible characters.** The TAG block, zero-width and bidirectional controls are removed from everything served and rejected in tool metadata. Enforced (contract test).
6. **Load modules from a manifest only,** from the `Waynestate\` namespace, implementing `Module`. Never scan. Enforced.
7. **Serve from verified data.** Bundled content is checked against a SHA-256 manifest at start-up and in CI; a mismatch stops the server. Enforced.
8. **Review any change to the tool list.** `tools/list` is snapshotted; a changed description is a reviewed diff. Enforced (snapshot test).
9. **Cite sources and date.** Policy answers carry the day they were worked out for and the file they came from. Enforced.
### Keeping the content fresh [#](https://advisor.apps.wayne.edu/docs/contributing.html#keeping-the-content-fresh)
Run `content:generate` after any change that lands in CREED's policy or handbook, a project's README or best practices, an extra doc, or the projects seed. Commit the regenerated `data/` with the source commits in the message. To add a project to the parts list, add its `name` and `tagline` to `generator/projects.seed.json`, then regenerate and `stack-parts --write`.
Beyond a project's README and best practices, a seed may bundle further files under `extra_docs` (a map of slug to path in the project); each lands in `data/docs//.md` and in the project's docs list, and a missing file is skipped, not an error. WayneUI's entry bundles its MIGRATING.md as the `migrating` doc.
Hand-written guides live in `generator/guides/`, one Markdown file per slug, served as `advisor://guide/`. Edit them there, then run `content:generate`.
### Catch stale bundled docs [#](https://advisor.apps.wayne.edu/docs/contributing.html#catch-stale-bundled-docs)
`composer content:drift` compares `data/` with a checkout of the stack repos and exits 1 when they no longer agree. It takes the folder from `ADVISOR_STACK_DIR`; without it, it prints how to run it and exits 1:
```
ADVISOR_STACK_DIR= composer content:drift
```
It writes nothing. On drift it lists the files that moved; regenerate with `composer content:generate` and review the diff before committing.
Run the drift check before every tag: a release must carry docs that still match the repos it advises on.
### Releasing [#](https://advisor.apps.wayne.edu/docs/contributing.html#releasing)
ADVISOR is public, so its bundle must not carry internal names. The public-posture test always checks generic shapes; private strings are loaded from a denylist file named by `ADVISOR_PRIVATE_DENYLIST`, kept outside the repository (in CI, a masked file-type variable).
Warning
The denylist file is never committed. The bundle is regenerated with the file present before every release.
1. Move the lines under `## [Unreleased]` in `CHANGELOG.md` (Keep a Changelog) to a new `## [X.Y.Z] - YYYY-MM-DD` heading.
2. With the denylist file present, regenerate: `php bin/advisor content:generate --sources=`, then `composer ci` (the public-posture test must pass).
3. Both pipelines green for that commit. Run a secrets scan of the history.
4. Tag `X.Y.Z` (no `v`) on git.wayne.edu. Its push mirror carries the tag to GitHub, and Packagist picks it up from there.
5. A release needs a maintainer's approval. Never move or delete a published tag.
### Open work [#](https://advisor.apps.wayne.edu/docs/contributing.html#open-work)
The following items are open questions or not yet built:
- A recorded green run on a native Windows PHP. The GitHub `native-os` workflow runs `advisor doctor` and the stdio tests on Windows and macOS on every push to main; this line goes when its first green run is recorded. The MCP Inspector in CI is not added (open question 7).
- Signing of any state handed back to a client (no tool needs it yet).
- A full-capture audit mode (the threat model mapped to OWASP and NIST is done: see `BEST_PRACTICES.md` and the threat pages).
- "Ask ADVISOR" web chat: needs a model, an open stack question and an accessibility pass of its own.
- HTTP transport and OAuth: stdio first; remote needs a threat model of its own (the one in `BEST_PRACTICES.md` covers stdio only).
- Tools that write (scaffold with Sourdough, apply a Booster step): the approved list is read-only; the read-only switch and tool groups are built so they can arrive safely.
- Per-project modules in their own repositories: the loader and `Module` interface exist and are tested; the other projects have not published modules.
- WarriorGPT-backed features: no model calls until an open stack question is settled.
- Plan handles, `requestState` signing and elicitation: no tool needs state or a question to the user yet.
- Full-capture audit mode: hashes only by default; an opt-in needs a retention decision.
- MCP Inspector in CI, and the full suite on Windows and macOS (the `native-os` workflow runs doctor and the stdio tests there).
### Related [#](https://advisor.apps.wayne.edu/docs/contributing.html#related)
- [Upgrading](https://advisor.apps.wayne.edu/docs/upgrading.html)
- [Releasing](https://advisor.apps.wayne.edu/docs/deploying/releasing.html)
- [Best practices](https://advisor.apps.wayne.edu/docs/reference/best-practices.html)
- [Commands](https://advisor.apps.wayne.edu/docs/reference/commands.html)
---
Source: https://advisor.apps.wayne.edu/docs/deploying/refreshing-the-content.html
## Refreshing the content [#](https://advisor.apps.wayne.edu/docs/deploying/refreshing-the-content.html#refreshing-the-content)
This page shows how to keep ADVISOR's bundled content in `data/` current with the stack: regenerate it, verify it, and check for drift.
### What is generated [#](https://advisor.apps.wayne.edu/docs/deploying/refreshing-the-content.html#what-is-generated)
The handbook, policy, project docs, the WayneUI markup contract and WayneUI's 1.x to 2.x migration guide in `data/` are generated from the sibling stack repositories by `content:generate` and verified at start-up against `data/manifest.json` (a SHA-256 for every file). If a file does not match, the server refuses to start rather than serve it. Files are cleaned on the way in: line endings are normalized and invisible characters (the TAG block, zero-width and bidirectional controls) are stripped. Image boilerplate is trimmed from the project docs, on the way in and again when `read_project_docs` serves them: centred hero, badge and cast blocks, lone images whose target is relative or a GIF (linked or not), and rows of nothing but badges. Prose, tables and code blocks are left alone, and the bundled file itself is never rewritten at read time, so its manifest hash still holds. Each project entry also carries its version when the project publishes one (composer.json, else package.json, else the newest CHANGELOG heading).
Beside the generated docs, hand-written guides are kept by hand in `generator/guides/` (one Markdown file per slug), the same way the ownership table is kept. Each is bundled into `data/guides/` and served as `advisor://guide/`; the first is "Connect to Oracle on Citadel".
### Regenerate [#](https://advisor.apps.wayne.edu/docs/deploying/refreshing-the-content.html#regenerate)
With the stack repos checked out side by side:
```bash
php vendor/bin/advisor content:generate --sources=/path/to/stack
```
`--sources` can also come from `ADVISOR_STACK_DIR`. Run `content:generate` after any change that lands in CREED's policy or handbook, a project's README or best practices, an extra doc, or the projects seed. Commit the regenerated `data/` with the source commits in the message.
The generator reads each project's folder from beside the other repos, so a stale clone gives stale docs. WayneUI's development happens on its GitLab repository and the checked-out copy is only a mirror of it: fast-forward the local wayne-ui clone to that repository's main before a resync.
To add a project to the parts list, add its `name` and `tagline` to `generator/projects.seed.json`, then regenerate and run `php bin/advisor stack-parts --write=README.md`.
Beyond a project's README and best practices, a seed may bundle further files under `extra_docs` (a map of slug to path in the project); each lands in `data/docs//.md` and in the project's docs list, and a missing file is skipped, not an error. WayneUI's entry bundles its MIGRATING.md as the `migrating` doc.
### Verify [#](https://advisor.apps.wayne.edu/docs/deploying/refreshing-the-content.html#verify)
CI cannot see the sibling repositories, so `composer ci` runs `content:verify`, which needs none of them:
```bash
php vendor/bin/advisor content:verify
```
It checks the bundled `data/` against `data/manifest.json` (a SHA-256 for every file).
### Check for drift [#](https://advisor.apps.wayne.edu/docs/deploying/refreshing-the-content.html#check-for-drift)
`composer content:drift` compares `data/` with a checkout of the stack repos and exits 1 when they no longer agree. It takes the folder from `ADVISOR_STACK_DIR`; without it, it prints how to run it and exits 1:
```bash
ADVISOR_STACK_DIR= composer content:drift
```
It writes nothing. On drift it lists the files that moved; regenerate with `composer content:generate` and review the diff before committing. You can also pass `--check` to `content:generate` directly:
```bash
php vendor/bin/advisor content:generate --sources=/path/to/stack --check
```
That exits 1 on drift.
The GitLab job `content-drift` does the same in CI: it clones the repos listed in `data/projects.json` with the job token, puts them in one folder, sets `ADVISOR_STACK_DIR` and runs the check. It is manual or scheduled and allowed to fail, so it cannot block main. Run the drift check before every tag: a release must carry docs that still match the repos it advises on.
### The private denylist [#](https://advisor.apps.wayne.edu/docs/deploying/refreshing-the-content.html#the-private-denylist)
ADVISOR is a public repository, so the bundle must not carry internal names. The public-posture test always checks generic shapes (ADR numbers, open-question numbers, design-doc paths, the coordination repo). Private strings (hostnames, people) are loaded from the file named by `ADVISOR_PRIVATE_DENYLIST` and checked only when the file is present.
To release with the denylist:
1. Set `ADVISOR_PRIVATE_DENYLIST` to a file kept outside the repository (one literal or `regex:` pattern per line, `#` comments).
2. In GitLab CI, the file comes from a masked file-type CI variable.
3. Regenerate the bundle with the file present: `php vendor/bin/advisor content:generate --sources=/path/to/stack`.
4. Run `composer ci` to confirm the public-posture test passes.
Warning
The denylist file is never committed. The bundle is regenerated with the file present before every release.
### Related [#](https://advisor.apps.wayne.edu/docs/deploying/refreshing-the-content.html#related)
- [Releasing](https://advisor.apps.wayne.edu/docs/deploying/releasing.html)
- [Served content](https://advisor.apps.wayne.edu/docs/guides/served-content.html)
- [Commands](https://advisor.apps.wayne.edu/docs/reference/commands.html)
- [Configuration](https://advisor.apps.wayne.edu/docs/reference/configuration.html)
- [Troubleshooting](https://advisor.apps.wayne.edu/docs/troubleshooting.html)
---
Source: https://advisor.apps.wayne.edu/docs/deploying/releasing.html
## Releasing [#](https://advisor.apps.wayne.edu/docs/deploying/releasing.html#releasing)
This page gives the numbered steps for releasing ADVISOR, from the README's "Releasing" section and MAINTAINING.md.
ADVISOR is public, so its bundle must not carry internal names. The public-posture test always checks generic shapes; private strings are loaded from a denylist file named by `ADVISOR_PRIVATE_DENYLIST`, kept outside the repository (in CI, a masked file-type variable). See "Releasing" in the README.
Warning
A release needs a maintainer's approval. Never move or delete a published tag.
### Steps [#](https://advisor.apps.wayne.edu/docs/deploying/releasing.html#steps)
1. Move the lines under `## [Unreleased]` in `CHANGELOG.md` (Keep a Changelog) to a new `## [X.Y.Z] - YYYY-MM-DD` heading.
2. With the denylist file present, regenerate: `php bin/advisor content:generate --sources=`, then `composer ci` (the public-posture test must pass).
3. Both pipelines green for that commit. Run a secrets scan of the history.
4. Tag `X.Y.Z` (no `v`) on git.wayne.edu. Its push mirror carries the tag to GitHub, and Packagist picks it up from there.
5. A release needs a maintainer's approval. Never move or delete a published tag.
### The denylist [#](https://advisor.apps.wayne.edu/docs/deploying/releasing.html#the-denylist)
The public-posture test always checks generic shapes (ADR numbers, open-question numbers, design-doc paths, the coordination repo). Private strings (hostnames, people) are loaded from the file named by `ADVISOR_PRIVATE_DENYLIST` and checked only when the file is present. Set it to a file kept outside the repository (one literal or `regex:` pattern per line, `#` comments); in GitLab CI, the file comes from a masked file-type CI variable. The file is never committed. The bundle is regenerated with the file present before every release.
### Related [#](https://advisor.apps.wayne.edu/docs/deploying/releasing.html#related)
- [Proof](https://advisor.apps.wayne.edu/docs/reference/proof.html)
- [Refreshing the content](https://advisor.apps.wayne.edu/docs/deploying/refreshing-the-content.html)
- [Changelog](https://advisor.apps.wayne.edu/docs/changelog.html)
---
Source: https://advisor.apps.wayne.edu/docs/guides/claude-code.html
## One line for Claude Code [#](https://advisor.apps.wayne.edu/docs/guides/claude-code.html#one-line-for-claude-code)
This page gives the one line that connects Claude Code to ADVISOR, and the `install` command that does the same thing.
### The one line [#](https://advisor.apps.wayne.edu/docs/guides/claude-code.html#the-one-line)
If you would rather type it than generate it, this does the same as `install --client=claude --write`; project scope keeps it out of your other projects, and the same "do not commit it" warning applies:
```bash
claude mcp add --scope project advisor -e ADVISOR_ENABLED=1 -- php vendor/bin/advisor mcp
```
### The install command [#](https://advisor.apps.wayne.edu/docs/guides/claude-code.html#the-install-command)
The `install` command does the same thing and supports Claude among its clients:
```bash
php vendor/bin/advisor install [--client=claude] [--write] [--force] [--path=.]
```
`install` puts `ADVISOR_ENABLED` in the client config's env block and warns when the file is not in `.gitignore`.
### Keep it out of git [#](https://advisor.apps.wayne.edu/docs/guides/claude-code.html#keep-it-out-of-git)
Warning
Approve it by name, and review the config like code. `.mcp.json` starts a program on whoever opens the project. Keep it out of git (this repo ignores it); `advisor install` warns when you have not.
### Related [#](https://advisor.apps.wayne.edu/docs/guides/claude-code.html#related)
- [No PHP? Use Docker](https://advisor.apps.wayne.edu/docs/guides/docker.html)
- [Quick start](https://advisor.apps.wayne.edu/docs/guides/quick-start.html)
- [Install](https://advisor.apps.wayne.edu/docs/install.html)
- [Laravel apps](https://advisor.apps.wayne.edu/docs/guides/laravel.html)
---
Source: https://advisor.apps.wayne.edu/docs/guides/docker.html
## No PHP? Use Docker [#](https://advisor.apps.wayne.edu/docs/guides/docker.html#no-php-use-docker)
This page shows how to point your MCP client at Docker to run ADVISOR when PHP is not on your PATH.
### Point the client at Docker [#](https://advisor.apps.wayne.edu/docs/guides/docker.html#point-the-client-at-docker)
If PHP is not on your PATH, point the client at Docker instead. Run it from the project root, the folder that holds `vendor/`, with a hand-written `.mcp.json` like this:
```json
{
"mcpServers": {
"advisor": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"--network",
"none",
"-v",
".:/app:ro",
"-w",
"/app",
"-e",
"ADVISOR_ENABLED=1",
"-e",
"ADVISOR_PROJECT_ROOT=/app",
"-e",
"ADVISOR_GROUPS=stack",
"-e",
"ADVISOR_READ_ONLY=1",
"composer:2.11.1@sha256:8de2184c6de224f4689e8f80ed5f5edaf0030b6b8b7839a22a2bcb6722ac87d0",
"php",
"vendor/bin/advisor",
"mcp"
]
}
}
}
```
### What the config does [#](https://advisor.apps.wayne.edu/docs/guides/docker.html#what-the-config-does)
The container has no network, and the project is mounted read-only. `ADVISOR_GROUPS=stack` keeps the tools that start programs (proctor, upgrade_path) off, because those need the app's own PHP. Some clients want an absolute path in place of `.` for the mount; give them one. Advice comes in; nothing goes out.
### Where to run it [#](https://advisor.apps.wayne.edu/docs/guides/docker.html#where-to-run-it)
Run the client from the folder that holds `vendor/`. If it starts somewhere else, set `ADVISOR_PROJECT_ROOT`.
### Keep it out of git [#](https://advisor.apps.wayne.edu/docs/guides/docker.html#keep-it-out-of-git)
This file is written by hand, so keep it out of git like the generated one. `install` never replaces a different existing `advisor` entry unless you pass `--force`, keeps your other servers, and warns when the file is not in `.gitignore`.
Warning
A client config starts a program on whoever opens the project, so do not commit a generated one; this repository ignores `.mcp.json` for that reason.
### Related [#](https://advisor.apps.wayne.edu/docs/guides/docker.html#related)
- [One line for Claude Code](https://advisor.apps.wayne.edu/docs/guides/claude-code.html)
- [Quick start](https://advisor.apps.wayne.edu/docs/guides/quick-start.html)
- [Install](https://advisor.apps.wayne.edu/docs/install.html)
- [Configuration](https://advisor.apps.wayne.edu/docs/reference/configuration.html)
---
Source: https://advisor.apps.wayne.edu/docs/guides/doctor.html
## When it does not show up [#](https://advisor.apps.wayne.edu/docs/guides/doctor.html#when-it-does-not-show-up)
This page is the one to follow when you added the config, opened the project, and the `advisor` server is not in the list.
### Run the doctor [#](https://advisor.apps.wayne.edu/docs/guides/doctor.html#run-the-doctor)
```bash
php vendor/bin/advisor doctor [--json] # check the install when the server does not show up
```
It checks the six things that keep a server from appearing, in plain words, and changes nothing. `--json` prints the findings as JSON.
### What it checks [#](https://advisor.apps.wayne.edu/docs/guides/doctor.html#what-it-checks)
- **php**: the PHP on your machine satisfies ADVISOR's own `composer.json` (8.3 or newer).
- **php-path**: which `php` your client will start. Clients start `php` by name, so they get the first one on the PATH. A warning when there is none, or when it is not the PHP running doctor (then run doctor with that one too). Doctor only looks; it never runs what it finds.
- **content**: the bundled `data/` still matches its manifest.
- **client:claude**, **client:warriorgpt**, **client:cursor**, **client:vscode**: each client's MCP config: is the file there, does it have the `advisor` entry, and is the script it points at in the project? A missing file is a warning, not a failure; you only need the one client you use.
- **mcp**: the server starts. Doctor boots it in-process and asks for its tools.
- **stdio**: the real thing. Doctor starts `php vendor/bin/advisor mcp` as a child process, the way your client does, and asks it to initialize, list its tools and answer one `policy_lookup` call. Every stdout line must be protocol, and the child must exit 0 when its input closes. The pass line names your OS and PHP version, so on Windows it is the proof that stdio works there.
### Reading the result [#](https://advisor.apps.wayne.edu/docs/guides/doctor.html#reading-the-result)
A `fail` is something to fix; a `warn` is something you may not care about. The exit code is `0` when nothing failed and `1` when something did. If doctor itself cannot run, it reports a `doctor` failure and exits `2`.
### On Windows [#](https://advisor.apps.wayne.edu/docs/guides/doctor.html#on-windows)
Run the same command in PowerShell; it needs no bash or WSL:
```powershell
php vendor\bin\advisor doctor
```
A `pass` on the **stdio** line reads like `php bin/advisor mcp runs as a child process on Windows (PHP 8.4.x)`. That one line is the evidence ADVISOR's first open question asks for (does the MCP SDK's stdio work on native Windows PHP), so if you are on Windows, paste it into an issue on git.wayne.edu and you have moved the stack forward. If **php-path** warns that there is no `php` on the PATH, your client will not find PHP either: put PHP's folder on the PATH, or write the full path to `php.exe` as the `command` in the client config.
The advisor will see you now.
### Related [#](https://advisor.apps.wayne.edu/docs/guides/doctor.html#related)
- [Quick start](https://advisor.apps.wayne.edu/docs/guides/quick-start.html)
- [One line for Claude Code](https://advisor.apps.wayne.edu/docs/guides/claude-code.html)
- [No PHP? Use Docker](https://advisor.apps.wayne.edu/docs/guides/docker.html)
- [Configuration](https://advisor.apps.wayne.edu/docs/reference/configuration.html)
- [Install](https://advisor.apps.wayne.edu/docs/install.html)
---
Source: https://advisor.apps.wayne.edu/docs/guides/laravel.html
## Laravel apps [#](https://advisor.apps.wayne.edu/docs/guides/laravel.html#laravel-apps)
This page shows how ADVISOR runs inside a Laravel app, beside Laravel Boost.
### The Laravel adapter [#](https://advisor.apps.wayne.edu/docs/guides/laravel.html#the-laravel-adapter)
ADVISOR ships a Laravel adapter on `laravel/mcp`, auto-discovered by the service provider. With it, the same server runs as `php artisan mcp:start advisor`, beside Boost.
Tip
Boost knows the framework, ADVISOR knows WSU, so run both. The one place they could overlap is rules; see [Boost's project rules and CREED's rules](https://advisor.apps.wayne.edu/docs/guides/laravel.html#boost-s-project-rules-and-creed-s-rules).
### Publish the config [#](https://advisor.apps.wayne.edu/docs/guides/laravel.html#publish-the-config)
Publish the config if you want it in the app:
```
php artisan vendor:publish --tag=advisor-config
```
### Settings [#](https://advisor.apps.wayne.edu/docs/guides/laravel.html#settings)
Settings come from the same `ADVISOR_*` variables, read through `config/advisor.php`.
Warning
The same rules apply: off unless `ADVISOR_ENABLED` is set, and never in production.
### Registering the server [#](https://advisor.apps.wayne.edu/docs/guides/laravel.html#registering-the-server)
`advisor install` always writes the plain PHP command, `php vendor/bin/advisor mcp`. The artisan route, `php artisan mcp:start advisor`, is available through the service provider.
### Boost's project rules and CREED's rules [#](https://advisor.apps.wayne.edu/docs/guides/laravel.html#boost-s-project-rules-and-creed-s-rules)
Boost can keep project rules: Markdown files in `.ai/rules`, committed with the app, that an agent files through Boost's `record-rule` tool when you say "remember that...". Boost writes the index, `.ai/rules/index.md`, and its docs say to record rules with the tool, not by hand. They are a good home for one app's own decisions. They are not a home for the stack's rules.
| | CREED rules | Boost project rules |
| --- | --- | --- |
| Scope | Every WSU app on the stack | This one app |
| Written by | The stack's maintainers, in CREED's handbook | This app's team and its agents |
| Where an agent reads them | ADVISOR's `list_stack_rules`, quoted with a citation such as `creed/handbook/ci.md:5` | `.ai/rules`, through Boost's index |
| Changes when | A CREED release, picked up by `composer update` | Someone records a rule |
Three habits keep them from fighting:
- **Do not copy CREED rules into `.ai/rules`.** Two copies drift, and an agent follows whichever one it read last. If your agent offers to "remember" a stack rule, tell it to cite the rule's id from `list_stack_rules` instead.
- **A project rule adds to CREED; it never overrides it.** "Controllers in this app extend `BaseController`" is a project rule. "This app may skip the session cookie flags" is not: an exception to a CREED requirement is a question for CREED's maintainers, not a rule file.
- **When the two seem to disagree, CREED wins** and the project rule is the one to fix. Ask your agent to check a project rule against `list_stack_rules` with a `query` before you rely on it.
Note
ADVISOR never writes to `.ai/rules` (all nine tools are read-only), and it does not read them either: they are your app's, and Boost already serves them. Boost's `BOOST_RULES_ENABLED=false` turns project rules off entirely; you do not need to for ADVISOR's sake.
### Related [#](https://advisor.apps.wayne.edu/docs/guides/laravel.html#related)
- [What it offers](https://advisor.apps.wayne.edu/docs/guides/what-it-offers.html)
- [Configuration](https://advisor.apps.wayne.edu/docs/reference/configuration.html)
- [Quick start](https://advisor.apps.wayne.edu/docs/guides/quick-start.html)
- [Safety](https://advisor.apps.wayne.edu/docs/guides/safety.html)
---
Source: https://advisor.apps.wayne.edu/docs/guides/modules.html
## Modules [#](https://advisor.apps.wayne.edu/docs/guides/modules.html#modules)
This page explains how ADVISOR modules extend what it can answer and the rules that decide which modules load.
### How modules load [#](https://advisor.apps.wayne.edu/docs/guides/modules.html#how-modules-load)
Each stack project can ship its own ADVISOR tools, and Squire already does (see [Modules the stack ships](https://advisor.apps.wayne.edu/docs/guides/modules.html#modules-the-stack-ships)).
Note
Modules load only from a manifest (`modules.json`), only from the `Waynestate\` namespace, and only if they implement the `Module` interface. Nothing scans a folder.
### The manifest [#](https://advisor.apps.wayne.edu/docs/guides/modules.html#the-manifest)
The repository's own manifest is `modules.json` at the root:
```json
{
"modules": [
"Waynestate\\Advisor\\Module\\CoreModule"
]
}
```
It lists one module, `Waynestate\Advisor\Module\CoreModule`.
### An extra manifest [#](https://advisor.apps.wayne.edu/docs/guides/modules.html#an-extra-manifest)
| Variable | Default | Meaning |
| --- | --- | --- |
| `ADVISOR_MODULES_FILE` | none | An extra module manifest. |
Set `ADVISOR_MODULES_FILE` to point at an extra module manifest; its default is none. An extra manifest is held to the same rules: manifest only, the `Waynestate\` namespace, and the `Module` interface.
### Modules the stack ships [#](https://advisor.apps.wayne.edu/docs/guides/modules.html#modules-the-stack-ships)
| Project | Module class | Tools it adds | Since |
| --- | --- | --- | --- |
| Squire | `Waynestate\Squire\Advisor\SquireModule` | `squire_doctor`, `squire_drift` (both read-only) | Squire 0.5.0 |
To use one, require the project in your app, list its class in a manifest of your own, and point `ADVISOR_MODULES_FILE` at that manifest. ADVISOR reads its own `modules.json` and that one extra file, nothing else.
### Related [#](https://advisor.apps.wayne.edu/docs/guides/modules.html#related)
- [What it offers](https://advisor.apps.wayne.edu/docs/guides/what-it-offers.html)
- [Configuration](https://advisor.apps.wayne.edu/docs/reference/configuration.html)
- [Safety](https://advisor.apps.wayne.edu/docs/guides/safety.html)
- [Quick start](https://advisor.apps.wayne.edu/docs/guides/quick-start.html)
---
Source: https://advisor.apps.wayne.edu/docs/guides/quick-start.html
## Quick start [#](https://advisor.apps.wayne.edu/docs/guides/quick-start.html#quick-start)
This page takes you from a fresh install to the `advisor` server registered in your client.
1. Print the config your MCP client needs, and read it:
```bash
php vendor/bin/advisor install --client=claude
```
Expected: it prints the config your MCP client needs.
2. Write it into the project when you are happy with it:
```bash
php vendor/bin/advisor install --client=claude --write
```
Expected: it writes the config into the project.
3. Open the project in your client and approve the `advisor` server by name when it asks.
The command it registers is always the same fixed string, `php vendor/bin/advisor mcp`, with `ADVISOR_ENABLED=1` in its environment. Clients: `claude` (`.mcp.json`), `warriorgpt` (`.mcp.json`), `cursor` (`.cursor/mcp.json`), `vscode` (`.vscode/mcp.json`) and `codex` (TOML, printed only; paste it into `~/.codex/config.toml`).
### What you built [#](https://advisor.apps.wayne.edu/docs/guides/quick-start.html#what-you-built)
The `advisor` server is registered in your client, running `php vendor/bin/advisor mcp` with `ADVISOR_ENABLED=1` in its environment, and it is ready to answer questions about the stack.
### Next steps [#](https://advisor.apps.wayne.edu/docs/guides/quick-start.html#next-steps)
- [What it offers](https://advisor.apps.wayne.edu/docs/guides/what-it-offers.html): the nine read-only tools.
- [Configuration](https://advisor.apps.wayne.edu/docs/reference/configuration.html): the environment variables.
- [One line for Claude Code](https://advisor.apps.wayne.edu/docs/guides/claude-code.html): if you would rather type it than generate it.
### Related [#](https://advisor.apps.wayne.edu/docs/guides/quick-start.html#related)
- [Install](https://advisor.apps.wayne.edu/docs/install.html)
- [Overview](https://advisor.apps.wayne.edu/docs/index.html)
- [What it offers](https://advisor.apps.wayne.edu/docs/guides/what-it-offers.html)
- [Configuration](https://advisor.apps.wayne.edu/docs/reference/configuration.html)
---
Source: https://advisor.apps.wayne.edu/docs/guides/safety.html
## Safety [#](https://advisor.apps.wayne.edu/docs/guides/safety.html#safety)
This page collects the safety rules ADVISOR enforces and the settings behind them, so you know what it will and will not do.
Each control is also written up as a threat page: [prompt injection](https://advisor.apps.wayne.edu/docs/threats/prompt-injection.html), [path traversal](https://advisor.apps.wayne.edu/docs/threats/path-traversal.html), [command injection](https://advisor.apps.wayne.edu/docs/threats/command-injection.html) and [data exfiltration](https://advisor.apps.wayne.edu/docs/threats/data-exfiltration.html).
### Safety, in short [#](https://advisor.apps.wayne.edu/docs/guides/safety.html#safety-in-short)
- Off unless enabled; refuses production; refuses to start on a bad setting or a content file that fails its hash.
- Read-only by default; no tool takes a command, a URL or a free path.
- Every result is cleaned of invisible characters and labeled as data; secrets in PROCTOR output are redacted.
- `run_proctor_check` runs one fixed program with an argument array and an allowlisted environment, never a shell.
- `upgrade_path` runs Booster's read-only `plan` the same way: one fixed program, an argument array, an allowlisted command, never a shell. It plans; it never runs a hop.
- No network calls, and no model calls, from ADVISOR itself.
### Settings that enforce it [#](https://advisor.apps.wayne.edu/docs/guides/safety.html#settings-that-enforce-it)
| Variable | Default | Meaning |
| --- | --- | --- |
| `ADVISOR_READ_ONLY` | on | Set to `0` or `false` to allow tools that write. None exist yet. Read-only wins over `ADVISOR_GROUPS`. |
| `ADVISOR_ENV` | `APP_ENV`, then `local` | `production` or `prod` always refuses to start. |
| `ADVISOR_PROJECT_ROOT` | the working directory | The folder `run_proctor_check` may look inside. Paths outside it are refused. |
| `ADVISOR_AUDIT_LOG` | off | A file for a one-line-per-call audit log: time, tool, a hash of the arguments, outcome, duration. Arguments are hashed, never written. |
| `ADVISOR_GROUPS` | all | Comma list of tool groups to offer (`stack`, `proctor`, `booster`). The [What it offers](https://advisor.apps.wayne.edu/docs/guides/what-it-offers.html) page says what each group may start. |
Warning
A bad value stops the server with a message on stderr. It does not guess.
### Best practices [#](https://advisor.apps.wayne.edu/docs/guides/safety.html#best-practices)
From `BEST_PRACTICES.md`, the safety rules:
- **Run it in development only.** It refuses to start unless `ADVISOR_ENABLED` is set and refuses in production. Enforced.
- **Keep secrets out of what you ask.** Do not paste tokens into prompts. Audit logs hold hashes, never arguments, and PROCTOR output is redacted. Enforced.
- **Read-only first.** Every tool states all four hints (read-only, destructive, idempotent, open-world). A tool that writes is left out unless `ADVISOR_READ_ONLY` is turned off, and that switch beats tool groups. Enforced (contract test).
- **Narrow tools, closed schemas.** No tool takes a command, a URL or a free path. Schemas set `additionalProperties: false`, and arguments are validated again on our side. Enforced (contract test).
- **Run other programs the safe way.** Fixed program, argument array, allowlisted environment, a timeout, and no shell. Paths are resolved and must stay inside the project root. Enforced.
- **Strip invisible characters.** The TAG block, zero-width and bidirectional controls are removed from everything served and rejected in tool metadata. Enforced (contract test).
- **Serve from verified data.** Bundled content is checked against a SHA-256 manifest at start-up and in CI; a mismatch stops the server. Enforced.
### Related [#](https://advisor.apps.wayne.edu/docs/guides/safety.html#related)
- [What it offers](https://advisor.apps.wayne.edu/docs/guides/what-it-offers.html)
- [Configuration](https://advisor.apps.wayne.edu/docs/reference/configuration.html)
- [Best practices](https://advisor.apps.wayne.edu/docs/reference/best-practices.html)
- [Quick start](https://advisor.apps.wayne.edu/docs/guides/quick-start.html)
- [Install](https://advisor.apps.wayne.edu/docs/install.html)
---
Source: https://advisor.apps.wayne.edu/docs/guides/served-content.html
## Served content [#](https://advisor.apps.wayne.edu/docs/guides/served-content.html#served-content)
This page explains what content ADVISOR serves, where it comes from, and how to keep it fresh.
### What is served [#](https://advisor.apps.wayne.edu/docs/guides/served-content.html#what-is-served)
The handbook, policy, project docs, the WayneUI markup contract and WayneUI's 1.x to 2.x migration guide in `data/` are generated from the sibling stack repositories. `data/` is generated, never hand-edited: `policy.json` and `handbook/` from CREED, `projects.json` from each project repo and `generator/projects.seed.json` (state, package, version, PHP floor), plus each project's README, best practices and any extra docs its seed names.
Each project entry also carries its version when the project publishes one (composer.json, else package.json, else the newest CHANGELOG heading).
Beyond a project's README and best practices, a seed may bundle further files under `extra_docs` (a map of slug to path in the project); each lands in `data/docs//.md` and in the project's docs list, and a missing file is skipped, not an error. WayneUI's entry bundles its MIGRATING.md as the `migrating` doc.
### Verified at start-up [#](https://advisor.apps.wayne.edu/docs/guides/served-content.html#verified-at-start-up)
Content is generated by `content:generate` and verified at start-up against `data/manifest.json` (a SHA-256 for every file).
Warning
If a file does not match, the server refuses to start rather than serve it.
Files are cleaned on the way in: line endings are normalized and invisible characters (the TAG block, zero-width and bidirectional controls) are stripped. Image boilerplate is trimmed from the project docs, on the way in and again when `read_project_docs` serves them: centred hero, badge and cast blocks, lone images whose target is relative or a GIF (linked or not), and rows of nothing but badges. Prose, tables and code blocks are left alone, and the bundled file itself is never rewritten at read time, so its manifest hash still holds.
### Hand-written guides [#](https://advisor.apps.wayne.edu/docs/guides/served-content.html#hand-written-guides)
Beside the generated docs, hand-written guides are kept by hand in `generator/guides/` (one Markdown file per slug), the same way the ownership table is kept. Each is bundled into `data/guides/` and served as `advisor://guide/`; the first is "Connect to Oracle on Citadel". Edit them there, then run `content:generate`.
### Refreshing the content [#](https://advisor.apps.wayne.edu/docs/guides/served-content.html#refreshing-the-content)
To refresh it, with the stack repos checked out side by side:
```
php vendor/bin/advisor content:generate --sources=/path/to/stack
php vendor/bin/advisor content:generate --sources=/path/to/stack --check # exits 1 on drift
```
Run `content:generate` after any change that lands in CREED's policy or handbook, a project's README or best practices, an extra doc, or the projects seed. Commit the regenerated `data/` with the source commits in the message.
The generator reads each project's folder from beside the other repos, so a stale clone gives stale docs. WayneUI's development happens on its GitLab repository and the checked-out copy is only a mirror of it: fast-forward the local wayne-ui clone to that repository's main before a resync.
CI cannot see the sibling repositories, so `composer ci` runs `content:verify`, which needs none of them.
### Catching drift [#](https://advisor.apps.wayne.edu/docs/guides/served-content.html#catching-drift)
`composer content:drift` compares `data/` with a checkout of the stack repos and exits 1 when they no longer agree. It takes the folder from `ADVISOR_STACK_DIR`; without it, it prints how to run it and exits 1. It writes nothing. On drift it lists the files that moved; regenerate with `composer content:generate` and review the diff before committing.
The GitLab job `content-drift` does the same in CI: it clones the repos listed in `data/projects.json` with the job token, puts them in one folder, sets `ADVISOR_STACK_DIR` and runs the check. It is manual or scheduled and allowed to fail, so it cannot block main. Run the drift check before every tag: a release must carry docs that still match the repos it advises on.
### Related [#](https://advisor.apps.wayne.edu/docs/guides/served-content.html#related)
- [What it offers](https://advisor.apps.wayne.edu/docs/guides/what-it-offers.html)
- [Commands](https://advisor.apps.wayne.edu/docs/reference/commands.html)
- [Configuration](https://advisor.apps.wayne.edu/docs/reference/configuration.html)
- [Releasing](https://advisor.apps.wayne.edu/docs/deploying/releasing.html)
---
Source: https://advisor.apps.wayne.edu/docs/guides/what-it-offers.html
## What it offers [#](https://advisor.apps.wayne.edu/docs/guides/what-it-offers.html#what-it-offers)
ADVISOR gives a coding agent nine read-only tools, plus two prompts and three resource routes, and each answer says where it came from.
### Tools [#](https://advisor.apps.wayne.edu/docs/guides/what-it-offers.html#tools)
Nine tools, all read-only. Each one says where its answer came from:
| Tool | Does |
| --- | --- |
| `list_projects` | The stack's projects, WayneUI first, with built or proposed state, package and version. |
| `get_project_status` | One project: state, package, version, PHP constraint, its floor under today's policy, next step. |
| `read_project_docs` | A project's README, best practices, or (WayneUI only) markup contract and 1.x to 2.x migration guide, paged. |
| `policy_lookup` | Support state for a runtime or tool (and an optional version) from CREED, as of today, worked out by CREED's own reader (`waynestate/creed`), the one PROCTOR carries a copy of. A version older than every one the policy lists is answered as end of life, with a note. |
| `list_stack_rules` | CREED handbook rules, each with its file and line, filtered by app permutation, chapter and a word query (`query: "session cookie"`). |
| `owner_of` | Answers "which project owns X?" from the bundled ownership table, built from the stack's one-owner-per-rule decision first: the owner, its role, the projects around it, and the decision each answer comes from. Pass a topic or the whole question ("who owns composer audit"). |
| `playbook_lookup` | A shared value by key, or every key: an environment variable of the same name wins, then Playbook; secret-looking keys are refused. |
| `run_proctor_check` | Runs the app's own `vendor/bin/proctor check` against the bundled policy and returns the findings. |
| `upgrade_path` | Plans the app's PHP and/or Laravel upgrade, one supported hop at a time, via Booster's read-only `plan`. Inputs: from_php (the version the app runs today, when the project names none), to_php, to_laravel. |
Every tool also publishes an output schema in `tools/list`: the fields its structured answer holds, each one described, and nothing else. A client can read an answer without guessing, and the tests check every answer against its schema. The front page's field book shows a real answer from each tool.
Note
Everything ADVISOR returns is labeled as reference data. PROCTOR in CI, not ADVISOR, decides pass or fail.
### Groups [#](https://advisor.apps.wayne.edu/docs/guides/what-it-offers.html#groups)
The groups split by what they may start: `stack` never starts a program, `proctor` starts the app's own `vendor/bin/proctor`, and `booster` starts Booster's read-only `plan` (never `run`). Set `ADVISOR_GROUPS=stack` when you want ADVISOR as pure reference material.
### Resources [#](https://advisor.apps.wayne.edu/docs/guides/what-it-offers.html#resources)
| Resource | Serves |
| --- | --- |
| `advisor://policy` | CREED's policy file. |
| `advisor://creed/` | One per handbook chapter. |
| `advisor://guide/` | Hand-written guides; the first is "Connect to Oracle on Citadel". |
### Prompts [#](https://advisor.apps.wayne.edu/docs/guides/what-it-offers.html#prompts)
Prompts: `orient_me` and `plan_upgrade`.
Here is what that looks like when you ask. Each numbered control point is one of the tools above, with the arguments the front page's own route table sends:

### Related [#](https://advisor.apps.wayne.edu/docs/guides/what-it-offers.html#related)
- [Served content](https://advisor.apps.wayne.edu/docs/guides/served-content.html)
- [Configuration](https://advisor.apps.wayne.edu/docs/reference/configuration.html)
- [Safety](https://advisor.apps.wayne.edu/docs/guides/safety.html)
- [Best practices](https://advisor.apps.wayne.edu/docs/reference/best-practices.html)
- [Quick start](https://advisor.apps.wayne.edu/docs/guides/quick-start.html)
---
Source: https://advisor.apps.wayne.edu/docs/guides/where-it-sits.html
## Where it sits in WELD [#](https://advisor.apps.wayne.edu/docs/guides/where-it-sits.html#where-it-sits-in-weld)
This page shows where ADVISOR sits among the parts of the Wayne State application stack and in WELD.
### The stack and WELD [#](https://advisor.apps.wayne.edu/docs/guides/where-it-sits.html#the-stack-and-weld)
The stack is the Wayne State application stack. WELD, Wired, Everything, Linked, Deployed, is its Laravel starter app. You can add ADVISOR to a WELD app or to any other Wayne State PHP app, and in either case it is the part of the stack that talks to your coding agent.
### The parts [#](https://advisor.apps.wayne.edu/docs/guides/where-it-sits.html#the-parts)
| Part | What it is |
| --- | --- |
| **WayneUI** | interface (project 0) |
| **CREED** | version policy and written standards |
| **PROCTOR** | checks an app |
| **SESAME** | sign-in inside the app |
| **HELMET** | runtime baseline |
| **Sourdough** | starter |
| **Preflight** | CI components |
| **Pinstripe** | coding standard |
| **Booster** | upgrades |
| **Rollcall** | fleet census |
| **Drawbridge** | sign-in gateway |
| **Squire** | deploy kit |
| **Parity** | Citadel on your computer |
| **ADVISOR** | MCP server |
| **WELD** | the Laravel starter app |
### What each part is [#](https://advisor.apps.wayne.edu/docs/guides/where-it-sits.html#what-each-part-is)
ADVISOR serves a bundled copy of what these projects publish, so it works offline. Each part:
- **WayneUI** is the interface, project 0 of the stack. ADVISOR bundles its markup contract and its 1.x to 2.x migration guide.
- **CREED** is the version policy and the written standards. ADVISOR bundles its policy file and handbook, and reads the policy through CREED's own reader (`waynestate/creed`).
- **PROCTOR** checks an app.
- **SESAME** handles sign-in inside the app.
- **HELMET** is the runtime baseline.
- **Sourdough** is the starter.
- **Preflight** provides the CI components (php-test, composer-audit, proctor and a11y).
- **Pinstripe** is the coding standard; PHPStan includes its raw preset.
- **Booster** does the upgrades.
- **Rollcall** is the fleet census.
- **Drawbridge** is the sign-in gateway.
- **Squire** is the deploy kit; the front page's deploy layer is generated with it.
- **Parity** runs Citadel on your own computer: Citadel's PHP image, its proxy and MySQL 5.6, for any app, with or without Squire. It is a Go command line for every OS, on Docker or Podman (Podman recommended), and it replaces Squire's parity group. Its site is [parity.apps.wayne.edu](https://parity.apps.wayne.edu/), and its repository is [enterprise-apps/parity](https://git.wayne.edu/enterprise-apps/parity) on git.wayne.edu.
- **ADVISOR** is the MCP server, the part of the stack that talks to your coding agent.
- **WELD** is the Laravel starter app: Wired, Everything, Linked, Deployed.
Note
ADVISOR does not replace Laravel Boost. Boost knows Laravel; ADVISOR knows WSU. Run both.
### Related [#](https://advisor.apps.wayne.edu/docs/guides/where-it-sits.html#related)
- [Served content](https://advisor.apps.wayne.edu/docs/guides/served-content.html)
- [What it offers](https://advisor.apps.wayne.edu/docs/guides/what-it-offers.html)
- [Quick start](https://advisor.apps.wayne.edu/docs/guides/quick-start.html)
- [Install](https://advisor.apps.wayne.edu/docs/install.html)
---
Source: https://advisor.apps.wayne.edu/docs/
## Overview [#](https://advisor.apps.wayne.edu/docs/#overview)
**What applies, and what's next.**
This page tells you what ADVISOR is, how to run it, and where to go next.
ADVISOR is an MCP server for the Wayne State application stack, a bit like Laravel Boost but for WSU. It orients a developer who is new to the stack and gives their coding agent nine read-only tools into it: the CREED standards and policy, PROCTOR results, the upgrade path, the WayneUI markup contract and migration guide, SESAME and HELMET guidance, and the parts list. Ask it "which PHP can I build on?" and it answers from the policy file, with the date and the source, instead of from whatever the model remembers.
It is read-only. It cannot write a file, run a shell command, or call out to the network. The two things it can start are the app's own `vendor/bin/proctor` and Booster's read-only `plan`, both with a fixed argument shape.
> Every WSU student has an advisor. Now every WSU app does too, and this one answers email.
### Install and run [#](https://advisor.apps.wayne.edu/docs/#install-and-run)
Add it to the app as a dev dependency, then run it:
```bash
composer require --dev waynestate/advisor
php vendor/bin/advisor
```
The command is `php vendor/bin/advisor`. This works the same on Windows, macOS and Linux, because it is one PHP command and not a shell script.
### Pick your path [#](https://advisor.apps.wayne.edu/docs/#pick-your-path)
- [Quick start](https://advisor.apps.wayne.edu/docs/guides/quick-start.html): register the `advisor` server with your client.
- [Install](https://advisor.apps.wayne.edu/docs/install.html): what it needs and how to add it to an app.
- [What it offers](https://advisor.apps.wayne.edu/docs/guides/what-it-offers.html): the nine read-only tools.
- [Configuration](https://advisor.apps.wayne.edu/docs/reference/configuration.html): the environment variables.
### Status [#](https://advisor.apps.wayne.edu/docs/#status)
Current release 0.3.1. PHP ^8.3, license MIT, MCP SDK 0.9.0. New in 0.3.0: Parity, Citadel on your own computer, is the fifteenth part of the stack, so `list_projects`, `get_project_status`, `read_project_docs` and `owner_of` ("local development") know it; the bundle is resynced with the stack's 2026-11-09 night main branches; and CI runs on Composer 2.11.1 and Preflight 0.8.0. The [changelog](https://advisor.apps.wayne.edu/docs/changelog.html) has the full list, and [Upgrading](https://advisor.apps.wayne.edu/docs/upgrading.html) the one step it needs. Agent-ready index: [llms.txt](https://advisor.apps.wayne.edu/llms.txt).
### Related [#](https://advisor.apps.wayne.edu/docs/#related)
- [Install](https://advisor.apps.wayne.edu/docs/install.html)
- [Quick start](https://advisor.apps.wayne.edu/docs/guides/quick-start.html)
- [What it offers](https://advisor.apps.wayne.edu/docs/guides/what-it-offers.html)
- [Configuration](https://advisor.apps.wayne.edu/docs/reference/configuration.html)
---
Source: https://advisor.apps.wayne.edu/docs/install.html
## Install [#](https://advisor.apps.wayne.edu/docs/install.html#install)
This page shows what ADVISOR needs and how to add it to a Wayne State PHP app.
### Requirements [#](https://advisor.apps.wayne.edu/docs/install.html#requirements)
PHP 8.3 or newer (8.3, 8.4 and 8.5 are tested). The package requires:
- PHP `^8.3`
- extensions `ext-fileinfo`, `ext-json` and `ext-mbstring`
- `composer/semver` `^3.0`
- `mcp/sdk` `0.9.0`
- `opis/json-schema` `^2.4`
- `psr/log` `^3.0`
- `symfony/console` `^7.4 || ^8.0`
- `symfony/process` `^7.4 || ^8.0`
- `waynestate/creed` `^0.1.8` (CREED's policy reader)
The platform is pinned to PHP 8.3.0 in `composer.json`.
### Install [#](https://advisor.apps.wayne.edu/docs/install.html#install-1)
Add it to the app as a dev dependency:
```bash
composer require --dev waynestate/advisor
```
The command is then `php vendor/bin/advisor`. This works the same on Windows, macOS and Linux, because it is one PHP command and not a shell script.
ADVISOR is on Packagist: `composer require --dev waynestate/advisor:^0.3`. No extra repository needed.
Note
Native Windows is not yet proven. ADVISOR is one PHP command, so it is built to run the same everywhere, but it has not been proven on native Windows. If you are on Windows, run `php vendor\bin\advisor doctor`: its **stdio** line says whether the server works over stdio on your machine ([On Windows](https://advisor.apps.wayne.edu/docs/guides/doctor.html#on-windows)). If it fails, [use Docker](https://advisor.apps.wayne.edu/docs/guides/docker.html).
### Verify [#](https://advisor.apps.wayne.edu/docs/install.html#verify)
Check the install with:
```bash
php vendor/bin/advisor doctor
```
It checks the six things that keep a server from appearing, in plain words, and changes nothing:
- **php**: the PHP on your machine satisfies ADVISOR's own `composer.json` (8.3 or newer).
- **php-path**: which `php` your client will start. Clients start `php` by name, so they get the first one on the PATH. A warning when there is none, or when it is not the PHP running doctor (then run doctor with that one too). Doctor only looks; it never runs what it finds.
- **content**: the bundled `data/` still matches its manifest.
- **client:claude**, **client:warriorgpt**, **client:cursor**, **client:vscode**: each client's MCP config.
- **mcp**: the server starts. Doctor boots it in-process and asks for its tools.
- **stdio**: the real thing. Doctor starts `php vendor/bin/advisor mcp` as a child process, the way your client does, and asks it to initialize, list its tools and answer one `policy_lookup` call. Every stdout line must be protocol, and the child must exit 0 when its input closes. The pass line names your OS and PHP version, so on Windows it is the proof that stdio works there.
A `fail` is something to fix; a `warn` is something you may not care about. The exit code is `0` when nothing failed and `1` when something did; `--json` prints the findings as JSON.
### Next steps [#](https://advisor.apps.wayne.edu/docs/install.html#next-steps)
- [Quick start](https://advisor.apps.wayne.edu/docs/guides/quick-start.html): register the `advisor` server with a client.
- [What it offers](https://advisor.apps.wayne.edu/docs/guides/what-it-offers.html): the nine read-only tools.
- [Configuration](https://advisor.apps.wayne.edu/docs/reference/configuration.html): the environment variables.
### Related [#](https://advisor.apps.wayne.edu/docs/install.html#related)
- [Overview](https://advisor.apps.wayne.edu/docs/index.html)
- [Quick start](https://advisor.apps.wayne.edu/docs/guides/quick-start.html)
- [Configuration](https://advisor.apps.wayne.edu/docs/reference/configuration.html)
- [Commands](https://advisor.apps.wayne.edu/docs/reference/commands.html)
---
Source: https://advisor.apps.wayne.edu/docs/reference/best-practices.html
## Best practices [#](https://advisor.apps.wayne.edu/docs/reference/best-practices.html#best-practices)
These are the rules ADVISOR holds itself to, the short version for people who use ADVISOR and people who add to it, with the test that enforces each rule where there is one.
Tags: Enforced (code or CI stops the bad outcome), Documented (written down only), Not yet (a gap).
### Approve it by name, and review the config like code [#](https://advisor.apps.wayne.edu/docs/reference/best-practices.html#approve-it-by-name-and-review-the-config-like-code)
`.mcp.json` starts a program on whoever opens the project. Keep it out of git (this repo ignores it); `advisor install` warns when you have not. Enforced (warning).
### Treat answers as data [#](https://advisor.apps.wayne.edu/docs/reference/best-practices.html#treat-answers-as-data)
Every result says where it came from and that it is reference text. PROCTOR in CI decides pass or fail; ADVISOR never does. Enforced (labels), Documented (the rule).
### Run it in development only [#](https://advisor.apps.wayne.edu/docs/reference/best-practices.html#run-it-in-development-only)
It refuses to start unless `ADVISOR_ENABLED` is set and refuses in production. Enforced.
### Keep secrets out of what you ask [#](https://advisor.apps.wayne.edu/docs/reference/best-practices.html#keep-secrets-out-of-what-you-ask)
Do not paste tokens into prompts. Audit logs hold hashes, never arguments, and PROCTOR output is redacted. Enforced.
### Run Boost beside it in Laravel apps [#](https://advisor.apps.wayne.edu/docs/reference/best-practices.html#run-boost-beside-it-in-laravel-apps)
Boost knows the framework and keeps your app's own project rules, ADVISOR knows WSU. Do not copy CREED rules into Boost's `.ai/rules`: a project rule adds to CREED and never overrides it (see [Boost's project rules and CREED's rules](https://advisor.apps.wayne.edu/docs/guides/laravel.html#boost-s-project-rules-and-creed-s-rules)). Documented.
### Read-only first [#](https://advisor.apps.wayne.edu/docs/reference/best-practices.html#read-only-first)
Every tool states all four hints (read-only, destructive, idempotent, open-world). A tool that writes is left out unless `ADVISOR_READ_ONLY` is turned off, and that switch beats tool groups. Enforced (contract test).
### Narrow tools, closed schemas [#](https://advisor.apps.wayne.edu/docs/reference/best-practices.html#narrow-tools-closed-schemas)
No tool takes a command, a URL or a free path. Schemas set `additionalProperties: false`, and arguments are validated again on our side. Answers are closed too: every tool publishes an output schema with each field described, and the tests check every answer against it. Enforced (contract test).
### Run other programs the safe way [#](https://advisor.apps.wayne.edu/docs/reference/best-practices.html#run-other-programs-the-safe-way)
Fixed program, argument array, allowlisted environment, a timeout, and no shell. Paths are resolved and must stay inside the project root. Enforced.
### Keep stdout clean [#](https://advisor.apps.wayne.edu/docs/reference/best-practices.html#keep-stdout-clean)
Only protocol lines go to stdout; logs, warnings and stray output go to stderr. Enforced (subprocess test).
### Strip invisible characters [#](https://advisor.apps.wayne.edu/docs/reference/best-practices.html#strip-invisible-characters)
The TAG block, zero-width and bidirectional controls are removed from everything served and rejected in tool metadata. Enforced (contract test).
### Load modules from a manifest only [#](https://advisor.apps.wayne.edu/docs/reference/best-practices.html#load-modules-from-a-manifest-only)
From the `Waynestate\` namespace, implementing `Module`. Never scan. Enforced.
### Serve from verified data [#](https://advisor.apps.wayne.edu/docs/reference/best-practices.html#serve-from-verified-data)
Bundled content is checked against a SHA-256 manifest at start-up and in CI; a mismatch stops the server. Enforced.
### Review any change to the tool list [#](https://advisor.apps.wayne.edu/docs/reference/best-practices.html#review-any-change-to-the-tool-list)
`tools/list` is snapshotted; a changed description is a reviewed diff. Enforced (snapshot test).
### Cite sources and date [#](https://advisor.apps.wayne.edu/docs/reference/best-practices.html#cite-sources-and-date)
Policy answers carry the day they were worked out for and the file they came from. Enforced.
### Threat model [#](https://advisor.apps.wayne.edu/docs/reference/best-practices.html#threat-model)
`BEST_PRACTICES.md` carries the threat model: eleven threats, each mapped to the rules above and to OWASP Top 10:2025, OWASP ASVS 5.0 or NIST SSDF, plus what is out of scope. Four of them have a page of their own: [prompt injection](https://advisor.apps.wayne.edu/docs/threats/prompt-injection.html), [path traversal](https://advisor.apps.wayne.edu/docs/threats/path-traversal.html), [command injection](https://advisor.apps.wayne.edu/docs/threats/command-injection.html) and [data exfiltration](https://advisor.apps.wayne.edu/docs/threats/data-exfiltration.html).
### Not yet [#](https://advisor.apps.wayne.edu/docs/reference/best-practices.html#not-yet)
- A recorded green run on a native Windows PHP. The GitHub `native-os` workflow runs `advisor doctor` and the stdio tests on Windows and macOS on every push to main; this line goes when its first green run is recorded. The MCP Inspector in CI is not added (open question 7).
- Signing of any state handed back to a client (no tool needs it yet).
- A full-capture audit mode.
### Related [#](https://advisor.apps.wayne.edu/docs/reference/best-practices.html#related)
- [Proof](https://advisor.apps.wayne.edu/docs/reference/proof.html)
- [Commands](https://advisor.apps.wayne.edu/docs/reference/commands.html)
- [Safety](https://advisor.apps.wayne.edu/docs/guides/safety.html)
- [Changelog](https://advisor.apps.wayne.edu/docs/changelog.html)
---
Source: https://advisor.apps.wayne.edu/docs/reference/commands.html
## Commands [#](https://advisor.apps.wayne.edu/docs/reference/commands.html#commands)
Every command the `advisor` CLI takes, and what it does.
### Running a command [#](https://advisor.apps.wayne.edu/docs/reference/commands.html#running-a-command)
Run any command with `php vendor/bin/advisor `. This is one PHP command, not a shell script, so it works the same on Windows, macOS and Linux. The `mcp` command is started by your MCP client, not by you.
```
php vendor/bin/advisor mcp # serve over stdio (your client starts this)
php vendor/bin/advisor install [--client=claude] [--write] [--force] [--path=.]
php vendor/bin/advisor content:verify # check the bundled content against its manifest
php vendor/bin/advisor content:generate [--sources=] [--check]
php vendor/bin/advisor stack-parts [--write=] [--check=]
php vendor/bin/advisor doctor [--json] # check the install when the server does not show up
```
Stdout carries only protocol messages. Logs, warnings and stray output go to stderr, so a client never sees garbage.
### Commands [#](https://advisor.apps.wayne.edu/docs/reference/commands.html#commands-1)
| Command | What it does |
| --- | --- |
| `bin/advisor doctor` | Check the install: PHP, the PATH, the bundled content, the client config, and the server over stdio. |
| `bin/advisor install` | Print (or with --write, write) the MCP client config that starts ADVISOR. |
| `bin/advisor mcp` | Serve ADVISOR to an MCP client over stdio (started by the client, not by hand). |
| `bin/advisor stack-parts` | Render the stack parts table from the seed; write or check the marked block in a README. |
| `bin/advisor content:generate` | Rebuild the bundled content from the stack repositories (--check only compares). |
| `bin/advisor content:verify` | Check the bundled content against its manifest. |
#### `bin/advisor doctor` [#](https://advisor.apps.wayne.edu/docs/reference/commands.html#bin-advisor-doctor)
Check the install: PHP, the PATH, the bundled content, the client config, and the server over stdio.
Usage: `bin/advisor doctor [--json]`
| Option | Meaning | Default |
| --- | --- | --- |
| `--json` | Print the findings as JSON. | |
| `--silent` | Do not output any message | |
#### `bin/advisor install` [#](https://advisor.apps.wayne.edu/docs/reference/commands.html#bin-advisor-install)
Print (or with --write, write) the MCP client config that starts ADVISOR.
Usage: `bin/advisor install [-c|--client CLIENT] [--write] [--force] [--path PATH] [--runner RUNNER]`
| Option | Meaning | Default |
| --- | --- | --- |
| `-c`, `--client=VALUE` | claude, warriorgpt, cursor, vscode or codex. | `claude` |
| `--write` | Write the file in the project instead of printing it. | |
| `--force` | Replace an existing, different "advisor" entry. | |
| `--path=VALUE` | Project folder to write into. | `.` |
| `--runner=VALUE` | How to start ADVISOR: docker (inside the app container) or php (on the host). Detected from the project when omitted. | |
| `--silent` | Do not output any message | |
#### `bin/advisor mcp` [#](https://advisor.apps.wayne.edu/docs/reference/commands.html#bin-advisor-mcp)
Serve ADVISOR to an MCP client over stdio (started by the client, not by hand).
Usage: `bin/advisor mcp`
| Option | Meaning | Default |
| --- | --- | --- |
| `--silent` | Do not output any message | |
#### `bin/advisor stack-parts` [#](https://advisor.apps.wayne.edu/docs/reference/commands.html#bin-advisor-stack-parts)
Render the stack parts table from the seed; write or check the marked block in a README.
Usage: `bin/advisor stack-parts [--write WRITE] [--check CHECK]`
| Option | Meaning | Default |
| --- | --- | --- |
| `--write=VALUE` | Replace the block between the stack-parts markers in this file (repeatable) | |
| `--check=VALUE` | Exit 1 when the block in this file is stale (repeatable) | |
| `--silent` | Do not output any message | |
#### `bin/advisor content:generate` [#](https://advisor.apps.wayne.edu/docs/reference/commands.html#bin-advisor-content-generate)
Rebuild the bundled content from the stack repositories (--check only compares).
Usage: `bin/advisor content:generate [-s|--sources SOURCES] [--check]`
| Option | Meaning | Default |
| --- | --- | --- |
| `-s`, `--sources=VALUE` | Folder that holds the stack repositories (creed, proctor, wayne-ui, ...). Default: ADVISOR_STACK_DIR. | |
| `--check` | Exit 1 when the bundle differs from what the sources produce; write nothing. | |
| `--silent` | Do not output any message | |
#### `bin/advisor content:verify` [#](https://advisor.apps.wayne.edu/docs/reference/commands.html#bin-advisor-content-verify)
Check the bundled content against its manifest.
Usage: `bin/advisor content:verify`
| Option | Meaning | Default |
| --- | --- | --- |
| `--silent` | Do not output any message | |
#### Options every command accepts [#](https://advisor.apps.wayne.edu/docs/reference/commands.html#options-every-command-accepts)
| Option | Meaning | Default |
| --- | --- | --- |
| `-h`, `--help` | Display help for the given command. When no command is given display help for the list command | |
| `-q`, `--quiet` | Only errors are displayed. All other output is suppressed | |
| \`-v | -vv | -vvv`, `--verbose\` |
| `-V`, `--version` | Display this application version | |
| `--ansi` | Force (or disable --no-ansi) ANSI output | |
| `--no-ansi` | Negate the "--ansi" option | |
| `-n`, `--no-interaction` | Do not ask any interactive question | |
### Exit codes [#](https://advisor.apps.wayne.edu/docs/reference/commands.html#exit-codes)
- `content:generate --check` exits `1` on drift, when the bundled content no longer matches the source repos.
- `doctor` exits `0` when nothing failed and `1` when something did; `--json` prints the findings as JSON. If doctor itself cannot run, it reports a `doctor` failure and exits `2`.
- `composer content:drift` exits `1` when `data/` no longer matches the stack repos, or when `ADVISOR_STACK_DIR` is not set.
### Related [#](https://advisor.apps.wayne.edu/docs/reference/commands.html#related)
- [Quick start](https://advisor.apps.wayne.edu/docs/guides/quick-start.html)
- [When it does not show up](https://advisor.apps.wayne.edu/docs/guides/doctor.html)
- [Refreshing the content](https://advisor.apps.wayne.edu/docs/deploying/refreshing-the-content.html)
- [Configuration](https://advisor.apps.wayne.edu/docs/reference/configuration.html)
---
Source: https://advisor.apps.wayne.edu/docs/reference/configuration.html
## Configuration [#](https://advisor.apps.wayne.edu/docs/reference/configuration.html#configuration)
ADVISOR reads the process environment only, never a file. This page lists every variable with its default and its meaning, and the placeholders are in `.env.example`. Nothing in ADVISOR needs a secret, key, certificate, token or host, so every setting is optional.
### Environment variables [#](https://advisor.apps.wayne.edu/docs/reference/configuration.html#environment-variables)
| Variable | Meaning | Default | Read in |
| --- | --- | --- | --- |
| ADVISOR_AUDIT_LOG | A file for a one-line-per-call audit log: time, tool, a hash of the arguments, outcome, duration. Arguments are hashed, never written. | off | src/Config.php |
| ADVISOR_BOOSTER_BIN | Where `upgrade_path` finds Booster when the app has no `vendor/bin/booster` of its own: the path to booster's `bin/booster` (or a `booster.phar`). The app's own `vendor/bin/booster` always wins. | none | src/Config.php |
| ADVISOR_BOOSTER_TIMEOUT | Seconds before a Booster plan is stopped (1 to 900). A plan is local and fast, so the default is shorter than a PROCTOR run. | `60` | src/Config.php |
| ADVISOR_ENABLED | Must be `1` or `true`, or the server refuses to start. `advisor install` sets it in the client config. | off | src/Command/ClientConfig.php |
| ADVISOR_ENV | `production` or `prod` always refuses to start. | `APP_ENV`, then `local` | src/Config.php |
| ADVISOR_GROUPS | Comma list of tool groups to offer (`stack`, `proctor`, `booster`). See below for what each group may start. | all | src/Config.php |
| ADVISOR_LOG_LEVEL | Log level on stderr (`debug` to `emergency`). | `warning` | src/Config.php |
| ADVISOR_MAX_CHARS | Largest piece of text one doc call returns (1000 to 45000). | `20000` | src/Config.php |
| ADVISOR_MODULES_FILE | An extra module manifest (see "Modules"). | none | src/Config.php |
| ADVISOR_PRIVATE_DENYLIST | A file (kept outside the repo) with private strings to strip from the bundle; used by `content:generate` and the public-posture test. See "Releasing". | none | src/Content/Denylist.php |
| ADVISOR_PROCTOR_TIMEOUT | Seconds before a PROCTOR run is stopped (1 to 900). | `120` | src/Config.php |
| ADVISOR_PROJECT_ROOT | The folder `run_proctor_check` may look inside. Paths outside it are refused. | the working directory | src/Command/DoctorCommand.php |
| ADVISOR_READ_ONLY | Set to `0` or `false` to allow tools that write. None exist yet. Read-only wins over `ADVISOR_GROUPS`. | on | src/Config.php |
| ADVISOR_STACK_DIR | Folder holding the sibling stack repos; used only by `content:generate`. | none | src/Command/ContentGenerateCommand.php |
### Example [#](https://advisor.apps.wayne.edu/docs/reference/configuration.html#example)
A short example, with placeholder values:
```bash
ADVISOR_ENABLED=1
ADVISOR_ENV=local
ADVISOR_PROJECT_ROOT=/path/to/your/app
ADVISOR_AUDIT_LOG=/path/to/advisor-audit.log
```
`advisor install` sets `ADVISOR_ENABLED` in the client config for you.
Warning
A bad value stops the server with a message on stderr. It does not guess.
### Related [#](https://advisor.apps.wayne.edu/docs/reference/configuration.html#related)
- [Commands](https://advisor.apps.wayne.edu/docs/reference/commands.html)
- [Quick start](https://advisor.apps.wayne.edu/docs/guides/quick-start.html)
- [No PHP? Use Docker](https://advisor.apps.wayne.edu/docs/guides/docker.html)
- [Safety](https://advisor.apps.wayne.edu/docs/guides/safety.html)
---
Source: https://advisor.apps.wayne.edu/docs/reference/proof.html
## Proof [#](https://advisor.apps.wayne.edu/docs/reference/proof.html#proof)
This page walks through `composer ci`, the one command that proves the build, and what each step of it proves.
The same command runs on GitLab and GitHub.
### Last run [#](https://advisor.apps.wayne.edu/docs/reference/proof.html#last-run)
| Check | Date | Commit | Result | Duration |
| --- | --- | --- | --- | --- |
| `composer validate --strict` | 2026-11-09 | 7818dae | pass: `./composer.json is valid` | 1 s |
| `content:verify` | 2026-11-09 | 7818dae | pass: `data/ is sound.` | under 1 s |
| `stack-parts --check=README.md` | 2026-11-09 | 7818dae | pass: the stack-parts block is up to date in 1 file | under 1 s |
| `phpunit` | 2026-11-09 | 7818dae | pass: 282 tests, 1535 assertions, 1 skipped | 56 s |
| `pint --test` | 2026-11-09 | 7818dae | pass: 111 files | 1 s |
| `site:agent-ready-check` | 2026-11-09 | 7818dae | pass: 31 file(s) current | under 1 s |
| `phpstan analyse` | 2026-11-09 | 7818dae | pass: no errors | 2 s |
| `composer audit` | 2026-11-09 | 7818dae | pass: no security advisories | 1 s |
| `docs:check` | 2026-11-09 | 7818dae | pass: 26 page(s) current | under 1 s |
Commit 7818dae is the 0.2.0 release. The skipped test is the private half of `PublicPostureTest`, which runs only when `ADVISOR_PRIVATE_DENYLIST` is set. To refresh this table, re-run `composer ci` (or each command above) on the commit you want to record and rewrite the date, commit, results and durations. Every check this page names was run on 2026-11-09 in Docker (`composer:2.11.1`, PHP 8.5) on a copy of the tracked files; none was skipped. The proof run (`bin/proof.php`, see the README) is dev tooling outside `composer ci` and was not run: it needs a corpus of app folders and the PROCTOR and Booster binaries.
### The command [#](https://advisor.apps.wayne.edu/docs/reference/proof.html#the-command)
```
composer ci
```
No PHP on your machine? Use Docker:
```
docker run --rm -v "${PWD}:/app" -v stack-composer-cache:/tmp/cache -w /app composer:2.11.1@sha256:8de2184c6de224f4689e8f80ed5f5edaf0030b6b8b7839a22a2bcb6722ac87d0 sh -c "composer install --no-interaction && composer ci"
```
### composer validate --strict [#](https://advisor.apps.wayne.edu/docs/reference/proof.html#composer-validate-strict)
Runs `composer validate --strict` on the package metadata.
### content:verify [#](https://advisor.apps.wayne.edu/docs/reference/proof.html#content-verify)
Runs `php bin/advisor content:verify`, which checks the bundled content against its manifest. CI cannot see the sibling repositories, so `composer ci` runs `content:verify`, which needs none of them.
### stack-parts --check=README.md [#](https://advisor.apps.wayne.edu/docs/reference/proof.html#stack-parts-check-readme-md)
Runs `php bin/advisor stack-parts --check=README.md`, which proves the parts table in the README still matches `generator/projects.seed.json`.
### PHPUnit [#](https://advisor.apps.wayne.edu/docs/reference/proof.html#phpunit)
Runs `phpunit`. Tests drive the real SDK server in-process with a small MCP client, snapshot `tools/list`, and start `bin/advisor mcp` as a subprocess to prove stdout stays clean.
Tip
To accept an intended change to the tool list, run `ADVISOR_UPDATE_SNAPSHOTS=1 vendor/bin/phpunit`, then review and commit the diff.
### Pint [#](https://advisor.apps.wayne.edu/docs/reference/proof.html#pint)
Runs `pint --test`, the style check.
### site:agent-ready-check [#](https://advisor.apps.wayne.edu/docs/reference/proof.html#site-agent-ready-check)
Fails when the agent-ready files are stale, a page lacks its Markdown link, a prompt drifts from the docs, or the kit was edited here.
### PHPStan [#](https://advisor.apps.wayne.edu/docs/reference/proof.html#phpstan)
Runs `phpstan analyse --memory-limit=1G`: level 8, Pinstripe's raw preset, included from `vendor/waynestate/pinstripe`.
### composer audit [#](https://advisor.apps.wayne.edu/docs/reference/proof.html#composer-audit)
Runs `composer audit`.
### docs:check [#](https://advisor.apps.wayne.edu/docs/reference/proof.html#docs-check)
Fails when `site/docs/` is stale or a docs page has a broken link, block or nav entry.
### Related [#](https://advisor.apps.wayne.edu/docs/reference/proof.html#related)
- [Best practices](https://advisor.apps.wayne.edu/docs/reference/best-practices.html)
- [Commands](https://advisor.apps.wayne.edu/docs/reference/commands.html)
- [Releasing](https://advisor.apps.wayne.edu/docs/deploying/releasing.html)
- [Changelog](https://advisor.apps.wayne.edu/docs/changelog.html)
---
Source: https://advisor.apps.wayne.edu/docs/threats/command-injection.html
## Command injection [#](https://advisor.apps.wayne.edu/docs/threats/command-injection.html#command-injection)
An attacker who controls a tool argument wants ADVISOR to start a program or run a command the developer never approved, using the server's privileges on the developer's machine.
### Where it applies in ADVISOR [#](https://advisor.apps.wayne.edu/docs/threats/command-injection.html#where-it-applies-in-advisor)
Only two tools start a child process, and both do it on purpose:
- `run_proctor_check` starts the app's own `vendor/bin/proctor` (`src/Security/ProctorRunner.php:58-63`).
- `upgrade_path` starts Booster's `plan`, preferring the app's own `vendor/bin/booster` and falling back to the operator's configured path (`src/Security/BoosterRunner.php:96-118`).
Everything the model sends for those tools flows into the argument list of one of those two commands, so the argument list is the attack surface. No other tool starts a process; the reference tools answer from bundled files only.
The server usually runs on the developer's own machine, next to the credentials it protects, which is why no-shell matters here more than in a container.
Both tools take a few extra arguments, but each is validated against a closed set before it reaches the command: the check ids against a fixed list (`src/Security/ProctorRunner.php:46-50`), and the version targets against strict patterns (`src/Security/BoosterRunner.php:37-45`).
### What stops it [#](https://advisor.apps.wayne.edu/docs/threats/command-injection.html#what-stops-it)
- **The program is fixed, not chosen.** The binary is located only in the project's own `vendor/bin` or the operator's configured setting; nothing a model sends picks which program runs (`src/Security/ProctorRunner.php:58-63`, `src/Security/BoosterRunner.php:96-118`). The fallback path must look like a PHP script or phar before it is accepted (`src/Security/BoosterRunner.php:107-113`, `src/Security/BoosterRunner.php:121-127`).
- **The subcommand is part of the allowlist.** PROCTOR may only run `check` and Booster only `plan`; a third slot holding anything else is refused (`src/Security/CommandAllowlist.php:53`, `src/Security/CommandAllowlist.php:81`).
- **Argument array, no shell.** The process runner hands Symfony Process an argv array with no stdin, so there is no shell to interpret spaces, semicolons or quotes (`src/Security/SymfonyProcessRunner.php:30-31`).
- **The whole command shape is allowlisted.** Before anything runs, `CommandAllowlist` checks the exact shape `[php, script, subcommand, --option=value ...]`: only known options, each at most once, each value matched against a regex, and the required options present (`src/Security/CommandAllowlist.php:51-70` for PROCTOR, `src/Security/CommandAllowlist.php:79-98` for Booster; option tables at `src/Security/CommandAllowlist.php:20-26` and `src/Security/CommandAllowlist.php:35-42`). Booster's `run`, the subcommand that edits files, is deliberately absent (`src/Security/CommandAllowlist.php:28-31`).
- **The run is capped.** A timeout stops a runaway child, and its output is truncated to 2 MB before it is read (`src/Security/SymfonyProcessRunner.php:17`, `src/Security/SymfonyProcessRunner.php:39-43`).
The tests prove the refusals: another program, another script, another subcommand, an extra flag, a flag in the path slot, a bare argument, a changed format, a duplicate option, a timeout of `1;rm -rf /`, a missing policy and a single-dash option are all refused for PROCTOR (`tests/Security/CommandAllowlistTest.php:35-62`); Booster's `run` subcommand and a `--from-php=7.4;rm` value are refused the same way (`tests/Security/CommandAllowlistTest.php:83-103`). The contract test adds that no tool may be named like a shell or take a free-form command, code, sql or url argument (`tests/Contract/ServerContractTest.php:59-68`).
A reviewer can check this by reading the two bad-command providers in `tests/Security/CommandAllowlistTest.php` and running `composer test`.
### What is left [#](https://advisor.apps.wayne.edu/docs/threats/command-injection.html#what-is-left)
The allowlist pins the shape of the command; it does not audit what the child program does. PROCTOR and BOOSTER run with full access to the project folder and their own logic, so a vulnerability in either one is outside this control.
The environment handed to the child is scrubbed (see [Data exfiltration](https://advisor.apps.wayne.edu/docs/threats/data-exfiltration.html)), and the timeout caps how long it runs, but neither limit stops a well-behaved-looking program from reading files inside the project, which is what it was started to do.
A misconfigured machine can point `ADVISOR_BOOSTER_BIN` at a different PHP script; the allowlist still pins what it may be told to do, but the choice of program is then the operator's. And the allowlist is enforced inside ADVISOR, on the machine that runs it: a compromised ADVISOR install could simply stop calling it.
---
Source: https://advisor.apps.wayne.edu/docs/threats/data-exfiltration.html
## Data exfiltration [#](https://advisor.apps.wayne.edu/docs/threats/data-exfiltration.html#data-exfiltration)
An attacker wants a secret (an environment variable, a token, a key, a file's contents) to leave the machine and land somewhere the model, a log, or a report can carry it out.
### Where it applies in ADVISOR [#](https://advisor.apps.wayne.edu/docs/threats/data-exfiltration.html#where-it-applies-in-advisor)
Three channels could carry a secret out:
- The child processes behind `run_proctor_check` and `upgrade_path` inherit the server's environment, and whatever they print becomes a tool result (`src/Security/SymfonyProcessRunner.php:21-30`).
- Finding messages and plan warnings quote the project's own files (`src/Security/ProctorRunner.php:116`, `src/Security/BoosterRunner.php:209`).
- The optional audit log records every tool call (`src/Server/AuditLog.php:20-35`).
ADVISOR itself makes no network calls, so "out" means into the model's context or onto disk in a log; the client then decides what happens to that text (`docs/guides/safety.md:19`). A fourth, quieter channel is the tool descriptions and prompts the client reads before any call; they ship in the repo and are scanned for hidden characters (`tests/Contract/ServerContractTest.php:70-83`).
### What stops it [#](https://advisor.apps.wayne.edu/docs/threats/data-exfiltration.html#what-stops-it)
- **Child processes get an allowlisted environment.** Only the names in `EnvAllowlist::NAMES` survive; everything else, including the app's `.env` values, tokens and cloud keys, is removed before the process starts (`src/Security/EnvAllowlist.php:18-24`, applied at `src/Security/SymfonyProcessRunner.php:30`).
- **Secret-shaped text is redacted.** Every string that came from a child process or a project file passes through the redactor, which blanks credential-shaped `key=value` pairs, Bearer tokens, PEM private-key blocks and well-known token shapes (`src/Security/Redactor.php:16-26`, `src/Security/Redactor.php:28-41`; applied at `src/Security/ProctorRunner.php:82`, `src/Security/ProctorRunner.php:116`, `src/Security/ProctorRunner.php:142` and `src/Security/BoosterRunner.php:80`, `src/Security/BoosterRunner.php:209`).
- **Paths in results are project-relative**, so a report does not reveal where the project lives on the host (`src/Security/ProctorRunner.php:127`, `src/Security/BoosterRunner.php:140`), and the policy file is described rather than located (`src/Security/BoosterRunner.php:172-174`).
- **The audit log stores a hash of the arguments, never the arguments** (`src/Server/AuditLog.php:28`).
- **`playbook_lookup` refuses secret-looking keys.** A key ending in SECRET, PASSWORD, TOKEN or KEY is refused before any source is consulted (`src/Playbook/Settings.php:17`, `src/Playbook/Settings.php:51-55`).
- **Output is capped.** Child output beyond 2 MB is dropped before it is read, so a chatty process cannot flood the context with data (`src/Security/SymfonyProcessRunner.php:17`, `src/Security/SymfonyProcessRunner.php:39-43`).
- **The server holds no secrets of its own.** ADVISOR needs no API keys; when the optional Playbook package is present it is the only holder of shared values, and the lookup tool is the only door to it.
The tests prove the first two: `APP_KEY`, `DB_PASSWORD`, `AWS_SECRET_ACCESS_KEY` and `COMPOSER_AUTH` do not survive into a child environment while `PATH` does (`tests/Security/EnvAndRedactionTest.php:13-30`), and credential shapes plus a private-key block are blanked while plain words stay (`tests/Security/EnvAndRedactionTest.php:32-52`). The contract test keeps private-key blocks and token-shaped strings out of the repository text itself (`tests/Contract/ServerContractTest.php:101-110`).
A reviewer can check the channels by reading `tests/Security/EnvAndRedactionTest.php` and the audit-log writer, and by running `composer test`.
### What is left [#](https://advisor.apps.wayne.edu/docs/threats/data-exfiltration.html#what-is-left)
The redactor is pattern-based and blunt on purpose: a false positive costs a word, a miss costs a key (`src/Security/Redactor.php:7-11`). The patterns cover the shapes developers actually leak; they are not a general-purpose secret scanner. A secret that matches no known shape, such as an unusual variable name or a quoted value with no key, passes through.
Files inside the project root remain readable by the child programs and quotable in their output; confinement decides where, not what. The environment allowlist is a whitelist of names, not values: an allowed name such as `PATH` is passed through untouched.
Once a value reaches the model's context, the client's own logging, retention and network behavior decide the rest, which is outside ADVISOR's control. The audit log helps a developer spot an odd call after the fact, but it hashes the arguments rather than hiding them from the model, which already saw them.
---
Source: https://advisor.apps.wayne.edu/docs/threats/path-traversal.html
## Path traversal [#](https://advisor.apps.wayne.edu/docs/threats/path-traversal.html#path-traversal)
An attacker who controls a tool's path argument wants to read files outside the project: private keys, credentials, neighboring projects, or enough of the disk layout to plan a next step.
### Where it applies in ADVISOR [#](https://advisor.apps.wayne.edu/docs/threats/path-traversal.html#where-it-applies-in-advisor)
Two tools take a `path` argument, and both hand the resolved folder to a child program:
- `run_proctor_check` runs the app's own PROCTOR on the given folder; the schema says the path must be inside the project root (`src/Tools/RunProctorCheck.php:30`).
- `upgrade_path` runs Booster's read-only `plan` on the given folder, with the same constraint (`src/Tools/UpgradePath.php:31`).
Both default to the project root itself, so even a call with no arguments goes through the guard. The guard's root comes from `ADVISOR_PROJECT_ROOT` and is fixed once when the server starts (`src/Server/Runtime.php:44`); nothing a model sends can move it.
The schema caps the argument at 1024 characters, the same limit the guard enforces (`src/Tools/RunProctorCheck.php:30`, `src/Tools/UpgradePath.php:31`).
PROCTOR and BOOSTER read whatever sits under the folder they are given, so that folder is the only boundary between their file access and the rest of the machine. The other tools take no path at all: `read_project_docs` takes a project id and a document name from closed lists (`src/Tools/ReadProjectDocs.php:27-28`), and the rest take no file input.
### What stops it [#](https://advisor.apps.wayne.edu/docs/threats/path-traversal.html#what-stops-it)
- **Odd input is refused before resolution.** Empty paths, paths over 1024 characters and null bytes are rejected (`src/Security/PathGuard.php:40-42`), as are paths that start with `~` (`src/Security/PathGuard.php:43-45`).
- **Parent segments are refused outright.** Any segment equal to `..`, under forward or back slashes, ends the call (`src/Security/PathGuard.php:46-50`).
- **Resolution follows symlinks, then checks containment.** The path is resolved to its real location and must sit inside the resolved root (`src/Security/PathGuard.php:52-57`), so a symlink inside the project that points out of it fails the same way `../../` does.
- **Missing and outside get the same error**, so a refusal does not map the disk for the attacker (`src/Security/PathGuard.php:54-56`).
- **Prefix tricks fail.** Containment compares against the root plus a separator, so a sibling folder whose name merely starts with the root's is refused (`src/Security/PathGuard.php:70`), and on Windows the comparison is case-insensitive (`src/Security/PathGuard.php:65-68`).
- **Drive-letter roots are handled.** Absolute-path detection covers `/`, `\` and `C:` style roots, so a Windows absolute path cannot slip past the prefix check (`src/Security/PathGuard.php:83-86`).
- **The root itself is validated.** The constructor refuses a root that is not a directory, so the guard cannot be pointed at a file (`src/Security/PathGuard.php:21-28`).
- **Output never shows the host layout.** Paths in results are rendered relative to the project root (`src/Security/PathGuard.php:73-80`, used at `src/Security/ProctorRunner.php:127` and `src/Security/BoosterRunner.php:140`).
The tests prove each refusal: hostile paths covering `..` segments, nested and backslash parents, `~`, null bytes, absolute paths elsewhere, missing files and overlong strings (`tests/Security/PathGuardTest.php:43-63`); a same-prefix sibling folder (`tests/Security/PathGuardTest.php:65-72`); a symlink that leaves the project (`tests/Security/PathGuardTest.php:74-82`); and errors that never show the host layout (`tests/Security/PathGuardTest.php:84-92`). The contract test adds that no tool may be named like a shell command or take a free-form command, cmd, script, code, sql or url argument at all (`tests/Contract/ServerContractTest.php:59-68`).
The same two tools are the only ones that start a process; see [Command injection](https://advisor.apps.wayne.edu/docs/threats/command-injection.html) for how their argument lists are pinned.
### What is left [#](https://advisor.apps.wayne.edu/docs/threats/path-traversal.html#what-is-left)
Confinement is to the configured project root, and everything inside that root is readable by these tools by design, since they exist to inspect the app. The guard checks the path once per call; a symlink swapped in after the check, before PROCTOR or BOOSTER reads the file, is not caught, and a path that moves out later (a bind mount, a moved volume) is outside the guard's view.
The guard also trusts the root it is given (`src/Security/PathGuard.php:21-28`): pointing `ADVISOR_PROJECT_ROOT` at a wide folder is an operator decision, and the guard will faithfully confine to it. Because the child programs run with normal file access inside the root, the guard decides where they may look, not what they may do with what they find.
---
Source: https://advisor.apps.wayne.edu/docs/threats/prompt-injection.html
## Prompt injection [#](https://advisor.apps.wayne.edu/docs/threats/prompt-injection.html#prompt-injection)
An attacker who controls some of the text ADVISOR serves wants the model reading that text to follow hidden instructions, leak data, or trust a false answer.
### Where it applies in ADVISOR [#](https://advisor.apps.wayne.edu/docs/threats/prompt-injection.html#where-it-applies-in-advisor)
Every tool result is plain text that lands in the client model's context, so anything ADVISOR serves is a possible carrier for instructions aimed at the model:
- `read_project_docs` serves bundled READMEs, best-practices guides and migration notes from the stack repositories (`src/Tools/ReadProjectDocs.php:23`).
- `list_stack_rules` serves CREED handbook text, rule by rule (`src/Tools/ListStackRules.php:90-99`).
- `run_proctor_check` returns finding messages that quote the project's own files (`src/Security/ProctorRunner.php:116`).
- `upgrade_path` returns plan steps and warnings that come from the app's manifests (`src/Security/BoosterRunner.php:209`).
- Tool descriptions, resources and prompts are also text the client reads before any call is made.
The interesting cases are the ones the developer never typed: a document shipped in a stack repository, or a file inside the project that PROCTOR quotes back. Both reach the model inside an answer that looks like a trusted reference, which is exactly what makes them persuasive. The resources (the policy feed, the CREED chapter feeds and the guide feeds) serve the same hash-pinned content as the tools (`src/Module/CoreModule.php:52-83`).
### What stops it [#](https://advisor.apps.wayne.edu/docs/threats/prompt-injection.html#what-stops-it)
- **Answers are labeled as data.** Every result carries its `source` and a `generated_on` date, and the docs tool says outright that the text is reference material, not instructions (`src/Tools/ReadProjectDocs.php:63-64`, `src/Tools/ReadProjectDocs.php:68`). The rules tool repeats the point (`src/Tools/ListStackRules.php:97`).
- **Decisions stay with PROCTOR.** PROCTOR reports say PROCTOR in CI decides pass or fail (`src/Security/ProctorRunner.php:131`), and Booster plans say they change nothing (`src/Security/BoosterRunner.php:180`), so a served answer cannot claim authority it does not have.
- **Invisible characters are stripped and rejected.** Zero-width, bidirectional and TAG-block controls can hide instructions from a human reviewer. They are removed from child-process output before it is served (`src/Security/ProctorRunner.php:82`, `src/Security/BoosterRunner.php:209`) and refused in bundled content at start-up (`src/Content/ContentBundle.php:98-101`).
- **The published surface is scanned.** Tools, resources and prompts are checked for hidden characters on every test run (`tests/Contract/ServerContractTest.php:70-79`), as are the shipped prompt files themselves (`tests/Contract/ServerContractTest.php:80-82`).
- **Bundled content is hash-pinned.** Every file under `data/` must match its SHA-256 manifest hash or the server throws at start-up (`src/Content/ContentBundle.php:51-58`, `src/Content/ContentBundle.php:95-97`), so a served document cannot change between release and use.
- **Tool metadata is snapshotted.** A quiet change to a tool name or description (tool poisoning) fails the snapshot test instead of shipping unnoticed (`tests/Server/McpServerTest.php:121-138`).
- **ADVISOR talks to no one.** It makes no network calls and no model calls of its own (`docs/guides/safety.md:19`), so there is no second channel for served text to act through.
The layers are deliberate: labeling tells the model what the text is, pinning keeps it stable, stripping removes the hidden channels, and the snapshot test makes quiet changes loud.
A reviewer can check these controls without trusting this page: read the `notice` fields above, run `composer ci` (the contract and snapshot tests are part of it), and diff `tools/list` against the committed snapshot.
### What is left [#](https://advisor.apps.wayne.edu/docs/threats/prompt-injection.html#what-is-left)
Labels reduce the risk, but they do not make injected instructions inert. A client model can still be fooled by text it reads, especially text that quotes the project's own files in the middle of a plausible report, and ADVISOR's job is to make sure that text is labeled, pinned and clean, not to guarantee the model will ignore it.
Hash pinning guarantees the text is what was released, not that it is harmless: a compromised upstream repository could ship a malicious document, and the manifest would bless it. Stripping invisible characters catches the sneaky encodings, not the plain-language ones. Nothing in ADVISOR can tell a well-written instruction from a well-written report. The client's own defenses, and the developer's review of what the model does with the text, are the last line.
---
Source: https://advisor.apps.wayne.edu/docs/troubleshooting.html
## Troubleshooting [#](https://advisor.apps.wayne.edu/docs/troubleshooting.html#troubleshooting)
This page lists the failure symptoms ADVISOR's own docs describe, with the cause, the fix and the command that checks it.
### The advisor server is not in the list [#](https://advisor.apps.wayne.edu/docs/troubleshooting.html#the-advisor-server-is-not-in-the-list)
You added the config, opened the project, and the `advisor` server is not in the list.
**Cause.** One of six things keeps a server from appearing:
- **php**: the PHP on your machine satisfies ADVISOR's own `composer.json` (8.3 or newer).
- **php-path**: which `php` your client will start. Clients start `php` by name, so they get the first one on the PATH. A warning when there is none, or when it is not the PHP running doctor (then run doctor with that one too). Doctor only looks; it never runs what it finds.
- **content**: the bundled `data/` still matches its manifest.
- **client:claude**, **client:warriorgpt**, **client:cursor**, **client:vscode**: each client's MCP config: is the file there, does it have the `advisor` entry, and is the script it points at in the project? A missing file is a warning, not a failure; you only need the one client you use.
- **mcp**: the server starts. Doctor boots it in-process and asks for its tools.
- **stdio**: the real thing. Doctor starts `php vendor/bin/advisor mcp` as a child process, the way your client does, and asks it to initialize, list its tools and answer one `policy_lookup` call. Every stdout line must be protocol, and the child must exit 0 when its input closes. The pass line names your OS and PHP version, so on Windows it is the proof that stdio works there.
**Fix.** Run doctor and fix anything it reports as a `fail`. A `fail` is something to fix; a `warn` is something you may not care about.
**Check.**
```bash
php vendor/bin/advisor doctor
```
The exit code is `0` when nothing failed and `1` when something did; `--json` prints the findings as JSON.
### The server refuses to start because it is not enabled [#](https://advisor.apps.wayne.edu/docs/troubleshooting.html#the-server-refuses-to-start-because-it-is-not-enabled)
**Cause.** `ADVISOR_ENABLED` defaults to off. It must be `1` or `true`, or the server refuses to start.
**Fix.** Set `ADVISOR_ENABLED=1` in the client config's environment. `advisor install` sets it in the client config.
**Check.**
```bash
php vendor/bin/advisor doctor
```
### The server refuses to start in production [#](https://advisor.apps.wayne.edu/docs/troubleshooting.html#the-server-refuses-to-start-in-production)
**Cause.** `ADVISOR_ENV` reads `APP_ENV`, then `local`. `production` or `prod` always refuses to start.
**Fix.** Run ADVISOR in development only. It refuses to start in production by design.
**Check.**
```bash
php vendor/bin/advisor doctor
```
### A bad setting stops the server [#](https://advisor.apps.wayne.edu/docs/troubleshooting.html#a-bad-setting-stops-the-server)
**Cause.** A bad value stops the server with a message on stderr. It does not guess.
**Fix.** Read the message on stderr and correct the value. ADVISOR reads the process environment only, never a file.
**Check.**
```bash
php vendor/bin/advisor doctor
```
### The server refuses to start because a content file fails its hash [#](https://advisor.apps.wayne.edu/docs/troubleshooting.html#the-server-refuses-to-start-because-a-content-file-fails-its-hash)
**Cause.** The bundled `data/` is verified at start-up against `data/manifest.json` (a SHA-256 for every file). If a file does not match, the server refuses to start rather than serve it.
**Fix.** Regenerate the bundle from the sibling stack repositories with `content:generate`, then verify it.
**Check.**
```bash
php vendor/bin/advisor content:verify
```
### Related [#](https://advisor.apps.wayne.edu/docs/troubleshooting.html#related)
- [When it does not show up](https://advisor.apps.wayne.edu/docs/guides/doctor.html)
- [Configuration](https://advisor.apps.wayne.edu/docs/reference/configuration.html)
- [Commands](https://advisor.apps.wayne.edu/docs/reference/commands.html)
- [Served content](https://advisor.apps.wayne.edu/docs/guides/served-content.html)
- [Refreshing the content](https://advisor.apps.wayne.edu/docs/deploying/refreshing-the-content.html)
- [Install](https://advisor.apps.wayne.edu/docs/install.html)
---
Source: https://advisor.apps.wayne.edu/docs/upgrading.html
## Upgrading [#](https://advisor.apps.wayne.edu/docs/upgrading.html#upgrading)
This page walks through each released version of ADVISOR and what changed, so you can see whether a new version affects your app.
### \[0.3.0\] - 2026-11-09 [#](https://advisor.apps.wayne.edu/docs/upgrading.html#0-3-0-2026-11-09)
A new minor line, so a `^0.2` constraint does not pick it up: move to `composer require --dev waynestate/advisor:^0.3`. No code in your app changes; the MCP server reports version 0.3.0.
- The parts list has fifteen projects: Parity, Citadel on your own computer, comes after Squire. `get_project_status` and `read_project_docs` take `parity`, so an agent that validates project ids against the tool's enum sees one more.
- `owner_of` answers "local development" with Parity, and the deploy-files row no longer lists the parity kit under Squire.
- A project whose `CHANGELOG.md` heading says unreleased no longer shows that number as its version, and a Go module counts as built.
- The bundled data is resynced with the stack's 2026-11-09 night main branches, and the front page deploy layer runs Squire's kit 0.10.2 with CREED ^0.1.8 and HELMET ^1.3.
### \[0.2.0\] - 2026-11-09 [#](https://advisor.apps.wayne.edu/docs/upgrading.html#0-2-0-2026-11-09)
A new minor line, so a `^0.1` constraint does not pick it up: move to `composer require --dev waynestate/advisor:^0.2`. ADVISOR now requires `waynestate/creed` (^0.1.8); if your app locks an older CREED (PROCTOR brings one), let Composer move it too with `composer update waynestate/advisor --with-dependencies`. The MCP server reports version 0.2.0.
- `policy_lookup` and `get_project_status` answer through CREED's own reader, so they say exactly what PROCTOR decides. A line the policy marks current (Vue 3, Inertia 2 and 3) now reads `active` instead of having no state, and a version older than every line the policy lists is answered as end of life with a note instead of being refused.
- `upgrade_path` takes `from_php`, for a project whose `composer.json` names no PHP constraint (Booster's `--from-php`).
- Only for module authors: `ContentBundle::policy()` returns CREED's `Waynestate\Creed\Policy`, `Content\PolicyReader` only checks the schema version, and `Content\State` is gone (use `Waynestate\Creed\State`). Squire's module (`Waynestate\Squire\Advisor\SquireModule`) uses none of these.
- The bundled data is resynced with the stack's 2026-11-09 main branches, the docs gain four threat pages, and the front page deploy layer runs Squire's kit 0.10.1 with HELMET ^1.0 and PROCTOR ^0.11.
### \[0.1.7\] - 2026-11-07 [#](https://advisor.apps.wayne.edu/docs/upgrading.html#0-1-7-2026-11-07)
No breaking changes are marked for this release. Update with `composer update waynestate/advisor`; the MCP server reports version 0.1.7.
- `owner_of` answers from an ownership table rebuilt from the stack's decisions, and `read_project_docs` trims image boilerplate at read time as well.
- The bundled data is resynced with the stack's 2026-11-07 releases, and the canonical repository is git.wayne.edu.
### \[0.1.6\] - 2026-11-06 [#](https://advisor.apps.wayne.edu/docs/upgrading.html#0-1-6-2026-11-06)
No breaking changes are marked for this release. Update with `composer update waynestate/advisor`; the MCP server reports version 0.1.6.
- symfony/console and symfony/process accept ^8.0 as well as ^7.4, so apps on Pest 5 / PHPUnit 13 can install ADVISOR.
- The bundled data is resynced with the stack's main branches through the evening of 2026-11-06, including Booster 1.9.0, WELD 0.1.3, the accessibility gates across the stack and the Sourdough raw PHP + Vue shape.
- A docs site built from `docs/` is added and checked in `composer ci`, and the front page and docs pass an accessibility gate. The proof runner is dev tooling and is not part of the served product.
### \[0.1.5\] - 2026-11-03 [#](https://advisor.apps.wayne.edu/docs/upgrading.html#0-1-5-2026-11-03)
No breaking changes are marked for this release.
- The deploy layer requires HELMET ^0.3 and PROCTOR ^0.4 (locked at 0.3.0 and 0.4.0) and sets minimum-stability to stable, which clears PROCTOR 0.4's new minimum-stability warning. HELMET 0.3 reads an empty `HELMET_PROXIES=` as trust nobody; the front page sets only the `citadel` preset, so nothing changes for it.
- The deploy layer's Squire kit is refreshed to 0.5.0 (updated `base-fallback.Dockerfile`, `scripts/release.sh` and `scripts/parity.ps1`).
- The bundled data is resynced with the 2026-11-03 releases: Booster 1.8.0, Preflight 0.1.4, PROCTOR 0.4.0, Pinstripe 0.1.2, CREED 0.1.6, Rollcall 0.1.9, HELMET 0.3.0, SESAME 0.4.0, Drawbridge 0.1.1, Sourdough 0.1.5, Squire 0.5.0 and WELD 0.1.2, and with each project's main since the last pass.
- One Playbook settings resolver (`Waynestate\Advisor\Playbook\Settings`, ADR-0018) is added. `playbook_lookup` now answers from `.env.playbook` when the package is not installed (same output shape).
- `.env.playbook` is git-ignored; the agent-ready files (`site/llms.txt`, `site/llms-full.txt`) are regenerated.
- Docs and package metadata name nougat as the canonical repository, with git.wayne.edu and GitHub as read-only mirrors, until git.wayne.edu has CI runners.
### \[0.1.4\] - 2026-11-03 [#](https://advisor.apps.wayne.edu/docs/upgrading.html#0-1-4-2026-11-03)
No breaking changes are marked for this release.
- CI pulls its Docker Hub images through the GitLab Dependency Proxy (the group's CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX), so pipelines no longer hit Docker Hub's anonymous pull limit.
### \[0.1.3\] - 2026-11-02 [#](https://advisor.apps.wayne.edu/docs/upgrading.html#0-1-3-2026-11-02)
No breaking changes are marked for this release.
- Hand-written guides are bundled from `generator/guides/` and served as `advisor://guide/`; the first guide is "Connect to Oracle on Citadel".
- `policy_lookup` returns `latest_patch`; the bundled docs drop hero images, badges and GIFs.
- WayneUI's migration guide (MIGRATING.md) is bundled as the `migrating` doc, and every project entry carries its version when it publishes one (composer.json, else package.json, else the newest CHANGELOG heading).
- A one-line `claude mcp add` and a Docker `.mcp.json` for machines without PHP are documented.
- `composer content:drift` and an optional CI job fail when `data/` no longer matches the sibling repos.
- The deploy layer's Squire kit is refreshed to 0.3.4 (the local `.env.squire` file is now git-ignored).
### \[0.1.2\] - 2026-10-29 [#](https://advisor.apps.wayne.edu/docs/upgrading.html#0-1-2-2026-10-29)
No breaking changes are marked for this release.
- An agent-ready site (prompt blocks, Markdown twins, llms.txt) is added from Squire's kit.
- The `playbook_lookup` tool answers "what is the value of X?" for WSU shared values. An environment variable of the same name wins, then the private `waynestate/playbook` package (Playbook) supplies the rest; without it the tool says how to get it instead of failing. Keys that look like secrets (ending in SECRET, PASSWORD, TOKEN or KEY) are refused. `waynestate/playbook` is suggested, never required.
- Docs copies are resynced; proof results now live on the proof site.
- Project names are written as words except acronyms.
- Stale capability claims in the site and docs are fixed.
### \[0.1.1\] - 2026-10-29 [#](https://advisor.apps.wayne.edu/docs/upgrading.html#0-1-1-2026-10-29)
No breaking changes are marked for this release.
- The `owner_of` tool answers "which project owns X?" from a new bundled `data/ownership.json` table (sourced from `generator/ownership.json`, verified by `content:verify`). Fuzzy match: every word of the topic must appear in a row's topic or role; a no-match answer lists every known topic.
- `upgrade_path` moves from the `stack` group to a new `booster` group, so `ADVISOR_GROUPS=stack` offers reference tools only and never starts a program. `ADVISOR_GROUPS` now accepts `stack`, `proctor` and `booster`.
- PHPStan includes Pinstripe's `raw.neon` preset (`waynestate/pinstripe` 0.1.0 as a dev dependency) instead of a hand copy of its settings; two docblocks were tightened to satisfy the preset's method-signature checks. Pint already used the `per` preset, so `pint.json` is unchanged.
### \[0.1.0\] - 2026-10-29 [#](https://advisor.apps.wayne.edu/docs/upgrading.html#0-1-0-2026-10-29)
This is the first release, so there is nothing to break.
- Read-only MCP server over stdio (`php vendor/bin/advisor mcp`) on the official `mcp/sdk` 0.9.0, speaking both the legacy `initialize` handshake and the 2026-07-28 per-request form.
- Seven tools: `list_projects`, `get_project_status`, `read_project_docs`, `policy_lookup`, `list_stack_rules`, `run_proctor_check`, `upgrade_path`. Resources `advisor://policy` and `advisor://creed/`. Prompts `orient_me` and `plan_upgrade`.
- `upgrade_path` plans the app's PHP and/or Laravel upgrade, one supported hop at a time, by running Booster's read-only `plan` (never `run`) against the bundled policy. New settings `ADVISOR_BOOSTER_TIMEOUT` (default 60) and `ADVISOR_BOOSTER_BIN` (fallback when the app has no `vendor/bin/booster` of its own).
- Bundled, hash-verified content (CREED handbook and policy, project docs, the WayneUI markup contract) with a generator, `content:generate --check` and `content:verify`.
- `advisor install` for Claude, WarriorGPT, Cursor, VS Code (written) and Codex (printed).
- Laravel adapter on `laravel/mcp` (`php artisan mcp:start advisor`), so ADVISOR runs beside Laravel Boost.
- Safety: off unless enabled, refuses production, read-only by default, path confinement, allowlisted child environment, redaction, invisible-character stripping, manifest-only module loading, argument-hash audit log.
- `composer ci`: validate, content verify, PHPUnit, Pint, PHPStan level 8 (Pinstripe settings), audit. CI files for GitLab (Preflight 0.1.0) and GitHub.
### Taking a new version [#](https://advisor.apps.wayne.edu/docs/upgrading.html#taking-a-new-version)
ADVISOR is on Packagist: `composer require --dev waynestate/advisor:^0.3`. No extra repository needed.
The command is then `php vendor/bin/advisor`. This works the same on Windows, macOS and Linux, because it is one PHP command and not a shell script.
### Related [#](https://advisor.apps.wayne.edu/docs/upgrading.html#related)
- [Install](https://advisor.apps.wayne.edu/docs/install.html)
- [Changelog](https://advisor.apps.wayne.edu/docs/changelog.html)
- [Releasing](https://advisor.apps.wayne.edu/docs/deploying/releasing.html)
- [Refreshing the content](https://advisor.apps.wayne.edu/docs/deploying/refreshing-the-content.html)