@reticlehq/server 3.8.1 → 3.9.0

package/docs/cli/license.mdx

@@ -20,17 +20,16 @@ One `reticle_license` JSON line, on stderr. On a checkout with no issuer key con
 {
   "t": "2026-08-15T18:42:26.758Z",
   "event": "reticle_license",
-  "gated": ["audit-log"],
   "contact": "hey@reticle.sh",
   "status": "eval",
-  "detail": "evaluation mode: enterprise features run free (no issuer key configured)"
+  "detail": "evaluation mode (no issuer key configured)"
 }
 ```
 
 | `status`  | Meaning                                             |
 | --------- | --------------------------------------------------- |
 | `active`  | A valid license is present                          |
-| `eval`    | Evaluation mode. Enterprise features run free       |
+| `eval`    | Evaluation mode. No issuer key is configured        |
 | `missing` | No license, and the build expects one               |
 | `expired` | The key verified, but its expiry has passed         |
 | `invalid` | The key was rejected, or the build is misconfigured |
@@ -47,6 +46,6 @@ Always `0`.
 npx @reticlehq/server license 2>&1 | jq -r .status
 ```
 
-<Card title="What enterprise covers" icon="building" href="/enterprise">
-  The licensed surface, and what stays Apache 2.0.
+<Card title="Enterprise" icon="building" href="/enterprise">
+  License keys, the roadmap, and the licensing model.
 </Card>

package/docs/cli/setup.mdx

@@ -14,10 +14,21 @@ No flags, and nothing is asked. It works for your user account, not for one proj
 
 ## What it prints
 
-One line per agent: `✓ <agent>` for a new registration, `✓ <agent> (already set up)` when Reticle was there already, `⚠ <agent>: Reticle registration failed…` when a registration failed (the command then exits `1`), and `⚠ <agent>: add the reticle entry to <path> by hand` for a config it will not rewrite. If it finds no agent, it names every agent it looked for.
+A `Your agents:` block, with one line for each agent and the one next step for that agent:
+
+```text
+Your agents:
+  Claude Code  plugin active: type /reload-plugins if it is open
+  Cursor       added: restart Cursor, then turn Reticle on in Settings › MCP
+  Codex        added: restart Codex, then /mcp shows reticle
+```
+
+`already set up` means that Reticle was there already. `registration failed` gives the command to retry, and the command then exits `1`. `not added: add the reticle entry to <path> by hand` is for a config that it does not rewrite. If it finds no agent, it names every agent it looked for.
+
+In a terminal, and not in CI, it then waits up to 60 seconds for each agent to connect. Then it prints `Connected: <agent> ✓`, or the step that is still missing for that agent. Press Ctrl+C to stop the wait. [`reticle status`](/cli/status) shows the same lines later.
 
 ## How you know it worked
 
-Restart your coding agent. An agent reads its server list only when it starts. After the restart, the `reticle_*` tools are listed.
+Do the next step for your agent. Most agents read their server list only when they start. The Claude Code plugin loads with `/reload-plugins`. Then the `reticle_*` tools are listed, and `reticle status` shows `Connected: <agent> ✓`.
 
 Codex CLI keeps a TOML config. When the `codex` binary is on your PATH, Reticle registers through `codex mcp add`. Otherwise it prints the hand-edit lines above. Reticle then adds one line, `default_tools_approval_mode = "approve"`, under `[mcp_servers.reticle]` in `~/.codex/config.toml`. This line approves Reticle's own tools, so Codex does not ask before each call. Reticle changes no other line, and it keeps a mode that you set. To undo it, change that line to `default_tools_approval_mode = "prompt"`. Reticle does not change a mode that is already there.

package/docs/cli/status.mdx

@@ -35,8 +35,12 @@ reticle status
                http://localhost:5173/  (throttled, hidden)
                http://localhost:7699/  (throttled, hidden)
   agent link   ✓ your agent has read and used Reticle's tools
+  agents       Connected: Claude Code ✓
+               Cursor not connected yet: restart Cursor, then turn Reticle on in Settings › MCP
 ```
 
+The `agents` row has one line for each coding agent on this machine. A line shows `✓` when that agent connected to Reticle at least one time. Otherwise it shows the step that is still missing. `reticle setup mcp` prints the same lines.
+
 And with no daemon on the port:
 
 ```text

