@reticlehq/server 3.8.2 → 3.9.0

package/dist/telemetry/telemetry.js

@@ -138,20 +138,24 @@ const Env = {
 };
 const isDisabled = (env, cwd = process.cwd()) => {
     const off = new Set(['0', 'false', 'off', 'no']);
-    if (off.has((env[Env.DISABLE] ?? '').toLowerCase()))
+    if (off.has((env[Env.DISABLE] ?? '').toLowerCase())) {
         return true;
+    }
     // Recording to a local file is not "phoning home", and the guards below exist to stop us phoning
     // home. Chief among them is the source-checkout rule — which is exactly where a release sweep is
     // driven from, so a sink that inherited it would record nothing and look like it had worked.
-    if ((env[Env.FILE] ?? '') !== '')
+    if ((env[Env.FILE] ?? '') !== '') {
         return false;
-    if (env[Env.VITEST] !== undefined)
-        return true; // a test run is not a user
+    }
+    if (env[Env.VITEST] !== undefined) {
+        return true;
+    } // a test run is not a user
     // Developing Reticle is not using Reticle. The `.env` carrying RETICLE_TELEMETRY=0 is gitignored,
     // so it only exists on the machine that made it — a fresh clone would phone home on a
     // contributor's first `reticle serve`. The repo marker is committed, so this guarantee travels.
-    if (isReticleSourceCheckout(cwd))
+    if (isReticleSourceCheckout(cwd)) {
         return true;
+    }
     const dnt = env[Env.DO_NOT_TRACK];
     return 'string' === typeof dnt && dnt !== '' && dnt !== '0';
 };
