@reticlehq/server 2.7.0 → 2.8.0

package/docs/cli/license.mdx

@@ -0,0 +1,48 @@
+---
+title: reticle license
+description: Show the enterprise license status resolved from the environment, offline.
+icon: key
+---
+
+`reticle license` reports whether an enterprise license is active. It resolves entirely from the environment. Nothing leaves the machine.
+
+```bash
+npx @reticlehq/server license
+```
+
+No flags.
+
+## What it prints
+
+One `reticle_license` line. Real capture on a checkout with no issuer key configured:
+
+```json
+{
+  "t": "2026-08-14T19:38:38.331Z",
+  "event": "reticle_license",
+  "status": "eval",
+  "detail": "evaluation mode: enterprise features run free (no issuer key configured)"
+}
+```
+
+| `status`  | Meaning                                       |
+| --------- | --------------------------------------------- |
+| `active`  | A valid license is present                    |
+| `eval`    | Evaluation mode. Enterprise features run free |
+| `missing` | No license, and the build expects one         |
+
+`detail` is a sentence explaining the status.
+
+## Exit codes
+
+Always `0`.
+
+## Worked example
+
+```bash
+npx @reticlehq/server license | jq -r .status
+```
+
+<Card title="What enterprise covers" icon="building" href="/enterprise">
+  The licensed surface, and what stays Apache 2.0.
+</Card>

package/docs/cli/mcp.mdx

@@ -0,0 +1,61 @@
+---
+title: reticle mcp
+description: Run the MCP stdio proxy your agent talks to, starting a daemon if one is not already up.
+icon: plug
+---
+
+`reticle mcp` is the command your agent runs. It is the MCP server the editor launches: a stdio proxy that bridges the client to the daemon's SSE endpoint, starting a daemon first if the port is empty.
+
+```bash
+npx @reticlehq/server mcp [--port N] [--drive <url>] [--headless] [--headed] [--http] [--http-port N] [--http-token T]
+```
+
+This is what `reticle init` registers, so you rarely type it yourself.
+
+## Flags
+
+| Flag | Type | Default | What it does |
+| --- | --- | --- | --- |
+| `--port N` | number | `4400` (or `RETICLE_PORT`, or the port in `.reticle.json`) | Bridge port |
+| `--drive <url>` | string | unset | Have the daemon launch its own browser at this URL, so the agent has autonomous control without relying on your tab |
+| `--headless` | boolean | `true` for `mcp` | Hide that browser |
+| `--headed` | boolean | `false` | Show it |
+| `--http` | boolean | `false` | Forward the HTTP verify endpoint flags to the daemon it spawns |
+| `--http-port N` | number | unset | Port for that endpoint |
+| `--http-token T` | string | unset | Bearer token for it |
+
+## The rule this command lives by
+
+The proxy **is** the MCP server the editor launched. Nothing respawns it, so an uncaught throw here is what a user experiences as "the MCP server disconnected". Three behaviours follow from that:
+
+- Crash handlers write to the proxy's own log file, not just stderr, because the editor swallows stderr.
+- A daemon that is not there is not fatal. The proxy answers `initialize` itself, serves the cached tool catalog, and retries a daemon on every client request. Present and complaining beats absent, because absent needs a human.
+- Reconnect is self-healing: if the daemon exited, crashed, was stopped, or shut itself down as idle, the reconnect path spawns a new one rather than retrying a dead port until the budget runs out.
+
+## What it prints
+
+Structured lines to the proxy log (`~/.reticle/`), not to your terminal, since stdout is the MCP transport.
+
+| Event | Meaning |
+| --- | --- |
+| `reticle_mcp_daemon_started` | It spawned a daemon |
+| `reticle_mcp_daemon_unavailable` | It could not, and is serving anyway |
+| `reticle_mcp_proxy_first_connect_failed` | The first connect was refused. Expected when the daemon is still coming up |
+
+## Exit codes
+
+Runs for the life of the editor session.
+
+## Worked example
+
+```json
+{
+  "mcpServers": {
+    "reticle": { "command": "npx", "args": ["@reticlehq/server", "mcp"] }
+  }
+}
+```
+
+<Card title="The tools this exposes" icon="screwdriver-wrench" href="/tools-overview">
+  The full surface your agent gets once this is registered.
+</Card>

package/docs/cli/open.mdx

