@reticlehq/server 3.8.2 → 3.10.0

package/docs/cli/stop.mdx

@@ -10,7 +10,7 @@ icon: circle-stop
 npx @reticlehq/server stop [--port N] [--quiet] [--force]
 ```
 
-`reticle kill` is the old name for `stop --force`. It still works for one release and prints one line naming the new spelling.
+`reticle kill` was removed. It prints that `stop --force` replaces it and exits `1`.
 
 ## Flags
 
@@ -94,7 +94,7 @@ Killed:
 Refused, because the listener is not ours. This one was captured with `python3 -m http.server 4498` holding the port:
 
 ```
-{"t":"2026-08-15T18:43:57.128Z","event":"reticle_kill_refused","port":4498,"reason":"pid 78795 (\"Python\") is listening, and it is not a Reticle daemon ... it never answered /status and it is not the pid Reticle recorded. Killing it would be killing someone else's process. If that is what you meant, `reticle restart --force` stops it and starts Reticle there (`stop --force` never does); or start Reticle on another port.","holder":"Python"}
+{"t":"2026-08-15T18:43:57.128Z","event":"reticle_kill_refused","port":4498,"reason":"pid 78795 (\"Python\") is listening, and it is not a Reticle daemon ... it never answered /status and it is not the pid Reticle recorded. Killing it would be killing someone else's process. If that is what you meant, `reticle serve --restart --force` stops it and starts Reticle there (`stop --force` never does); or start Reticle on another port.","holder":"Python"}
 ```
 
 Nothing to free:
@@ -118,6 +118,6 @@ With `--force`, exit `0` means the port is free and `1` means it is still held:
 
 ```bash
 npx @reticlehq/server stop --port 4400 --quiet && npx @reticlehq/server serve --port 4400
-npx @reticlehq/server restart --port 4400   # the same thing, honest about each half
+npx @reticlehq/server serve --restart --port 4400   # the same thing, honest about each half
 npx @reticlehq/server stop --force          # the port is held and the pid file says nothing
 ```

package/docs/cli/update.mdx

@@ -61,6 +61,6 @@ npx @reticlehq/server update
 <Warning>
   A daemon that is already running keeps its own version. When no tab and no other agent is attached
   to it, your agent's new MCP server stops it and starts the new version. When a tab or another
-  agent is attached, the old daemon keeps running. Run [`reticle restart`](/cli/restart) to start
-  the new version now.
+  agent is attached, the old daemon keeps running. Run [`reticle serve --restart`](/cli/restart) to
+  start the new version now.
 </Warning>

package/docs/cli/verify.mdx

@@ -20,12 +20,13 @@ It uses the same runner and the same verdict as the MCP and HTTP paths, so a pla
 | `--headed` | boolean | `false` (headless) | Show the browser |
 | `--timeout N` | number, ms | `15000` | How long to wait for a browser session to dial back. With `--expect`, how long the predicate may take to come true instead, default `4000` |
 | `--storage-state <file>` | string | unset | A Playwright storage state file. This is how you verify flows behind a login without scripting the login every time |
-| `--results-json <file>` | string | unset | Also write one verdict per journey to this file: `{ verdict, results: [{ journey, verdict, reason?, runId? }] }`, each verdict `yes`, `no` or `unknown`. A skipped journey is `unknown`, and the run is `yes` only when every journey is. `runId` names the run the journey came from, and is set only when that run reached the platform. Written when verify boots its own browser and a run finishes; a refusal before that writes nothing. The [GitHub Action](https://github.com/reticlehq/reticle/tree/main/action) posts this file |
+| `--results-json <file>` | string | unset | Also write one verdict per journey to this file: `{ schemaVersion, verdict, results: [{ journey, verdict, reason?, runId?, steps }], score }`, each verdict `yes`, `no` or `unknown`. `schemaVersion` is 2 (a file without it has only `verdict` and `results`). `steps` is `{ passed, failed, unknown }` for the journey, and `score` is the total with `value` = passed / total. A step counts only when every earlier step of its journey passed; a step never reached is `unknown` and stays in the total. With `--sweep`, verdicts after a failed step are reported apart as `steps.swept` and never raise the score. A skipped journey is `unknown`, and the run is `yes` only when every journey is. `runId` names the run the journey came from, and is set only when that run reached the platform. Written when verify boots its own browser and a run finishes; a refusal before that writes nothing. The [GitHub Action](https://github.com/reticlehq/reticle/tree/main/action) posts this file |
 | `--port N` | number | `RETICLE_PORT`, else the project's port, else `4400` | The bridge port the app dials |
 | `--session-id <id>` | string | unset | Use a tab that is already connected |
 | `--select <label>` | string, repeatable | unset | Verify only flows carrying this label |
 | `--expect '<json predicate>'` / `--expect-file <path>` | string | unset | One verdict on one predicate, no saved flows needed. Asks the daemon that owns the port and never starts one; with no daemon it refuses. Waits up to `--timeout` for the predicate, the way `reticle_assert { action: "wait" }` does, so a request still in flight after the page loads is waited for. Exits `0` only on `verified: "yes"`. Cannot be combined with `--storage-state` |
 | `--explore` / `--persona "<who does what>"` | boolean / string | off | No saved flows yet? The Harness drives the app and records them. `--persona` implies `--explore`. Needs a linked project (`reticle connect`, or `RETICLE_API_KEY` in CI). It runs at any instrumentation score |
+| `--against <reference-url>` | string | unset | Compare the URL with a reference build, for example a pull request preview with production. See [Compare two builds](#compare-two-builds). Cannot be combined with `--expect`, `--expect-file`, `--explore` or `--persona` |
 | `--confirm-dangerous` | boolean | off | Let this run press the controls the replay guard holds as destructive, such as a "Place order" or "Delete" button in a saved flow. Without it such a step is refused, so a checkout flow cannot pass. It covers this run only and is never saved into a flow. |
 
 On Windows PowerShell, write the predicate to a file and pass `--expect-file` so the JSON never goes through shell quoting:
@@ -35,6 +36,27 @@ On Windows PowerShell, write the predicate to a file and pass `--expect-file` so
 npx @reticlehq/server verify http://localhost:3000 --expect-file expect.json
 ```
 