package/docs/cli.mdx

@@ -197,7 +197,7 @@ policy       https://github.com/reticlehq/reticle/blob/main/docs/telemetry.md
 | `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,

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.9.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.9"
 ```
 
 ```rust

package/docs/enterprise.md

@@ -1,22 +1,22 @@
 ---
 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>"
@@ -26,25 +26,21 @@ Enterprise (`ee/`) features ship **inside the open package**; they're source-ava
 
    ```
    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.
 
-## 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`, `reticle affected` | `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/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.9"
 ```
 
 ```rust

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/react.mdx

@@ -38,9 +38,21 @@ The bridge refuses a connect without the pairing token, also on localhost. `reti
 
 | Export | Signature | What it does |
 | --- | --- | --- |
-| `install` | `(): void` | Idempotent. Registers the `react` adapter and installs the render meter. Call it once, before `connect()` |
+| `install` | `(options?: InstallOptions): void` | Idempotent. Registers the `react` adapter and installs the render meter. Call it once, before `connect()` |
 
-The [Vite plugin](/packages/vite-plugin) injects `install()` and `reticle.connect()` for you, so a Vite user never writes either line.
+#### `InstallOptions`
+
+| Option | Type | Default | What it does |
+| --- | --- | --- | --- |
+| `discoverStores` | `boolean` | `true` | When `true`, `install` walks the React fiber tree after each of the first ten commits and registers stores it finds in Redux `Provider`, TanStack `QueryClientProvider`, and similar context providers. Set to `false` to skip auto-discovery. Use this when your app has more than one context provider and you want only the stores you name with `registerStore` to appear in `reticle_look`. The render meter still runs. |
+
+```ts
+// Only expose the store you control:
+install({ discoverStores: false });
+registerStore('safe', safeStore);
+```
+
+The [Vite plugin](/packages/vite-plugin) injects `install()` and `reticle.connect()` for you. In Vite, pass `discoverStores: false` to the plugin (`reticle({ discoverStores: false })`) to disable auto-discovery. With manual setup, pass `{ discoverStores: false }` to `install()` before calling `reticle.connect()`.
 
 ### Mapping a node to its component
 

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.9"
 ```
 
 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/vite-plugin.mdx

@@ -67,6 +67,7 @@ Plus a dynamic import of your dev module if one exists. It looks for `src/reticl
 | `present` | `boolean` | `true`. Set `false` to hide Reticle's presenter while keeping the agent connection active |
 | `sourceMapping` | `boolean` | `true`. Set `false` to skip the Babel pass |
 | `inject` | `boolean` | `true`. Set `false` to call `connect()` yourself |
+| `discoverStores` | `boolean` | `true`. Set `false` to disable auto-discovery of context stores in React apps (`install({ discoverStores: false })`) |
 | `desktop` | `boolean` | `false`. When `true` the connect passes `allowInProduction: true`, which an Electron or Tauri renderer needs, and a `vite build` in a non-production mode (`--mode development`) is instrumented too. A production-mode build is stubbed like a web build |
 | `captureNetworkBodies` | `boolean` | `false`. Also enabled by `VITE_RETICLE_CAPTURE_BODIES=1` |
 | `networkBodyMaxChars` | `number` | `8192`, clamped to 256 to 262144. Also `VITE_RETICLE_BODY_MAX_CHARS` |

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.9"
 ```
 
 <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/skill.md

@@ -3,7 +3,7 @@ name: reticle-docs
 description: Install, instrument and verify this running web app from the inside (DOM, network, routing, console and framework state) instead of screenshots or guessing. Drives one real flow end to end and returns a verdict with the file:line to fix. Use when the user asks to set up or install Reticle, when a user-facing change needs proving before you call it done, when a test passes but the UI is broken, or when the user types /reticle.
 license: Apache-2.0
 metadata:
-  version: 3.8.1
+  version: 3.9.0
   homepage: https://docs.reticle.sh
   repository: https://github.com/reticlehq/reticle
   internal: true

package/docs/telemetry.md