@@ -0,0 +1,68 @@
+---
+title: reticle open
+description: Show the app in a browser, reusing the already-connected tab when there is one.
+icon: window-maximize
+---
+
+`reticle open` is the one-command "show me the app". It resolves the port, makes sure a daemon is up, and then either reuses the tab that is already connected or opens a new one.
+
+```bash
+npx @reticlehq/server open [url] [--port N]
+```
+
+## Arguments and flags
+
+| Argument | Type | Default | What it does |
+| --- | --- | --- | --- |
+| `url` | string, positional, optional | unset | The URL to open. Omit it to reuse a connected tab |
+| `--port N` | number | `4400` (or `RETICLE_PORT`, or the port in `.reticle.json`) | Bridge port. If nothing is on it, `open` discovers a running daemon rather than making you hunt |
+
+It is idempotent. Re-running never piles up duplicate tabs.
+
+## What it prints
+
+One `reticle_open` line, whose fields say which of four things happened.
+
+| Fields | Meaning |
+| --- | --- |
+| `reusing` | A connected tab was already on the right page. Nothing was opened |
+| `reusing` + `requested` + `note` | A tab is connected on that origin but sitting on a different page. It was **left there**, not navigated. Drive it with `reticle_navigate` or open the URL yourself |
+| `opened` + `connected: true` | A browser was launched and a Reticle session appeared |
+| `opened` + `connected: false` + `note` | The URL went to the system default browser and no session showed up within 8 seconds. Almost always means the app carries no SDK, or dials a different port |
+| `error` | No app connected and no URL given, or the browser could not be launched |
+
+<Note>
+  `connected` is measured, not assumed. This command polls for a **new** session rather than printing
+  `{"opened": url}` unconditionally, so a run where nothing opened no longer looks like one where it did.
+  When the launcher itself cannot run, there is no `opened` field at all. Real capture:
+
+```
+{"event":"reticle_open","port":4499,"error":"could not launch a browser: spawn open ENOENT","recovery":"Nothing was opened. This command asks the OS to open a url in your default browser (`open` on this platform) and that failed, so the fix is on the OS side: open the url yourself, or set a default browser."}
+```
+
+</Note>
+
+<Warning>
+  This command does **not** use Reticle's own Chromium. It hands the URL to your system default
+  browser, so a `chromium` warning from `reticle doctor` has nothing to do with an `open` that came
+  back `connected: false`. That misread cost a reporter an afternoon in their bridge config.
+</Warning>
+
+<Warning>
+  For an Electron or Tauri app there is no URL to open. Start the app the way you normally would; it
+  dials the bridge itself.
+</Warning>
+
+## Exit codes
+
+| Code | Meaning                                                             |
+| ---- | ------------------------------------------------------------------- |
+| `0`  | Reused, opened, or reported that no app is connected                |
+| `1`  | A browser could not be launched, or the daemon could not be reached |
+
+## Worked example
+
+```bash
+npx @reticlehq/server open http://localhost:5173
+npx @reticlehq/server status    # confirm the session is really there
+```

package/docs/cli/restart.mdx