+## Compare two builds
+
+```bash
+npx @reticlehq/server verify https://pr-42.preview.example.com --against https://example.com
+```
+
+`--against` answers one question: did the change alter what users see? It drives both running builds with the same actions and reports each difference in what a person can read and use.
+
+- **The actions.** Each saved flow in `.reticle/flows/` (with `--select`, only the flows with those labels) is replayed one step at a time, and the page is read after every step. Then the explorer of `reticle_verify { action: "crawl", exhaustive: true }` walks the reference breadth first. It fills each empty text field with its own value (`text 1`, `text 2`), clicks each control, and waits a short time after each action. Both builds then get the same list of actions.
+- **What is compared.** The accessibility tree, reduced to what a person sees: names, text, values, and the checked, selected, disabled, expanded and pressed states, in page order. Case and spacing are folded. Refs, focus, layout, test ids, source locations and component names are removed.
+- **Noise.** The reference is driven two times, each time in a new browser. A line that differs between those two runs (a clock, a random id) is ignored. A step that the reference did on only one of its runs is not compared.
+- **A step the candidate cannot do.** When the reference did a step and the candidate could not (the control is gone, or a flow anchor does not resolve), that is a difference.
+
+The command uses the daemon on `--port`, and starts one when there is none. Each run is a leased browser tab, so the apps do not need `reticle init`. Each replayed flow step is written as a run, the same as any replay.
+
+The explorer clicks every control it finds. The action guard refuses a control it holds as destructive, and `--confirm-dangerous` removes that guard. Point `--against` at a build whose data you can change, not at a production database.
+
+Each difference prints the actions that first reached it, then `-` for the lines only the reference shows and `+` for the lines only the candidate shows. Differences with the same lines are printed one time, with the number of steps they were seen at. Exit `0` only when steps were compared and nothing differs. A run that compared no step exits `1`, because it proved nothing.
+
+`--results-json <file>` writes `{ schemaVersion: 1, reference, candidate, identical, differences: [{ id, kind, actions, removed, added, seen }], journeys, compared, unstable, ignored, explored }`. `kind` is `changed` or `unreached`. `id` is a hash of the difference's lines, so the same difference has the same id on every run. `ignored` counts the lines skipped as noise, and `unstable` counts the steps not compared.
+
 ## What it prints
 
 The rendered run report on stdout. On failure it names the cause on stderr instead, and there are two refusals worth knowing:

package/docs/cli.mdx

@@ -41,18 +41,20 @@ npx @reticlehq/server <command>
 | Command | What it does | Page |
 | --- | --- | --- |
 | `reticle verify <url>` | One-shot: drive the URL, verify saved flows or one predicate, exit 0 on pass | [verify](/cli/verify) |
+| `reticle compare <reference-url> <candidate-url> [--base <url>] [--state <file>] [--json] [--report <file>]` | Drive two running builds the same way and list each difference in what users see; exit 0 same, 1 different, 2 invalid | [compare](/cli/compare) |
+| `reticle grade <snapshot\|judge\|tables\|suggest> [flags]` | Grade a finished run of an app from snapshots of its stored data, and check its final answer; exit 0 pass, 1 fail, 2 unverified | [grade](/cli/grade) |
 | `reticle gate [--since <ref>] [--accept-coverage] [--hook]` | Exit non-zero unless passing artifacts cover the affected flows | [gate](/cli/gate) |
+| `reticle gate --list [--since <ref>]` | Which saved flows must re-verify for the changed files | [affected](/cli/affected) |
 
 ### Reticle on this machine
 
 | Command | What it does | Page |
 | --- | --- | --- |
-| `reticle status [--json]` | Is the daemon up, which pages connected, who is signed in, is this repo linked | [status](/cli/status) |
+| `reticle status [--json]` | Is the daemon up, which pages connected, who is signed in, is this repo linked, which license is active | [status](/cli/status) |
 | `reticle doctor` | Find what is wrong with the setup (Chromium, daemon, port, agent link), and what is missing from coverage | [doctor](/cli/doctor) |
 | `reticle open [url]` | Show the app: reuse the connected tab, else open one | [open](/cli/open) |
 | `reticle stop [--force]` | Stop the daemon we started; `--force` frees the port by its listener, never the agent's MCP proxy | [stop](/cli/stop) |
-| `reticle restart` | Free the port, then start a daemon and wait for a real bind | [restart](/cli/restart) |
-| `reticle update` | Install the latest server version and restart | [update](/cli/update) |
+| `reticle update [--rollback]` | Install the latest server version and restart; `--rollback` restores the previous one | [update](/cli/update) |
 
 ### Account
 