@@ -40,7 +40,7 @@ Twenty-five kinds of events, each a single small JSON object. This is the whole
 | `mcp_proxy_exited` | The process that gives your agent its Reticle tools ends | Why it ended (`stdin_end`, `idle`, `client_gone_storm`, `wake_failed`), how long it ran, and two counts: how many times it lost the daemon and how many tool calls it carried, with its random id. Never what the calls were |
 | `daemon_died_unclean` | Reticle finds that an earlier daemon stopped without a clean exit | How long that daemon had run. Nothing else |
 | `wake_refused` | Reticle will not use the daemon port it found, because something else holds it | Whether the holder was another program (`foreign`) or a Reticle daemon for another project (`other_project`). Never the port or the project |
-| `onboarding_step` | One step of getting set up begins, finishes, fails, is skipped, or is walked away from | Which phase (`install`, `onboard`, `first_run`), which step, what became of it, how long it took, and the framework. The step name comes from a closed list we define -- it can only ever be one of the names in `core/src/onboarding.ts`, so nothing you typed or any path on your disk can arrive in it. `unattended` says whether anybody was asked anything |
+| `onboarding_step` | One step of getting set up begins, finishes, fails, is skipped, or is walked away from | Which phase (`install`, `onboard`, `first_run`), which step, what became of it, how long it took, and the framework. The step name comes from a closed list we define -- it can only ever be one of the names in `core/src/onboarding.ts`, so nothing you typed or any path on your disk can arrive in it. `unattended` says whether anybody was asked anything. A step that failed can carry why setup stopped, also from a closed list (`no_node`, `node_too_old`, `no_web_app`, `dev_server_failed`, `chromium_unavailable`, and so on) |
 | `init_completed` | `reticle init` finishes | Whether it worked, a classified reason when it did not, and which published install route you came through, DECLARED by that route via `RETICLE_INSTALL_SOURCE` and never inferred, and `unknown` when nothing declared one |
 | `bug_found` | Reticle finds a defect in the app under test | The **kind** of defect (`signal-contradicted`, `console-error`, …) and how it was found, never what it was found in |
 | `tool_refused` | A tool cannot do what an agent asked | Which tool, why (one of six buckets: no session, no match, unsupported, bad arguments, not ready, other), and whether the same call was retried. **Never the message**, because a refusal interpolates whatever you asked for, so only the tool name and the bucket are sent. Capped at 50 per daemon run |
@@ -49,11 +49,12 @@ Twenty-five kinds of events, each a single small JSON object. This is the whole
 | `hud_signin_prompted` | The HUD shows you a sign-in or "link this project" prompt | Which prompt (`rail`, `harness` or `header`), once per prompt for each daemon run |
 | `platform_linked` | A project on this machine is linked to a Reticle workspace | How (`connect`, `hud` or `link`) and the workspace's id; see [The platform side](#the-platform-side) |
 | `harness_run` | A Reticle Harness run starts, and again when it ends | Who started it (`agent`, `hud`, `dashboard`, `cli_try`, `plan`), whether the platform drove it, and at the end how it went (`proved`, `not_proved`, `failed`, `blocked`, `stopped`), how many journeys it answered and replayed, as buckets, and for a `blocked` or `failed` run why it did not drive, from a closed list (`not_linked`, `harness_off`, `no_credits`, and so on) |
+| `gate_completed` | `reticle gate` ends | How it ended (`pass`, `fail`, `nothing_to_check`, `regression` or `error`) and how many saved flows it judged. Never a flow name or a file path |
 | `identified` | **Never** from this version. Only an earlier version's `reticle identify`, which has been removed | What you chose to tell us then; see [Telling us who you are](#telling-us-who-you-are) |
 
 **There is no per-tool-call event.** Tool usage is counted in memory and leaves once, inside `daemon_stopped`, as a histogram like `{"reticle_act": 40, "reticle_assert": 12}`. That is counts of tool NAMES from a fixed list we define, never arguments, results, selectors, or URLs.
 