@@ -0,0 +1,60 @@
+---
+title: reticle restart
+description: Free the bridge port and put a daemon back on it, reporting each half separately.
+icon: rotate
+---
+
+`reticle restart` is [`reticle kill`](/cli/kill) followed by a daemon start that waits for a real bind.
+
+```bash
+npx @reticlehq/server restart [--port N] [--force]
+```
+
+## Flags
+
+| Flag | Type | Default | What it does |
+| --- | --- | --- | --- |
+| `--port N` | number | `4400` (or `RETICLE_PORT`, or the port in `.reticle.json`) | Which port to restart on |
+| `--force` | boolean | `false` | Passed to the kill half: clear a listener that is not a Reticle daemon |
+
+## The two halves are reported separately
+
+A restart that killed the old daemon and then could not start a new one leaves you somewhere quite different from one that could not kill anything at all, and a single `ok: false` cannot tell you which happened. So each half prints its own line.
+
+Real capture, restarting over a running daemon:
+
+```
+{"event":"reticle_killed","port":4499,"pid":84513,"escalated":false,"listenerIdentified":true,"note":"only the listener was signalled. Any `reticle mcp` proxy on this port holds a client connection, not the port, and was left alone — it goes dormant and starts a fresh daemon on the next tool call."}
+{"event":"reticle_daemon_spawned","port":4499}
+```
+
+Real capture, when the port is held by something that is not ours:
+
+```
+{"event":"reticle_kill_refused","port":4498,"reason":"pid 84537 (\"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. Run it again with --force if that is what you meant, or start Reticle on another port.","holder":"Python"}
+{"event":"reticle_restart_aborted","port":4498,"reason":"the port was not freed, so nothing was started — the old holder is still there"}
+```
+
+<Note>
+  The start half is `serve`'s, which waits for the daemon to **answer** before claiming it started
+  and exits non-zero when it does not. A restart never reports success for a daemon that never
+  bound.
+</Note>
+
+## Exit codes
+
+| Code | Meaning                                                   |
+| ---- | --------------------------------------------------------- |
+| `0`  | The port was freed and a daemon is answering on it        |
+| `1`  | The port was not freed, or the new daemon did not come up |
+
+## Worked example
+
+```bash
+npx @reticlehq/server restart         # after an upgrade, so the new version is the one serving
+npx @reticlehq/server status
+```
+
+<Card title="Why not lsof" icon="skull" href="/cli/kill">
+  The pipeline everyone reaches for kills the agent's own MCP proxy along with the daemon.
+</Card>

package/docs/cli/rollback.mdx

@@ -0,0 +1,35 @@
+---
+title: reticle rollback
+description: Restore the previously installed Reticle server version and restart.
+icon: arrow-rotate-left
+---
+
+`reticle rollback` is the undo for [`reticle update`](/cli/update). It restores the previous server version and restarts.
+
+```bash
+npx @reticlehq/server rollback
+```
+
+No flags.
+
+## What it prints
+
+Nothing on the happy path: `rollback()` replaces the process. A failure logs `reticle_rollback_failed` with the error message.
+
+Telemetry records the move as a `version_changed` event with `direction: "rollback"`, which is treated as a release-quality alarm rather than a routine version move.
+
+## Exit codes
+
+| Code | Meaning                                                     |
+| ---- | ----------------------------------------------------------- |
+| `0`  | The previous version was restored (the process is replaced) |
+| `1`  | There was nothing to roll back to, or the restore threw     |
+
+## Worked example
+
+```bash
+npx @reticlehq/server update
+# the new build misbehaves:
+npx @reticlehq/server rollback
+npx @reticlehq/server version
+```

package/docs/cli/serve.mdx

@@ -0,0 +1,62 @@
+---
+title: reticle serve
+description: Start the Reticle daemon on the bridge port and wait until it has actually bound.
+icon: play
+---
+
+`reticle serve` starts the daemon: the WebSocket bridge your app dials into, plus the tool engine behind it. It spawns a detached child and then waits for that child to answer `/status` before reporting success.
+
+```bash
+npx @reticlehq/server serve [--port N] [--drive <url>] [--headless] [--headed] [--http] [--http-port N] [--http-token T]
+```
+
+Most people never type this. Your agent runs [`reticle mcp`](/cli/mcp), which starts a daemon itself if one is not already up.
+
+## Flags
+
+| Flag | Type | Default | What it does |
+| --- | --- | --- | --- |
+| `--port N` | number | `4400` (or `RETICLE_PORT`, or the port in `.reticle.json`) | Bridge port to bind |
+| `--drive <url>` | string | unset | Launch Reticle's own browser at this URL instead of waiting for your tab |
+| `--headless` | boolean | `true` for `serve` | Hide the browser |
+| `--headed` | boolean | `false` | Show it. `serve` owns the pooled browser behind leases, which is batch work, so it hides by default |
+| `--http` | boolean | `false` | Also expose the HTTP verify endpoint |
+| `--http-port N` | number | unset | Port for that endpoint |
+| `--http-token T` | string | unset | Bearer token the endpoint requires |
+
+## What it prints
+
+One structured line. When a daemon already owns the port, it says so and does nothing:
+
+```json
+{ "t": "2026-08-14T19:39:13.230Z", "event": "reticle_daemon_already_running", "port": 4400 }
+```
+
+A successful spawn logs `reticle_daemon_spawned` with the port. A port held by something that is not a Reticle daemon is refused up front rather than spawned into:
+
+```
+reticle_daemon_start_refused
+```
+
+## Exit codes
+
+| Code | Meaning                                                                           |
+| ---- | --------------------------------------------------------------------------------- |
+| `0`  | A daemon is up on the port, whether this run started it or found it               |
+| `1`  | The port is held by a foreign process, or the child never bound within 15 seconds |
+
+<Note>
+  `serve` reports the **bind**, not the spawn. It used to exit `0` the moment it forked, while the
+  child died on an `EADDRINUSE` nobody joined back up. It now waits for the daemon to answer.
+</Note>
+
+## Worked example
+
+```bash
+npx @reticlehq/server serve --port 4400
+npx @reticlehq/server status
+```
+
+<Card title="What the daemon is" icon="sitemap" href="/architecture">
+  The bridge, the tool engine, and where `.reticle/` lives.
+</Card>