@@ -75,14 +77,11 @@ npx @reticlehq/server <command>
 | `reticle config` | Choose what syncs: runs, memory, flows; where verification runs | [cloud](/cli/cloud#reticle-config) |
 | `reticle hook [status\|install\|uninstall]` | The prompt hook: is each prompt captured here, add it, or remove exactly what was added | [prompt capture](/prompt-capture#reticle-hook) |
 | `reticle setup mcp` | Register the MCP server with your coding agents (the installer's registration half) | [setup](/cli/setup) |
-| `reticle serve` | Start the daemon and wait for it to bind | [serve](/cli/serve) |
+| `reticle serve [--restart]` | Start the daemon and wait for it to bind; `--restart` frees the port first | [serve](/cli/serve) |
 | `reticle mcp` | The MCP stdio proxy your agent runs; starts the daemon if needed | [mcp](/cli/mcp) |
 | `reticle drive <url>` | Foreground mode, for debugging | [drive](/cli/drive) |
-| `reticle affected [--since <ref>]` | Which saved flows must re-verify for the changed files | [affected](/cli/affected) |
 | `reticle context --compact [--session <id>]` | Resume after a compaction: what was proved, failed and is still owed | none |
 | `reticle report [--session <id>] [--hook]` | What the latest session claimed, and what held | [report](/cli/report) |
-| `reticle rollback` | Restore the previous server version and restart | [rollback](/cli/rollback) |
-| `reticle license` | Enterprise license status: active, eval or missing | [license](/cli/license) |
 | `reticle version` | Print the version | [version](/cli/version) |
 | `reticle help [all\|<command>]` | Usage: the short list, every command, or one command | [help](/cli/help) |
 
@@ -90,16 +89,27 @@ npx @reticlehq/server <command>
 
 The old names below still work for one release and print one line naming the new one.
 
-| Old | Now |
+| Old                | Now                         |
+| ------------------ | --------------------------- |
+| `reticle affected` | `reticle gate --list`       |
+| `reticle license`  | `reticle status`            |
+| `reticle rollback` | `reticle update --rollback` |
+| `reticle restart`  | `reticle serve --restart`   |
+
+These names were removed. Each prints what to use instead and exits `1`.
+
+| Removed | Use |
 | --- | --- |
 | `reticle kill` | `reticle stop --force` |
-| `reticle login`, `reticle link` | `reticle connect`. `reticle login --email` is gone: sign-in is only in the browser, with Google or GitHub. Without a browser, set `RETICLE_API_KEY` |
+| `reticle login`, `reticle link` | `reticle connect`. Sign-in is only in the browser, with Google or GitHub. Without a browser, set `RETICLE_API_KEY` |
 | `reticle project` | `reticle connect --project <name\|id>` |
 | `reticle whoami` | `reticle status` |
 | `reticle push` | `reticle sync` |
 | `reticle regression`, `share`, `issues`, `memory` | `reticle runs regression`, `runs share`, `runs issues`, `runs memory` |
-
-`hunt`, `watch`, `capsules`, `tutorial` and `identify` were removed. Each prints what to use instead and exits `1`: `reticle affected` or `reticle gate` for `watch`, `reticle init` or `reticle try <url>` for `tutorial`, `reticle feedback` for `identify`. Saved capsules stay in `.reticle/capsules`.
+| `reticle watch` | `reticle gate --list` or `reticle gate` |
+| `reticle tutorial` | `reticle init` or `reticle try <url>` |
+| `reticle identify` | `reticle feedback` |
+| `reticle hunt`, `reticle capsules` | nothing. Saved capsules stay in `.reticle/capsules` |
 
 ## Setup and diagnosis
 
@@ -192,18 +202,18 @@ policy       https://github.com/reticlehq/reticle/blob/main/docs/telemetry.md
 | `reticle serve` | Start the daemon and wait for it to bind. `--drive <url>`, `--headless`, `--headed`, `--http`, `--http-port N`, `--http-token T` |
 | `reticle stop` | Stop the daemon we started, by its recorded pid. `--quiet` |
 | `reticle stop --force` | Free the port by asking who is **listening** on it |
-| `reticle restart` | Free the port, then start a daemon and wait for a real bind. `--force` |
+| `reticle serve --restart` | Free the port, then start a daemon and wait for a real bind. `--force` |
 | `reticle open [url]` | Show the app. Reuse the connected tab, or open one |
 | `reticle drive <url>` | Foreground mode, for debugging |
 | `reticle mcp` | The MCP stdio proxy. Auto-starts the daemon if needed. This is what your agent runs |
 
-A bare `reticle` with no arguments is not help. It is `reticle serve`.
+A bare `reticle` with no arguments is not help. In a project that `init` wired, it is `reticle serve`. In a folder that Reticle has not wired, it gives a first verdict with no agent and no `init`. It finds the folder's web app (it starts the dev script when the app does not run), or the one dev server that runs on this computer. It opens the page in a Reticle browser and checks four things: the page loads, no console error, no failed request, and each same-origin link opens (8 at most). It prints `verified: yes` or `verified: no` with each fault, and exits 0 only for `yes`. A page that goes to a sign-in page is verified up to there. It stops the dev server it started.
 
 <Note>
   When the Reticle SDK installed in the project is a different **major** version from the CLI you ran,
   the CLI hands the same command to `npx @reticlehq/server@<that version>`, so an unpinned
   `npx @reticlehq/server` never pairs a daemon with an SDK it cannot talk to. `init`, `update`,
-  `rollback`, `setup install`, `version` and `help` always run as typed, and so does a command whose
+  `update --rollback`, `setup install`, `version` and `help` always run as typed, and so does a command whose
   version you pinned yourself (`npx @reticlehq/server@<version> …`). Set `RETICLE_NO_VERSION_MATCH=1` to
   turn it off. Because `--help` runs as typed too, it describes the CLI you ran. When the command it
   describes would run at the project's version instead, the help opens with a line naming that version.
@@ -238,12 +248,12 @@ Options:
 - `--results-json <file>`: also write one verdict per journey as JSON, for CI.
 - `--confirm-dangerous`: let this run press what the replay guard holds as destructive.
 
-### `reticle affected`
+### `reticle gate --list`
 
-Which saved flows must re-verify for a set of changed files.
+Which saved flows must re-verify for a set of changed files. It checks nothing.
 
 ```bash
-npx @reticlehq/server affected --since HEAD~1
+npx @reticlehq/server gate --list --since HEAD~1
 ```
 
 ```json
@@ -290,13 +300,13 @@ Measured exit code: **`1`**, with the flow lists trimmed above. That run genuine
 
 ## Maintenance
 
-| Command            | What it does                                        |
-| ------------------ | --------------------------------------------------- |
-| `reticle update`   | Install the latest server version and restart       |
-| `reticle rollback` | Restore the previous version and restart            |
-| `reticle license`  | Enterprise license status: active, eval, or missing |
-| `reticle version`  | Print the version                                   |
-| `reticle help`     | The short list; `help all` for every command        |
+| Command                     | What it does                                                 |
+| --------------------------- | ------------------------------------------------------------ |
+| `reticle update`            | Install the latest server version and restart                |
+| `reticle update --rollback` | Restore the previous version and restart                     |
+| `reticle status --json`     | Carries `license`: active, eval, missing, expired or invalid |
+| `reticle version`           | Print the version                                            |
+| `reticle help`              | The short list; `help all` for every command                 |
 
 <Tip>
   `rollback` exists because an auto-updating dev tool that cannot go back is a dev tool that can

package/docs/deploy-checks.md

@@ -12,6 +12,8 @@ That makes the non-developer story complete: the SDK is auto-injected by the bui
 
 > **Recipe A works today; Recipe B does not exist yet.** `reticle verify` exits 0/1 and persists a run artifact right now. What is _not_ built is a hosted Reticle app that registers itself as a Vercel or Netlify check provider. Until it exists, use the CI recipe.
 
+Using Reticle in CI or in a pipeline? Talk to a founder: [book a call](https://calendar.app.google/h9NRDbBBQetyTzWM6) or write to [hey@reticle.sh](mailto:hey@reticle.sh).
+
 ## The shape
 
 ```
@@ -54,6 +56,29 @@ The job's own pass/fail becomes the PR check. Nothing else is required.
 
 **Non-loopback previews need pairing.** For a real preview URL (not `localhost`), Reticle injects `reticle.connect()` with a one-time token and allow-lists the preview origin, so the app does not need to be rebuilt per environment. Confirm the SDK actually runs on the deployed build: a production build that tree-shakes the dev-only SDK will connect to nothing, and `verify` will (correctly) fail with _"no app connected."_
 
+## The Reticle GitHub Action
+
+The Action replays your saved flows on each preview and posts one check with a verdict for each flow. On `deployment_status`, it reads the preview URL from the event, so you type no URL.
+
+```yaml
+# .github/workflows/reticle.yml
+name: reticle
+on: [deployment_status]
+jobs:
+  verify:
+    if: github.event.deployment_status.state == 'success'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: reticlehq/reticle/action@v3.10.0
+        with:
+          api-key: ${{ secrets.RETICLE_API_KEY }}
+          # Only for a Vercel preview behind Deployment Protection.
+          vercel-bypass-secret: ${{ secrets.VERCEL_AUTOMATION_BYPASS_SECRET }}
+```
+
+A Vercel preview behind Deployment Protection needs a [Protection Bypass for Automation](https://vercel.com/docs/deployment-protection/methods-to-bypass-deployment-protection/protection-bypass-automation) secret. Netlify has no bypass secret for its password protection, so turn off protection for deploy previews. The [Action README](https://github.com/reticlehq/reticle/tree/main/action) gives each input.
+
 ## Recipe B: the Checks API pattern (what a hosted Reticle would do)
 
 Both providers expose the same shape, which is why this is one integration rather than two:

package/docs/desktop.mdx

@@ -224,7 +224,7 @@ Alternatively, since an Electron renderer _is_ Chromium, `--remote-debugging-por
 
 ```toml
 [dependencies]
-reticle-tauri = "3.8"
+reticle-tauri = "3.10"
 ```
 
 ```rust

package/docs/enterprise.md

@@ -1,50 +1,46 @@
 ---
 title: Enterprise
-description: 'Premium access and activation, what is gated, the security and data-handling posture, and the licensing model.'
+description: 'License keys and activation, the enterprise roadmap, the security and data-handling posture, and the licensing model.'
 icon: building
 ---
 
-Enterprise features ship inside the open package and are unlocked by a signed license key you set as `RETICLE_LICENSE_KEY`. Activation is verified locally with Ed25519 and makes **no network call**. Usage metrics are separate: they are on by default, and on a licensed build they carry your licence id. Turn them off with `RETICLE_TELEMETRY=0`. See [telemetry](/telemetry). Run `npx @reticlehq/server license` to see whether you are `active`, `eval`, `missing`, `expired` or `invalid`.
+Every Reticle package is Apache-2.0. An enterprise customer gets a signed license key, which you set as `RETICLE_LICENSE_KEY`. Activation is verified locally with Ed25519 and makes **no network call**. Usage metrics are separate: they are on by default, and on a licensed build they carry your licence id. Turn them off with `RETICLE_TELEMETRY=0`. See [telemetry](/telemetry). Run `npx @reticlehq/server license` to see whether you are `active`, `eval`, `missing`, `expired` or `invalid`.
 
 > For how to connect a platform to Reticle, see [Platform integration](/platform-integration).
 
 > **Already have a key and just need to switch it on?** [Activating a license key](./license-activation) is the step-by-step version: where to set it on each platform, the editor and CI cases, how to read every status, and what to do when it does not work.
 
-## How premium access works (offline, no phone-home)
+## How a license key works (offline, no phone-home)
 
-Enterprise (`ee/`) features ship **inside the open package**; they're source-available (free for development, testing, and evaluation). A **license key activates them in production**. Activation is verified locally with Ed25519 and sends nothing. Usage metrics, which you can turn off, carry your licence id on a licensed build.
+No feature in the open packages needs a key. A key identifies your organisation to Reticle. Activation is verified locally with Ed25519 and sends nothing. Usage metrics, which you can turn off, carry your licence id on a licensed build.
 
 **The flow, end to end:**
 
-1. **Buy.** Contact **[hey@reticle.sh](mailto:hey@reticle.sh)**; we issue you a signed license key (license id, org, plan, expiry, feature set). The **license id** is the stable handle on your subscription: it survives a rename, and it is what a renewal continues.
+1. **Buy.** Contact **[hey@reticle.sh](mailto:hey@reticle.sh)**; we issue you a signed license key (license id, org, plan, expiry). The **license id** is the stable handle on your subscription: it survives a rename, and it is what a renewal continues.
 2. **Install.** Set it on the machine running the Reticle server:
    ```bash
    export RETICLE_LICENSE_KEY="<your key>"
    # the release already bakes the issuer public key (RETICLE_LICENSE_PUBLIC_KEY)
    ```
-3. **Verify.** `reticle license` prints one JSON line whose `status` and `detail` say where you stand:
+3. **Verify.** `reticle status --json` carries a `license` object whose `status` and `detail` say where you stand:
 
    ```
    active    licensed to Acme Corp (enterprise), expires 2027-06-20T00:00:00.000Z
-   eval      evaluation mode: enterprise features run free (no issuer key configured)
-   missing   set RETICLE_LICENSE_KEY to activate enterprise features in production. Request a key from hey@reticle.sh
-   expired   license expired. Renew with hey@reticle.sh to keep using enterprise features
+   eval      evaluation mode (no issuer key configured)
+   missing   set RETICLE_LICENSE_KEY to activate a license. Request a key from hey@reticle.sh
+   expired   license expired. Renew with hey@reticle.sh
    invalid   license key rejected (<reason>). hey@reticle.sh can re-issue it
    ```
 
-   Every status reports `contact`, so a reader who is stuck always has somebody to write to. An unlicensed status also reports `gated`, what a licence unlocks in the build you are running, so the command answers "what would this buy me, and how do I get one" without anybody having to find this page first. It is derived from the features the gate actually enforces, so it names what your build will really refuse rather than a roadmap. An `active` licence does not report it: that reader has already bought, and listing feature names at them answers nothing they asked.
+   Every status reports `contact`, so a reader who is stuck always has somebody to write to. A published release has the issuer key baked in. Only a build from source, with no issuer key, reports `eval`.
 
-4. **Unlock.** Enterprise features now run; without a valid key they refuse to run (a clear error, never a silent half-feature). A published release has the issuer key baked in, so it enforces the key everywhere. Only a build without one (from source) runs in `eval` mode, where the features run free outside `NODE_ENV=production`.
-5. **Renew.** Keys carry an expiry, shown as `expiresAt`; once it passes, the status is `expired`.
+4. **Renew.** Keys carry an expiry, shown as `expiresAt`; once it passes, the status is `expired`.
 
-> Procuring a license: contact **[hey@reticle.sh](mailto:hey@reticle.sh)**. Keys are issued offline and signed with Ed25519; the activation you run (`reticle license`) verifies them locally with no network call.
+> Procuring a license: contact **[hey@reticle.sh](mailto:hey@reticle.sh)**. Keys are issued offline and signed with Ed25519; the activation check (`reticle status`) verifies them locally with no network call.
 
-## What's gated (and the roadmap)
+## Roadmap
 
-The licensing **mechanism** is open core (inspectable, FSL). Only the **features** under `ee/` are gated:
-
-- **Today:** the activation gate + one gated feature (audit event recording, `audit-log`).
-- **Roadmap** (the reliably enterprise-only set): **SSO/SAML, SCIM, RBAC / team permissions, audit logs, multi-org management, verify-before-merge policy gates, and the hosted control-plane connectors.** These are the things a security/compliance org pays for; the core verification engine stays free forever.
+**SSO/SAML, SCIM, RBAC / team permissions, audit logs, multi-org management, verify-before-merge policy gates, and the hosted control-plane connectors** are planned for the hosted Reticle platform, not for the open packages. The core verification engine stays free.
 
 > For pricing, write to [hey@reticle.sh](mailto:hey@reticle.sh). This page describes the mechanism, not the price list.
 
@@ -62,15 +58,14 @@ The honest one-pager a security review needs. Reticle is built so the answer to
 | Leak risk downstream? | The **`prod-preview` profile** redacts source `file:line`, raw bodies, and app-state values. |
 | Path safety | Run/flow ids are validated as single path segments on read **and** write (no traversal). |
 
-**Verify it yourself:** the SDK + server are source-available, so read the tree-shaking, the `127.0.0.1` bind, and the offline license verify. `SECURITY.md` has the disclosure process; an SBOM is available on request. SOC 2 is not in place; the posture above is the honest current state.
+**Verify it yourself:** the SDK and server are open source, so read the tree-shaking, the `127.0.0.1` bind, and the offline license verify. `SECURITY.md` has the disclosure process; an SBOM is available on request. SOC 2 is not in place; the posture above is the honest current state.
 
-## Licensing model (per package)
+## Licensing model
 
 | Scope | License | Why |
 | --- | --- | --- |
 | The protocol and the rules (`open-verification`, `core`, `engine`) | **Apache-2.0** | the part that DECIDES a verdict, auditable and reimplementable by anyone |
 | Embeddable SDK (`browser`, `react`, `babel-plugin`, `next`, `vite-plugin`, `electron`, `eslint-plugin`) | **Apache-2.0** | safe to ship inside your customers' apps; explicit patent grant |
-| Server / CLI / MCP (`server`, `init`, `test`) | **FSL-1.1-ALv2** | free for any use except reselling Reticle itself; converts to Apache after 2 years |
-| Enterprise features (`server/src/features/ee/`) | **Reticle Enterprise License** | source-available; free for dev/eval, license key required in production |
+| Server / CLI / MCP (`server`, `init`, `test`) | **Apache-2.0** | use, change and redistribute it anywhere |
 
 Embedding / OEM / enterprise: **[hey@reticle.sh](mailto:hey@reticle.sh)**.

package/docs/environment.mdx

@@ -53,6 +53,7 @@ Reticle works with none of these set. Each one changes a single behaviour, and m
 | Variable | Read by | What it does |
 | --- | --- | --- |
 | `RETICLE_SKIP_GATE` | `reticle gate --hook` | Lets an agent's stop hook proceed past a failing gate. The skip is printed and recorded, never silent. It does not affect `reticle gate` without `--hook`, which is what CI runs. |
+| `RETICLE_NO_CI_HINT` | `reticle gate`, `reticle verify` | `1` stops the one line these commands write to stderr at the end of a run in a CI runner or a container. The line names the pull request check and `https://reticle.sh/ci`. It never prints in an interactive terminal or for `gate --hook`, and it makes no network call. |
 | `RETICLE_VERIFY_TOKEN` | `reticle serve --http` | The bearer token the optional HTTP verify endpoint requires. |
 | `RETICLE_SECRET_<FIELD>` | replay, verify, crawl | The value typed into a password or secret field at replay. A recorded flow never stores it. See [what is recorded](/what-is-recorded). |
 

package/docs/first-drive.md

@@ -12,7 +12,7 @@ Everything here is written from a run of these exact steps, including the places
 ## Before you start
 
 ```bash
-node --version   # 22.12 or newer
+node --version   # 22.15 or newer
 pnpm --version   # this is a pnpm workspace; npm will not resolve it
 ```
 

package/docs/flows.md

@@ -80,7 +80,7 @@ reticle_run({ tool: "reticle_flow_save", args: { flowName: "create-task" } })
 }
 ```
 
-Each step binds to a **semantic anchor**, never a `eXX` ref: a `testid`/`signal` when available, else an auto-derived `component` anchor (component name + source `file:line`) for an element with no testid, so the flow stays stable with zero hand-added testids. A press of a document key (Escape, Tab, a shortcut) with no target is aimed at no element, so it is saved with a `{ "kind": "role", "role": "document" }` anchor and replayed at the document, as it ran. Only when none of those resolve is a step kept `degraded: true` (a last-resort "add a testid here" marker) rather than silently dropped.
+Each step binds to a **semantic anchor**, never a `eXX` ref: a `testid`/`signal` when available, else an auto-derived `component` anchor (component name + source `file:line`) for an element with no testid, so the flow stays stable with zero hand-added testids. A press of a document key (Escape, Tab, an arrow key, a shortcut) with no target is aimed at no element, so it is saved with a `{ "kind": "role", "role": "document" }` anchor and replayed at the document, as it ran. Only when none of those resolve is a step kept `degraded: true` (a last-resort "add a testid here" marker) rather than silently dropped.
 
 ## Run a flow
 
@@ -110,6 +110,16 @@ Every session's driving is saved as a flow at teardown when it declared a conseq
 - declare `requires` (the start page) and `ensures` (the end page) as route claims, so `canFollow` can tell which flows chain. Replay treats a required start page as met by navigating there;
 - carry `author: { agent, person }`: the MCP client that drove it and the email of whoever signed in with `reticle connect` on that machine. Either is left out when it is not known.
 
+### A route in `requires`
+
+A route claim in `requires` says which page the flow needs. Replay puts the tab there before step 1, so a suite does not run the flow on the page that the previous flow left open. It goes to `startPath` when that is on the route, else to the route itself.
+
+A route can name an entity id with a `:name` segment, for example `{ "kind": "route", "pathname": "/cases/:id/notes" }`. When the tab is already on a page that matches, replay keeps that page and its id. When the tab is on another page of the same record (`/cases/c-42/files`), replay opens the route with that id (`/cases/c-42/notes`). It opens the recorded address only when the tab has no id to give. The recorded id can be a record that was deleted since.
+
+Replay checks every route claim in `requires`, its `contains` too, on the page it arrives at. When the tab is already on the route, replay reloads it, the same reset a `startPath` gets. State that the previous flow left in memory is lost. A flow that needs that state declares it with a claim that is not a route.
+
+When replay cannot put the tab on the route (the page refuses, the app redirects to another page, or a pattern has no recorded address to open), the flow is `unverifiable` with a reason that names the route. No step runs.
+
 ## Delete a flow
 
 ```jsonc

package/docs/frameworks.mdx

@@ -5,7 +5,7 @@ description: Which frameworks Reticle supports, which are wired but unverified,
 icon: layer-group
 ---
 
-**React + Vite, Next.js, Remix and Astro are fully supported, each with an example app in CI: React + Vite and Next.js are driven to a verdict by the e2e battery, and the Remix and Astro examples are booted and must register a session. SvelteKit, Nuxt, React Router framework mode, Create React App, Vue and Angular have their INSTALL gated: the install gate scaffolds each from scratch whenever the install path changes and requires a real session, but no gate drives them to a verdict. TanStack Start, Preact and plain HTML are wired by `init` and documented but not gated at all, so treat them as plausible rather than proven.** The exact wiring for each is below.
+**Reticle works on React, Next.js, Remix, Astro, Vue, SvelteKit and Angular. React + Vite, Next.js, Remix and Astro each have an example app in CI: React + Vite and Next.js are driven to a verdict by the e2e battery, and the Remix and Astro examples are booted and must register a session. Vue, SvelteKit and Angular are supported with the framework-neutral sensor; their install is gated (scaffolded from scratch whenever the install path changes, and a real session is required), and no CI gate drives them to a verdict yet. The `file:line` source pointer works on React and Svelte, not on Vue or Angular. Nuxt, React Router framework mode and Create React App have their install gated the same way. TanStack Start, Preact and plain HTML are wired by `init` and documented but not gated at all, so treat them as plausible rather than proven.** The exact wiring for each is below.
 
 Reticle is a verification layer that embeds a dev-only SDK in your running web app so an AI coding agent can prove a change works. Its core is framework-neutral: DOM, network, console, routing, animations and source mapping work anywhere JavaScript runs.
 
@@ -15,7 +15,7 @@ What varies is two things: how `connect()` gets into your app, and whether you g
 
 ## Where each framework stands
 
-We separate "we tested this" from "this should work". Four frameworks have an example app and a CI gate. The rest are wired and documented but nothing proves they still work.
+We separate "supported" from "what CI proves". Four frameworks have an example app and a CI gate. Vue, SvelteKit and Angular are supported and install gated. The rest are wired and documented, and nothing in CI proves they still work.
 
 Two columns say different things and it is worth keeping them apart. **CI gate** `yes` means an example app runs in CI: React + Vite and Next.js are driven to a verdict, Remix and Astro are booted and must register a session. **install only** means the install gate scaffolds that stack from scratch, runs `init`, boots it and waits for a session, so the setup is proven and the drive is not. Vue is there because a release once nearly shipped an installer that left a Vue app connecting 0% of the time, and the gate that exists for exactly that had only React scaffolds.
 
@@ -27,14 +27,14 @@ Two columns say different things and it is worth keeping them apart. **CI gate**
 | **Next.js** | yes | yes | yes | yes | Supported |
 | **Remix** | yes | yes | yes | yes | Supported |
 | **Astro** | yes | yes | yes | yes | Supported |
-| **SvelteKit** | yes | no | install only | unproven | Install gated, drive unverified |
+| **SvelteKit** | yes | no | install only | yes | Supported |
 | **TanStack Start** | yes | no | no | unproven | Wired, unverified |
 | **Nuxt** | yes | no | install only | no | Install gated, drive unverified |
 | **React Router (framework mode)** | yes | no | install only | yes | Install gated, drive unverified |
 | **Create React App** | yes | no | install only | unproven | Install gated, drive unverified |
-| **Angular 17+** | yes | no | install only | no | Install gated, drive unverified |
+| **Angular 17+** | yes | no | install only | no | Supported (no `file:line`) |
 | **Plain HTML** | yes | no | no | no | Wired, unverified |
-| **Vue (non-Nuxt)** | as Vite | no | install only | no | Install gated, drive unverified |
+| **Vue (non-Nuxt)** | as Vite | no | install only | no | Supported (no `file:line`) |
 | **Preact** | as Vite | no | no | transform-tested; drive unproven | Sensor, React adapter via `preact/compat` |
 | **Server-rendered (Django, Flask, FastAPI, Streamlit, Rails)** | yes | no | no | no | Wired, unverified |
 
@@ -392,10 +392,10 @@ Solid appears in dependency detection but has no wiring, no adapter and no gate.
   </Accordion>
 
 <Accordion title="Does Reticle work with Vue?">
-  Partly, and the limit is specific. Install `@reticlehq/browser` rather than the React kit, and you
-  get DOM, network, console, routing, actions and Pinia state. What you do not get is a `source`
-  field: source stamping covers JSX and Svelte components, and a Vue single-file component is
-  neither. The install path is covered by a gate; the drive is not.
+  Yes. Install `@reticlehq/browser` rather than the React kit, and you get DOM, network, console,
+  routing, actions, verdicts and Pinia state. The one thing you do not get is a `source` field:
+  source stamping covers JSX and Svelte components, and a Vue single-file component is neither. The
+  install path is gated in CI; no example app is driven to a verdict there yet.
 </Accordion>
 
 <Accordion title="Which framework should I pick if I want the strongest verdicts?">

package/docs/getting-started.md

@@ -287,7 +287,7 @@ if (process.env.NODE_ENV !== 'production') {
 
 Change the `./reticle.local.js` path so that it points to the project root from your entry module. Do not commit `reticle.local.js`: the token is for this machine only. A teammate runs `reticle init` to get their own.
 
-Plain HTML with no build step: run `npx @reticlehq/server init` in the folder that holds `index.html`. It adds a dev-only snippet that connects only on localhost, and puts this machine's pairing token in a gitignored `reticle.local.js` beside the page, so the token never lands in anything you publish. A hand-written script tag without that token is refused by the bridge.
+Plain HTML with no build step: run `npx @reticlehq/server init` in the folder that holds `index.html`. Init does not change `index.html`. It serves the folder with Reticle's static server, which adds a dev-only connect snippet to the page that it serves. With `--url` or `--files-only`, nothing of Reticle's serves the page, so init writes the snippet into `index.html`. That snippet connects only on localhost. Init puts this machine's pairing token in a gitignored `reticle.local.js` beside the page, so the token never lands in anything you publish. A hand-written script tag without that token is refused by the bridge.
 
 > **Want to watch the agent work?** Add `present: true` to `reticle.connect()` for a glowing border, a synthetic cursor that flies to targets, click/hover effects, and a narration HUD. See [usage §16](usage.md#16-presenter-mode-narration-&-fake-clock-watch-+-control).
 

package/docs/install-manual.mdx

@@ -32,6 +32,21 @@ npx @reticlehq/server setup mcp
 
 `reticle setup mcp` is exactly the registration half of the installer, and it prints any client it could not write for you.
 
+### Sandbox and container images
+
+Install the CLI once, in the image:
+
+```bash
+npm install -g @reticlehq/server
+npx @reticlehq/server setup mcp
+```
+
+npx runs the installed copy. When the CLI is installed, `reticle init` and `reticle setup mcp` register its absolute path (`node <path>/bin/reticle.js mcp`). Each boot then starts the MCP server from the local copy, and your agent does not wait for a download.
+
+Without an install, the registration is `npx @reticlehq/server@<version> mcp`, with one exact version. npx uses its cache again only when that cache is in the image. A fresh sandbox with an empty npm cache downloads the package at each boot, and your agent waits for it before its first turn.
+
+If you remove the installed copy later, the agent shows the server as failed. `reticle doctor` then prints a `launcher` row with the missing path and the command to run.
+
 ## Part 1. Register the MCP server
 
 There is no config file that all agents share. Each harness has its own path and its own schema, so write only the one you actually use.
@@ -187,7 +202,7 @@ Screenshots and headless mode need the Rust crate, which is versioned independen
 
 ```toml
 [dependencies]
-reticle-tauri = "3.8"
+reticle-tauri = "3.10"
 ```
 
 ```rust

package/docs/license-activation.mdx

@@ -67,10 +67,10 @@ Put the key in the MCP server's own `env` block instead, then restart the editor
 ## Confirm it worked
 
 ```bash
-npx @reticlehq/server license
+npx @reticlehq/server status --json
 ```
 
-You do not need `NODE_ENV` set, a project, a dev server, or a running app. This reads the key and nothing else.
+Read `license.status` in the output. You do not need `NODE_ENV` set, a project, a dev server, or a running app. The license check reads the key and nothing else.
 
 | `status` | What it means | What to do |
 | --- | --- | --- |
@@ -142,4 +142,4 @@ export RETICLE_TELEMETRY=0
 
 [hey@reticle.sh](mailto:hey@reticle.sh) for activation problems, renewals and re-issues.
 
-Include the output of `npx @reticlehq/server license`. It carries your license id and no secrets, and it usually tells us the answer immediately.
+Include the output of `npx @reticlehq/server status --json`. It carries your license id and no secrets, and it usually tells us the answer immediately.

package/docs/packages/engine.mdx

@@ -12,7 +12,7 @@ icon: gavel
 
 It was nine thousand lines in the middle of the server, which meant the rules that decide a verdict could only be read, tested or trusted by running the whole daemon. Carving it out has three consequences that matter more than tidiness:
 
-- **It can be audited.** The verdict is the product, so the code that produces one is the code a sceptical reader most wants to see. It is Apache 2.0 for that reason, carved out of an otherwise source-available server.
+- **It can be audited.** The verdict is the product, so the code that produces one is the code a sceptical reader most wants to see. It is Apache 2.0, the same as every other Reticle package.
 - **It can be reused.** Anything that has evidence in the protocol's shape can reach a verdict without Reticle in the loop.
 - **It cannot quietly depend on the daemon.** A rule that needs a browser to decide something is not a rule, it is a measurement, and the package boundary is what makes that confusion a compile error.
 

package/docs/packages/server.mdx

@@ -6,7 +6,7 @@ icon: server
 
 `@reticlehq/server` is the Reticle bridge, MCP server and CLI in one Node package. It hosts the WebSocket your app dials into, exposes the MCP tools your agent calls, and ships the `reticle` binary. **You do not add it to your project**: your agent runs it with `npx @reticlehq/server mcp`.
 
-**Licensed under `FSL-1.1-ALv2` (the Functional Source License, converting to Apache 2.0), not Apache 2.0 like the SDK packages.** This is the package the enterprise terms apply to.
+**Licensed under `Apache-2.0`, the same as every other Reticle package.**
 
 ## Why it exists
 

package/docs/packages/tauri.mdx

@@ -16,7 +16,7 @@ Tauri IPC observation needs nothing on the Rust side. An `invoke('load_todos')`
 
 ```toml
 [dependencies]
-reticle-tauri = "3.8"
+reticle-tauri = "3.10"
 ```
 
 Its own dependencies are `tauri = "2.12"` (the Windows backend must use the same `webview2-com` and `windows` versions Tauri does, so it follows Tauri's minor version) plus the per-platform capture backends: `objc2` and friends on macOS, `webview2-com` and `windows` on Windows, `webkit2gtk` and `cairo-rs` on Linux and the BSDs.

package/docs/packages/test.mdx

@@ -6,7 +6,7 @@ icon: vial
 
 `@reticlehq/test` is Reticle's spec runner for CI. It turns an interactive session into a suite that runs on every pull request, without an agent and without paying model tokens to re-derive the same checks. Install it when you want unattended verification; skip it if you only ever drive Reticle interactively through MCP.
 
-**Licensed under `FSL-1.1-ALv2`. Depends on `@reticlehq/core` and `@reticlehq/server`. Optional peer dependency: `vitest ^3.2.6 || ^4.0.0`.**
+**Licensed under `Apache-2.0`. Depends on `@reticlehq/core` and `@reticlehq/server`. Optional peer dependency: `vitest ^3.2.6 || ^4.0.0`.**
 
 ```bash
 npm i -D @reticlehq/test

package/docs/packages.mdx

@@ -253,7 +253,7 @@ A lint rule makes the signal layer self-enforcing, which is the only way a conve
 
 ```toml
 [dependencies]
-reticle-tauri = "3.8"
+reticle-tauri = "3.10"
 ```
 
 <Card title="Desktop setup in full" icon="display" href="/desktop">

package/docs/platform-integration.md

@@ -154,4 +154,4 @@ A service that drives apps it did not build uses these seams.
 
 ## Licensing for embedding
 
-The embeddable SDK is **Apache-2.0** (ship it in your customers' apps). The server/CLI is **FSL** (free, no competing resale). Enterprise features + the premium-access flow: [`enterprise.md`](./enterprise.md). OEM terms: **[hey@reticle.sh](mailto:hey@reticle.sh)**.
+Every Reticle package is **Apache-2.0**, so you can ship the SDK in your customers' apps. Hosted and team features: [`enterprise.md`](./enterprise.md). OEM terms: **[hey@reticle.sh](mailto:hey@reticle.sh)**.

package/docs/predicates.mdx

@@ -316,7 +316,7 @@ This is the predicate that catches a UI-versus-store desync. A deploy that only
 { "kind": "animation", "name": "dialog-in", "completed": true }
 ```
 
-`target` narrows it to one element. `completed: false` matches an animation that is still running.
+`target` narrows it to one element by Reticle ref (`e12`) or CSS selector. `completed: false` matches an animation that is still running.
 
 ### settled