-**Parameter and flag NAMES are collected; their VALUES are not.** We record that `reticle_act` was called with `ref` and `action`, and that you ran `reticle serve --headed --port`. We do not record what you set them to. This distinction is the whole safety property, and it is absolute for CLI flags: `--http-token` holds a secret, `--drive` holds a URL, `--storage-state` holds a file path, so no flag value is ever sent. For tool parameters there is one narrow exception: a short, explicit allowlist of parameters whose values are enums _we_ defined (`action: "click"`), listed in [`argument-shape.ts`](https://github.com/reticlehq/reticle/blob/main/server/src/telemetry/argument-shape.ts). A value outside that allowlist reports as `other`, so a future schema change cannot quietly start forwarding free text. `reticle_act`'s `args` (the text being typed into your app, which on a login form is a password) is **never** in that allowlist.
+**Parameter and flag NAMES are collected; their VALUES are not.** We record that `reticle_act` was called with `ref` and `action`, and that you ran `reticle serve --headed --port`. We do not record what you set them to. This distinction is the whole safety property, and it is absolute for CLI flags: `--http-token` holds a secret, `--drive` holds a URL, `--storage-state` holds a file path, so no flag value is ever sent. For tool parameters there is one narrow exception: a short, explicit allowlist of parameters whose values are enums _we_ defined (`action: "click"`, and the name of the Reticle tool that `reticle_run` calls), listed in [`argument-shape.ts`](https://github.com/reticlehq/reticle/blob/main/server/src/telemetry/argument-shape.ts). A value outside that allowlist reports as `other`, so a future schema change cannot quietly start forwarding free text. `reticle_act`'s `args` (the text being typed into your app, which on a login form is a password) is **never** in that allowlist.
 
 `daemon_stopped` carries: how long the session ran, how many tool calls and of which tools, how many of those calls came before an app connected, the version of the Reticle SDK in the last page that connected, how long each tool took (total and worst case), how many failed, how many verifications ran, browser/lease connection attempts with their failure causes, and which MCP clients connected (`claude-code`, `cursor`). It also carries how the in-page HUD was used: presses per control (`hudControls`, by the control's name from a closed list Reticle defines, a toggle as `name:on` / `name:off`), how long the HUD sat as a bubble, collapsed or open and on which page (`hudViewMs`, `hudPanelMs`), which rail slides were shown (`hudSlides`), and the order of those presses and views, cut at 60 (`hudJourney`). Control names, never anything typed or shown on the page.
 
@@ -113,6 +114,7 @@ Every event carries the same few fields:
 | `version` | The Reticle version running | n/a |
 | `os` | The platform (`darwin` / `linux` / `win32`) | Not the OS version, hostname, or hardware |
 | `ci` | Whether the run is inside CI | n/a |
+| `internal` | `true`, only on the Reticle team's own machines and test runs, which set it on purpose | Not set for anybody else, and never guessed from a name, an email or a path |
 
 There are no IP-based profiles, no cookies, no fingerprinting, and no person profiles: events are processed in "personless" mode, so they are never joined into a person profile.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reticlehq/server",
-  "version": "3.8.1",
+  "version": "3.9.0",
   "mcpName": "io.github.reticlehq/reticle",
   "description": "Reticle CLI, bridge and MCP server: a coding agent drives your running web app from the inside and gets a verdict with evidence, for change verification, access control, accessibility, performance and SEO checks.",
   "type": "module",
@@ -23,11 +23,11 @@
     "@modelcontextprotocol/sdk": "^1.31.0",
     "ws": "^8.21.3",
     "zod": "^4.6.6",
-    "@reticlehq/engine": "3.8.1",
-    "@reticlehq/core": "3.8.1",
-    "@reticlehq/init": "3.8.1",
-    "open-verification": "1.0.0",
-    "@reticlehq/browser": "3.8.1"
+    "@reticlehq/browser": "3.9.0",
+    "@reticlehq/core": "3.9.0",
+    "@reticlehq/init": "3.9.0",
+    "open-verification": "1.1.0",
+    "@reticlehq/engine": "3.9.0"
   },
   "devDependencies": {
     "@types/pngjs": "^6.0.5",
@@ -39,7 +39,7 @@
     "playwright": "^1.63.0",
     "pngjs": "^7.0.0"
   },
-  "license": "FSL-1.1-ALv2",
+  "license": "Apache-2.0",
   "author": "Reticle contributors",
   "repository": {
     "type": "git",
@@ -52,7 +52,8 @@
     "bin",
     "dist",
     "README.md",
-    "LICENSE-ENTERPRISE",
+    "LICENSE",
+    "NOTICE",
     "SKILL.md",
     "docs"
   ],
@@ -64,8 +65,11 @@
     "cli"
   ],
   "reticle": {
-    "changelog": "On Windows, the daemon now keeps running when the agent process that started it ends. A collapsed Next.js \"1 Issue\" badge no longer turns every check into unknown. Reticle moves to zod 4 for a high-severity memory advisory. reticle_lease can omit url and lease the project's own dev server. reticle doctor checks that the daemon answers, and streamed SSE response bodies can be captured. Replay waits for a start page that is still loading, a re-acquired lease moves to the page asked for, and a guarded app driven by fast clicks is no longer accused of applying a stale response. Update the SDK in your app as well as the CLI.",
-    "breakingChanges": []
+    "changelog": "3.9.0 gets more installs to a first verdict. The one-line installer and reticle init now check your app and wait for your agent to connect. A lease reads a deployed preview with no SDK installed. Several false verdicts are fixed: a click that hit Reticle's own panel, a recorded flow that lost its assertion, and an iframe that took over a page's session. Every package is now Apache-2.0. Update the CLI and the SDK in your app.",
+    "breakingChanges": [
+      "A headless page now opens at 1440x900, not 1280x720. Record your headless screenshot baselines again, or they report dimension-mismatch.",
+      "The JSON line of `reticle license` no longer has the `gated` and `coversNothingHere` fields."
+    ]
   },
   "publishConfig": {
     "access": "public"

package/LICENSE-ENTERPRISE

@@ -1,37 +0,0 @@
-The Reticle Enterprise License (the "Enterprise License")
-Copyright (c) 2026 Reticle Labs
-
-With regard to the Reticle software (the "Software"):
-
-This Software and associated documentation files (the "Software") may only be
-used in production if you (and any entity that you represent) hold a valid Reticle
-Enterprise subscription for the correct number of seats and/or usage as agreed
-with Reticle Labs.
-
-Subject to the foregoing, you are free to use, copy, modify, and create
-derivative works of the Software for development, testing, and evaluation
-purposes without a subscription.
-
-You may not move, change, disable, or circumvent the license-key functionality
-in the Software, and you may not remove or obscure any functionality in the
-Software that is protected by the license key.
-
-You may not alter, remove, or obscure any licensing, copyright, or other
-notices.
-
-Any use of the Software in violation of this Enterprise License will
-automatically terminate your rights under this Enterprise License for the
-current and all other versions of the Software.
-
-This Enterprise License does not grant you any rights to any trademark, trade
-name, service mark, logo, or product name of Reticle Labs.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-For a Reticle Enterprise subscription: hey@reticle.sh

package/dist/features/ee/audit-log.d.ts

@@ -1,14 +0,0 @@
-/**
- * Example enterprise feature (Reticle Enterprise License — see./LICENSE). Demonstrates the pattern every
- * ee feature follows: call assertEnterprise...) first, then do the privileged work. The body here is a
- * stub — the real audit sink is the hosted control plane. It exists now to prove the gate.
- */
-import { type GateContext } from '../license/license.js';
-interface AuditEvent {
-    actor: string;
-    action: string;
-    at: number;
-}
-/** Record an audit event — gated. Throws EnterpriseLicenseError in production without a valid license. */
-export declare function recordAuditEvent(event: AuditEvent, ctx: GateContext): AuditEvent;
-export {};

package/dist/features/ee/audit-log.js

@@ -1,11 +0,0 @@
-/**
- * Example enterprise feature (Reticle Enterprise License — see./LICENSE). Demonstrates the pattern every
- * ee feature follows: call assertEnterprise...) first, then do the privileged work. The body here is a
- * stub — the real audit sink is the hosted control plane. It exists now to prove the gate.
- */
-import { assertEnterprise, EnterpriseFeature, } from '../license/license.js';
-/** Record an audit event — gated. Throws EnterpriseLicenseError in production without a valid license. */
-export function recordAuditEvent(event, ctx) {
-    assertEnterprise(EnterpriseFeature.AUDIT_LOG, ctx);
-    return event; // stub: a real implementation persists to the enterprise audit store
-}