package/docs/cli/status.mdx

@@ -0,0 +1,64 @@
+---
+title: reticle status
+description: Ask whether the Reticle daemon is up and which app sessions have connected to it.
+icon: heart-pulse
+---
+
+`reticle status` is the command that tells you whether the install actually finished. Not a tick in a checklist: a connected app.
+
+```bash
+npx @reticlehq/server status [--port N]
+```
+
+## Flags
+
+| Flag | Type | Default | What it does |
+| --- | --- | --- | --- |
+| `--port N` | number | `4400` (or `RETICLE_PORT`, or the port in `.reticle.json`) | Which daemon to ask |
+
+## What it prints
+
+One JSON line on stdout. Real capture, daemon up and no app connected:
+
+```json
+{
+  "t": "2026-08-14T19:38:37.737Z",
+  "event": "reticle_status",
+  "port": 4400,
+  "running": true,
+  "pid": 4795,
+  "sessionCount": 0,
+  "sessions": [],
+  "why": "no browser session connected. Two things to weigh, and neither of them is proof. (1) Nothing is listening on the ports Reticle scans ... (2) There is no `.reticle.json` in the directory this daemon is running in ..."
+}
+```
+
+| Field | Meaning |
+| --- | --- |
+| `running` | Whether a usable daemon owns the port |
+| `presence` | Present when the pid file is dead: `daemon`, `foreign`, or `absent`. The port is asked, not just the pid file |
+| `pid` | The daemon process |
+| `sessionCount` / `sessions` | Connected app sessions, each with `sessionId`, `url`, `throttled`, `stale` |
+| `why` | Present when zero sessions connected. Names the two likely causes and refuses to assert either |
+| `updateAvailable` | Present when a newer server version is on the registry |
+
+<Note>
+  `status` asks the **port**, not only the pid file. `running: false` used to be printed about a
+  port that was demonstrably occupied, which sent the reader off to start a daemon that could never
+  bind.
+</Note>
+
+## Exit codes
+
+Always `0`. This command answers a question; it does not judge the answer.
+
+## Worked example
+
+```bash
+npx @reticlehq/server init
+npx @reticlehq/server status    # a session in the list means the app is genuinely wired
+```
+
+<Card title="Nothing connected?" icon="triangle-exclamation" href="/troubleshooting">
+  The bridge port is not your dev server port, and that is the most common cause.
+</Card>

package/docs/cli/stop.mdx