@@ -191,19 +195,22 @@ const readIdFile = (file) => {
 export const resolveIdentity = (file = ID_FILE) => {
     try {
         const existing = readIdFile(file);
-        if (existing !== undefined)
+        if (existing !== undefined) {
             return { anonymousId: existing, firstRun: false };
+        }
         const id = randomUUID();
         mkdirSync(dirname(file), { recursive: true });
         try {
             writeFileSync(file, id, { encoding: 'utf8', flag: 'wx' });
         }
         catch (error) {
-            if (!isAlreadyThere(error))
+            if (!isAlreadyThere(error)) {
                 throw error;
+            }
             const raced = readIdFile(file);
-            if (raced !== undefined)
+            if (raced !== undefined) {
                 return { anonymousId: raced, firstRun: false };
+            }
             // An empty file left by a crash: replace it, as the old code did.
             writeFileSync(file, id, 'utf8');
         }
@@ -235,30 +242,40 @@ export const projectFingerprint = (cwd) => {
     // stable across every directory inside one machine's checkout, a package.json root is the same for
     // a non-git project — and the raw cwd is stable across nothing, which is why it is last. See
     // `project-identity.test.ts` for what a wrong order costs.
-    const { key, source } = origin !== undefined
-        ? { key: origin, source: ProjectIdSource.GIT_ORIGIN }
-        : root !== undefined
-            ? { key: root, source: ProjectIdSource.GIT_ROOT }
-            : packageRoot(cwd) !== null
-                ? { key: packageRoot(cwd) ?? cwd, source: ProjectIdSource.PACKAGE_ROOT }
-                : { key: cwd, source: ProjectIdSource.CWD };
+    const { key, source } = projectKey(cwd, origin, root);
     return {
         projectId: createHash('sha256').update(key).digest('hex').slice(0, 32),
         // Reported alongside so the analytics knows whether this id is comparable to another machine's.
         source,
     };
 };
+/** The most stable key this directory has, and what it came from. */
+function projectKey(cwd, origin, root) {
+    if (origin !== undefined) {
+        return { key: origin, source: ProjectIdSource.GIT_ORIGIN };
+    }
+    if (root !== undefined) {
+        return { key: root, source: ProjectIdSource.GIT_ROOT };
+    }
+    const pkg = packageRoot(cwd);
+    if (pkg !== null) {
+        return { key: pkg, source: ProjectIdSource.PACKAGE_ROOT };
+    }
+    return { key: cwd, source: ProjectIdSource.CWD };
+}
 /** Nearest ancestor holding a package.json — the project boundary when there is no git. */
 const packageRoot = (cwd) => {
     let dir = cwd;
     // Same bound as the git walk: deep monorepos are well inside 20, and an unbounded loop on a
     // pathological path would hang the CLI's startup.
     for (let depth = 0; depth < 20; depth += 1) {
-        if (existsSync(join(dir, 'package.json')))
+        if (existsSync(join(dir, 'package.json'))) {
             return dir;
+        }
         const parent = dirname(dir);
-        if (parent === dir)
+        if (parent === dir) {
             return null;
+        }
         dir = parent;
     }
     return null;
@@ -329,18 +346,21 @@ export const createTelemetry = (opts) => {
     const cwd = opts.cwd ?? process.cwd();
     // A source checkout silences metrics but must not silence FEEDBACK — see onlyBlockedBySourceCheckout.
     const feedbackOnly = onlyBlockedBySourceCheckout(env, cwd);
-    if (isDisabled(env, cwd) && !feedbackOnly)
+    if (isDisabled(env, cwd) && !feedbackOnly) {
         return NOOP;
+    }
     try {
-        if (existsSync(join(reticleDir, OPT_OUT_FILE_NAME)))
-            return NOOP; // the persistent `reticle telemetry disable` opt-out
+        if (existsSync(join(reticleDir, OPT_OUT_FILE_NAME))) {
+            return NOOP;
+        } // the persistent `reticle telemetry disable` opt-out
     }
     catch {
         /* unreadable home dir — fall through; the env-var opt-outs above still apply */
     }
     const apiKey = env[Env.KEY] ?? POSTHOG_KEY;
-    if ('' === apiKey)
-        return NOOP; // no key baked in (dev/test build) — nowhere to send, stay silent
+    if ('' === apiKey) {
+        return NOOP;
+    } // no key baked in (dev/test build) — nowhere to send, stay silent
     const now = opts.now ?? (() => Date.now());
     const doFetch = opts.fetchImpl ?? fetch;
     const url = `${(env[Env.URL] ?? DEFAULT_URL).replace(/\/+$/, '')}${TELEMETRY_PATH}`;
@@ -375,8 +395,9 @@ export const createTelemetry = (opts) => {
     // How this process was launched: a property of the process, so read once. Only the bucket leaves.
     const launch = launchMethodOf(process.argv[1]);
     const home = opts.home ?? homedir();
-    if (!feedbackOnly)
+    if (!feedbackOnly) {
         showNoticeOnce(reticleDir);
+    }
     const spawnDetached = opts.spawnImpl ??
         ((command, args, input) => {
             const bodyFile = join(tmpdir(), `reticle-telemetry-${randomUUID()}.json`);
@@ -397,8 +418,9 @@ export const createTelemetry = (opts) => {
     const emit = async (kind, extra) => {
         // In a Reticle source checkout the emitter carries FEEDBACK and nothing else: somebody typed the
         // feedback, and no metric is worth phoning home from a contributor's clone.
-        if (feedbackOnly && TelemetryEventKind.FEEDBACK_SUBMITTED !== kind)
+        if (feedbackOnly && TelemetryEventKind.FEEDBACK_SUBMITTED !== kind) {
             return false;
+        }
         // One clock read for the whole event: `ts` and the licence check must agree, and two calls to
         // now() can straddle an expiry.
         const eventTs = now();
@@ -470,6 +492,7 @@ export const createTelemetry = (opts) => {
             ...(extra?.proxyExit !== undefined ? { proxyExit: extra.proxyExit } : {}),
             ...(extra?.daemonDeath !== undefined ? { daemonDeath: extra.daemonDeath } : {}),
             ...(extra?.wakeRefusal !== undefined ? { wakeRefusal: extra.wakeRefusal } : {}),
+            ...(extra?.gate !== undefined ? { gate: extra.gate } : {}),
             // A SCALAR: the event build and the wire schema, no `blocks` entry.
             ...(extra?.spawnMethod !== undefined ? { spawnMethod: extra.spawnMethod } : {}),
         };
@@ -484,7 +507,7 @@ export const createTelemetry = (opts) => {
         // PostHog filters and breakdowns operate on top-level properties, so a nested `feedback.stack`
         // would be invisible to the exact "which stacks report the most bugs" question this exists to
         // answer. One prefix keeps them grouped in the UI without a nested path.
-        const { anonymousId: distinctId, event: name, ts, sessionId: eventSessionId, feedback, session, project, verification, versionChange, crash, identity, connection, init, onboarding, bug, refusal, outage, instrumentation, hud, link, harness, proxyExit, daemonDeath, wakeRefusal, ...rest } = event;
+        const { anonymousId: distinctId, event: name, ts, sessionId: eventSessionId, feedback, session, project, verification, versionChange, crash, identity, connection, init, onboarding, bug, refusal, outage, instrumentation, hud, link, harness, proxyExit, daemonDeath, wakeRefusal, gate, ...rest } = event;
         // `$session_id` is PostHog's OWN session property, so sending ours under that name lights up
         // its built-in session views and funnels for free rather than requiring custom HogQL everywhere.
         // `sessionId` rides only on events that happened inside a daemon run. A one-shot CLI command
@@ -522,6 +545,7 @@ export const createTelemetry = (opts) => {
             proxyExit,
             daemonDeath,
             wakeRefusal,
+            gate,
         };
         for (const [prefix, block] of Object.entries(blocks)) {
             for (const [key, value] of Object.entries(block ?? {})) {
@@ -583,8 +607,9 @@ export const createTelemetry = (opts) => {
                     return response.ok !== false;
                 }
                 catch (error) {
-                    if (attempt === attempts - 1)
+                    if (attempt === attempts - 1) {
                         throw error;
+                    }
                 }
             }
             return false;
@@ -602,10 +627,17 @@ export const createTelemetry = (opts) => {
  */
 let invalidDropped = 0;
 export const droppedInvalidEvents = () => invalidDropped;
-/** `RETICLE_INTERNAL=1`, or the machine-wide marker file. Unreadable home → not internal. */
+/** The values of `RETICLE_INTERNAL` that mark a run, after trim and lower case. Anything else is not. */
+const INTERNAL_ON = new Set(['1', 'true', 'yes', 'on']);
+/**
+ * The one decision for the `internal` field on every event: `RETICLE_INTERNAL` set to an "on" value,
+ * or the machine-wide marker file. An explicit signal only, never read from a name, email or path.
+ * Unreadable home → not internal.
+ */
 const isInternal = (env, dir) => {
-    if ('1' === env[Env.INTERNAL] || 'true' === env[Env.INTERNAL])
+    if (INTERNAL_ON.has((env[Env.INTERNAL] ?? '').trim().toLowerCase())) {
         return true;
+    }
     try {
         return existsSync(join(dir, INTERNAL_MARKER_FILE));
     }

package/dist/telemetry/tool-refused.d.ts

@@ -15,7 +15,7 @@ import { RefusalReason, type NoSessionReason } from '@reticlehq/core/telemetry';
 export declare function notePendingNoSessionReason(reason: NoSessionReason | undefined): void;
 /** A call that was served. Breaks the retry chain: what follows it is not a retry of anything. */
 export declare function noteToolServed(): void;
-/** One refused call, reported with its cause and whether it was itself a retry. */
-export declare function reportToolRefused(tool: string, reason: RefusalReason): void;
+/** One refused call, reported with its cause, whether it was a retry, and the names of its arguments. */
+export declare function reportToolRefused(tool: string, reason: RefusalReason, args?: Record<string, unknown>): void;
 /** Tests only — the counters are process-lifetime, so each case has to start from zero. */
 export declare function resetToolRefusals(): void;

package/dist/telemetry/tool-refused.js

@@ -11,6 +11,7 @@
  * covered without anybody remembering to cover it.
  */
 import { RefusalReason, TelemetryActor, TelemetryEventKind, } from '@reticlehq/core/telemetry';
+import { describeToolParams } from './argument-shape.js';
 import { getTelemetry } from './telemetry.js';
 /**
  * Refusal events one daemon run will send.
@@ -54,8 +55,10 @@ export function notePendingNoSessionReason(reason) {
 export function noteToolServed() {
     lastRefusedTool = undefined;
 }
-/** One refused call, reported with its cause and whether it was itself a retry. */
-export function reportToolRefused(tool, reason) {
+/** How many argument names one refusal carries. A call with more is malformed in its own way. */
+const MAX_REFUSAL_PARAMS = 16;
+/** One refused call, reported with its cause, whether it was a retry, and the names of its arguments. */
+export function reportToolRefused(tool, reason, args = {}) {
     const retried = lastRefusedTool === tool;
     lastRefusedTool = tool;
     // Read and clear whatever the throw left, whether or not this refusal can use it: a reason left
@@ -71,6 +74,10 @@ export function reportToolRefused(tool, reason) {
             tool,
             reason,
             retried,
+            ...(() => {
+                const params = describeToolParams(args).slice(0, MAX_REFUSAL_PARAMS);
+                return 0 === params.length ? {} : { params };
+            })(),
             // Only where it means something. On any other refusal reason this field would be answering
             // a question nobody asked of it.
             ...(RefusalReason.NO_SESSION === reason && noSessionReason !== undefined

package/docs/architecture.md

@@ -115,14 +115,11 @@ This is plain, reviewable, version-controllable data, not a black box.
 
 ---
 
-## Open-core licensing (what's free, what's protected)
+## Licensing
 
-- The **protocol and the rules** (`open-verification`, `@reticlehq/core`, `@reticlehq/engine`) are **Apache-2.0**. The part that decides a verdict is the part a sceptical reader most wants to audit, so it is the part with no licence in the way.
-- The embeddable **SDK** (`@reticlehq/browser`, `@reticlehq/react` and the build adapters) is **Apache-2.0**, safe to ship inside your own app.
-- The **server / CLI** is under the **Functional Source License (FSL-1.1, Apache-2.0 future)**: source-available, converts to Apache-2.0 over time.
-- Enterprise-only features live behind a license gate and are clearly separated.
+Every npm package is **Apache-2.0**: the protocol and the rules (`open-verification`, `@reticlehq/core`, `@reticlehq/engine`), the embeddable SDK and its adapters, and the server, CLI, `init` and spec runner. The `reticle-tauri` crate is MIT.
 
-See [LICENSE](https://github.com/reticlehq/reticle/blob/main/LICENSE) and each package's own `LICENSE` file. The licensing _mechanism_ is open and inspectable; activation is offline (no phone-home).
+See [LICENSE](https://github.com/reticlehq/reticle/blob/main/LICENSE) and each package's own `LICENSE` file.
 
 ---
 

package/docs/cli/doctor.mdx

@@ -7,13 +7,14 @@ icon: stethoscope
 `reticle doctor` collapses the setup failure modes into one command. It is the first thing to run when something is wrong.
 
 ```bash
-npx @reticlehq/server doctor [--port N]
+npx @reticlehq/server doctor [--fix] [--port N]
 ```
 
 ## Flags
 
 | Flag | Type | Default | What it does |
 | --- | --- | --- | --- |
+| `--fix` | boolean | off | Repair what Reticle can repair safely, then run the checks again. See [Repair with --fix](#repair-with---fix) |
 | `--port N` | number | `RETICLE_PORT`, else the port in `.reticle.json`, else the daemon already serving this project, else `4400` | Which bridge port to diagnose |
 
 ## What it prints
@@ -50,10 +51,12 @@ When nothing has connected, the `sessions` line fails and the daemon's own diagn
 | Line | What it checks |
 | --- | --- |
 | `node` | The Node version running the CLI |
+| `mcp` | Which coding agents found on this machine have Reticle's MCP server registered. Fails when an agent is found without it, and names the agent and `reticle setup mcp` |
 | `chromium` | Whether the exact Chromium revision the bundled Playwright wants is on disk. The most common silent failure |
 | `daemon` | Whether the port holds a Reticle daemon, a foreign process (named where possible), or nothing. Adds a `version` line when the daemon's version or contract fingerprint disagrees with the CLI's |
 | `sessions` | Whether any page has actually connected. Zero is a FAILING check rather than a neutral note, because it is the state the setup most often stalls in: wired correctly, daemon up, nothing dialled in. When it is zero the daemon's own no-session diagnosis prints below the checklist |
 | `agent link` | Whether an MCP client has listed Reticle's tools on this port **and actually called one**. Every other row here checks a component; this one checks the hop between your agent and the daemon. It is possible for the SDK to be injected, a session to be live, and your client to show every tool enabled, while no request has ever crossed from the agent. That state passes every other check and is the one people lose hours to |
+| `launcher` | Only when an agent config starts Reticle from an installed copy (`node <path> mcp`) and that file does not exist, for example after `npm uninstall -g`. Names the agent, the path, and the command that writes a working entry |
 | `loopback` | Which of `localhost`'s two answers reaches the bridge. Printed **only when they disagree**. The daemon binds `127.0.0.1`, and a best-effort alias forwards `[::1]` to it so the name works everywhere. When that alias cannot open (IPv6 disabled, or something already holding `[::1]` on the port) the daemon serves IPv4 perfectly and a page told to dial `localhost` still cannot reach it, because Windows Chrome tries the IPv6 answer first. Every other row here goes green in that state |
 | `bridge port` | The port your app must dial, spelled out because mixing it up with the dev server port is the most common setup failure |
 | `port check` | Only when your project's configured port disagrees with the one the daemon is on. Prints the mismatch rather than leaving you to spot it across two lines |
@@ -113,9 +116,45 @@ The wanted revision and the root are both read back off the path Playwright itse
   before. That loop is why the line names the version to pin to.
 </Warning>
 
+## Repair with --fix
+
+When a row has a safe repair, a plain `doctor` run ends with one more line:
+
+```
+Run `reticle doctor --fix` to repair 2 of these.
+```
+
+`reticle doctor --fix` prints the checks, applies the safe repairs in a fixed order, runs the checks again, and prints one line for each repair and one for each row that still fails. A repair changes only Reticle's own state:
+
+| Order | Row | Repair | Done only when |
+| --- | --- | --- | --- |
+| 1 | `daemon` | Delete the pid file of a daemon that is not running | The process that the file names does not exist |
+| 2 | `daemon` | Stop a Reticle daemon that holds the port and does not answer, as `reticle restart` does | The holder's command line is a Reticle daemon, and it is still silent after a grace period. A different program and the agent's own `reticle mcp` proxy are never stopped |
+| 3 | `chromium` | Install the pinned Chromium of the bundled Playwright (a download) | No Chrome or Edge can stand in, and `RETICLE_CHROMIUM_PATH` is not set |
+| 4 | `launcher` | Run `reticle setup mcp`, which replaces Reticle's own entry | An agent config starts Reticle from an installed copy that does not exist. `setup mcp` keeps an existing Claude Code entry, so for Claude Code the step stays `claude mcp remove reticle -s user`, then `setup mcp` |
+| 5 | `mcp` | Run `reticle setup mcp` | An agent on this machine does not have Reticle registered |
+
+Each repair checks again before it acts, so a second `--fix` finds nothing to do and changes nothing.
+
+`--fix` never repairs a row that needs a change to your app, a process that Reticle cannot prove is its own daemon, or an action only you can do. For those rows it prints the step that the row names: for example `reticle init` for `project`, starting your agent for a stopped `daemon`, `reticle hook install` for `prompts`, a CSP or desktop change, or a version skew (restart the daemon when no other agent uses it).
+
+```
+reticle doctor --fix
+  daemon       pid file of a stopped daemon: fixed
+  daemon       a Reticle daemon that does not answer: nothing to do
+  chromium     Playwright's own Chromium: nothing to do
+  launcher     a registered launcher that does not exist: nothing to do
+  mcp          agent registrations: fixed
+  still needs: sync         ✗ off: this project is not linked: run `reticle connect`; no push yet
+```
+
+A registration takes effect when the agent reads its config again, so restart your agent after `mcp` is fixed.
+
 ## Exit codes
 
-Always `0`. `doctor` reports; it does not gate.
+A plain `doctor` always exits `0`. It reports; it does not gate.
+
+`doctor --fix` exits `0` only when no row fails after the repairs, and `1` otherwise.
 
 ## Worked example
 

package/docs/cli/help.mdx

@@ -33,7 +33,7 @@ Get started
   try         Watch Reticle drive a URL once and say which journeys work
 
 Check your app
-  verify      Check the saved flows against the running app; exit 0 means pass
+  verify      Check saved flows, or one claim with --expect, against the running app; exit 0 = pass
   gate        Fail unless passing checks cover the flows your changes touch
 
 Reticle on this machine
@@ -85,5 +85,7 @@ Two audiences, two channels: the structured line for logs and scripts, the plain
 | `1`  | Help was printed because something else was wrong |
 
 <Note>
-  A bare `reticle` with no arguments is **not** help. It is [`reticle serve`](/cli/serve).
+  A bare `reticle` with no arguments is **not** help. In a wired project it is [`reticle
+  serve`](/cli/serve). In a folder that Reticle has not wired, it gives a first verdict on the app:
+  see [the CLI reference](/cli).
 </Note>

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
 ```