@@ -0,0 +1,56 @@
+---
+title: reticle stop
+description: Stop the Reticle daemon on a port, escalating from SIGTERM to SIGKILL if it will not go.
+icon: circle-stop
+---
+
+`reticle stop` reads the pid recorded for the port and stops that process.
+
+```bash
+npx @reticlehq/server stop [--port N] [--quiet]
+```
+
+## Flags
+
+| Flag | Type | Default | What it does |
+| --- | --- | --- | --- |
+| `--port N` | number | `4400` (or `RETICLE_PORT`, or the port in `.reticle.json`) | Which daemon to stop |
+| `--quiet` | boolean | `false` | Print nothing. For scripts that stop a daemon that may not be running |
+
+## How it stops
+
+1. `SIGTERM` first, then poll every 100ms.
+2. Still alive after 5 seconds: `SIGKILL`. A daemon that ignores `SIGTERM` is wedged, which is the one situation this command exists for, and giving up there left the port held and a human reaching for `kill -9`.
+3. Still alive 2 seconds after that: report `reticle_daemon_stop_timeout` with the pid and exit `1`. Surviving `SIGKILL` means the pid is not yours to kill, or it is an unkillable zombie. Neither is retryable.
+
+## What it prints
+
+| Event | When |
+| --- | --- |
+| `reticle_daemon_stopped` | It stopped. Carries `port`, `pid`, and `escalated: true` if it took a `SIGKILL` |
+| `reticle_daemon_not_running` | No live pid for that port. The stale pid file is removed |
+| `reticle_daemon_stop_timeout` | It survived everything. Exits `1` |
+
+## Exit codes
+
+| Code | Meaning                        |
+| ---- | ------------------------------ |
+| `0`  | Stopped, or was not running    |
+| `1`  | The process survived `SIGKILL` |
+
+<Warning>
+  Do not stop a daemon with `lsof -ti tcp:4400 | xargs kill -9`. That pattern matches the agent's
+  own `reticle mcp` proxy as well as the daemon and takes both down. Use this command, or [`reticle
+  kill`](/cli/kill).
+</Warning>
+
+## When this is not enough
+
+`stop` needs the pid Reticle recorded. If the pid file is stale, was never written, or the port is held by a daemon from another checkout, `stop` reports `reticle_daemon_not_running` about a port that is demonstrably occupied. [`reticle kill`](/cli/kill) asks the **port** instead and is the command for that case.
+
+## Worked example
+
+```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
+```

package/docs/cli/telemetry.mdx

@@ -0,0 +1,57 @@
+---
+title: reticle telemetry
+description: Show, enable, or disable Reticle's anonymous usage metrics on this machine.
+icon: chart-line
+---
+
+`reticle telemetry` is the user-facing control for anonymous usage metrics.
+
+```bash
+npx @reticlehq/server telemetry [status|enable|disable]
+```
+
+## Sub-actions
+
+| Action | Default | What it does |
+| --- | --- | --- |
+| `status` | yes, when nothing is given | Report the current state, why it is that state, and where the policy lives |
+| `enable` |  | Turn metrics on for this machine |
+| `disable` |  | Persist a machine-wide opt-out. Unlike `RETICLE_TELEMETRY=0`, this survives shells |
+
+Any other word is a usage error: `unknown telemetry action: <word>`, exit `1`.
+
+## What it prints
+
+Human-readable lines on stdout, like [`doctor`](/cli/doctor). Real capture inside a Reticle source checkout:
+
+```
+telemetry    disabled  (this is a Reticle source checkout; developing it is not using it)
+policy       https://github.com/reticlehq/reticle/blob/main/docs/telemetry.md
+```
+
+When it is enabled, a third line names every way to turn it off:
+
+```
+opt out      reticle telemetry disable  (or RETICLE_TELEMETRY=0 / DO_NOT_TRACK=1)
+```
+
+## Exit codes
+
+| Code | Meaning                              |
+| ---- | ------------------------------------ |
+| `0`  | Status shown, or the setting changed |
+| `1`  | Unknown sub-action                   |
+
+## Worked example
+
+```bash
+npx @reticlehq/server telemetry status
+npx @reticlehq/server telemetry disable
+```
+
+<Card title="Exactly what is collected" icon="shield-check" href="/telemetry">
+  The complete list, in plain language, and every way to switch it off.
+</Card>
+<Card title="Every event, in schema detail" icon="database" href="/telemetry-events">
+  The contributor reference: payload blocks, field types, and what each event exists to answer.
+</Card>

package/docs/cli/update.mdx

@@ -0,0 +1,52 @@
+---
+title: reticle update
+description: Install the latest Reticle server version, sync the project SDK to match, and restart.
+icon: arrow-up
+---
+
+`reticle update` moves the installed server forward and brings the app's SDK with it.
+
+```bash
+npx @reticlehq/server update
+```
+
+No flags.
+
+## What it does, in order
+
+1. Ask the registry what is available.
+2. Compare by **direction**, not inequality. A registry version that merely differs is not a newer one, and the old check happily installed a downgrade.
+3. Nothing newer: log `reticle_update` with `ok: false` and `message: "already on the latest version"`, then stop.
+4. Otherwise sync the **app's SDK first**. `reticle update` used to swap only the CLI, so the command whose job is keeping an install current was itself a way to produce a version-skewed pair.
+5. Then apply the CLI update, which execs and exits. Your agent client restarts it.
+
+## What it prints
+
+| Event | Fields |
+| --- | --- |
+| `reticle_update` | `ok`, and either `from` and `to`, or `message` and `version` |
+| `reticle_update_sdk` | `synced`, `packages`, `to`, `packageManager`. Or `synced: false` with `reason: "no @reticlehq packages in this project"` |
+| `reticle_update_sdk_failed` | A `hint` naming the exact command to run by hand |
+| `reticle_update_failed` | The error |
+
+The SDK sync is best effort and non-fatal on purpose. This command gets run from wherever the human happens to be standing, which is often not an app at all.
+
+## Exit codes
+
+| Code | Meaning                                                              |
+| ---- | -------------------------------------------------------------------- |
+| `0`  | Already current, or the update was applied (the process is replaced) |
+| `1`  | The update check or install threw                                    |
+
+## Worked example
+
+```bash
+npx @reticlehq/server version     # 2.8.0
+npx @reticlehq/server update
+```
+
+<Warning>
+  Attaching to a running daemon is what a daemon is for, which means an upgrade does not take effect
+  until that daemon dies. Run [`reticle stop`](/cli/stop) afterwards if you need the new build
+  serving immediately.
+</Warning>

package/docs/cli/verify.mdx

@@ -0,0 +1,57 @@
+---
+title: reticle verify
+description: Drive a URL once, replay every saved flow, and exit zero only on a real pass.
+icon: circle-check
+---
+
+`reticle verify` is the CI command: no model in the loop, no MCP. It boots the engine in drive mode, waits for the in-page SDK to dial back, replays every saved flow, renders the verdict, and exits.
+
+```bash
+npx @reticlehq/server verify <url> [--headed] [--timeout N] [--storage-state <file>]
+```
+
+It uses the same runner and the same verdict as the MCP and HTTP paths, so a platform agent that can only run a shell command gets a byte-identical artifact.
+
+## Arguments and flags
+
+| Argument | Type | Default | What it does |
+| --- | --- | --- | --- |
+| `url` | string, positional, **required** | none | The preview URL to drive |
+| `--headed` | boolean | `false` (headless) | Show the browser |
+| `--timeout N` | number, ms | `15000` | How long to wait for a browser session to dial back |
+| `--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 |
+
+## 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:
+
+```
+No app connected: Reticle drove the URL but no @reticlehq/browser session dialed back.
+  Make sure the SDK is in the build and reticle.connect() runs on the preview page
+```
+
+```
+No saved flows to verify (.reticle/flows is empty), so refusing to report a pass for verifying nothing.
+```
+
+<Warning>
+  Both of those are honesty guards, and both exit `1`. Verifying nothing is never a pass.
+</Warning>
+
+## Exit codes
+
+| Code | Meaning                                                           |
+| ---- | ----------------------------------------------------------------- |
+| `0`  | The verdict was a pass                                            |
+| `1`  | Failed, or no session, or no flows, or the engine could not start |
+
+## Worked example
+
+```bash
+npm run build && npm run preview &
+npx @reticlehq/server verify http://localhost:4173 --timeout 60000
+```
+
+<Card title="Recording the flows this replays" icon="vial" href="/testing">
+  Flows are recorded interactively, then committed to `.reticle/flows/`.
+</Card>

package/docs/cli/version.mdx

@@ -0,0 +1,39 @@
+---
+title: reticle version
+description: Print the version of the Reticle server that is actually executing.
+icon: tag
+---
+
+`reticle version` prints the running package version. It is the diagnostic to reach for when you need to know which build `npx` actually resolved, which is not always the one you expected.
+
+```bash
+npx @reticlehq/server version
+npx @reticlehq/server --version
+npx @reticlehq/server -v
+```
+
+All three are the same command. No flags.
+
+## What it prints
+
+One `reticle_version` line. Real capture:
+
+```json
+{ "t": "2026-08-14T19:38:37.595Z", "event": "reticle_version", "version": "2.8.0" }
+```
+
+## Exit codes
+
+Always `0`.
+
+## Worked example
+
+```bash
+npx @reticlehq/server version | jq -r .version
+```
+
+<Note>
+  The version here is the CLI's. A daemon that was already running keeps serving its own build until
+  it exits, so [`reticle doctor`](/cli/doctor) is the command that compares the two and names a
+  skew.
+</Note>