railwatch 0.9.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93de03467c62b34decd8de64008cee94e3032bbbf51d574d65f1271a4261c22a
-  data.tar.gz: 6a7bb7839ae87ee9a00b94b9404ebe518208470afc77947c5c304966454c0953
+  metadata.gz: 336bf2e2440f9d076539faaca52e7d04db59422aeb280250a4c4556e7c6562ea
+  data.tar.gz: ea7b81637d1e104faa87e9ceb756cd1af43afb801108335674a508658b9adafa
 SHA512:
-  metadata.gz: 94efd4b22a285f4735aeb652450f73e2135f795bb78f4a901b44fb89989769e817571b3768ce3aba4e7a442a29492f48767445b6c8967bd0f77eed4e3e4bed5b
-  data.tar.gz: 38e2952771cfbf9a359f66000257895e08c0ba47f5144e8084fb5f98af9129904a66d05482896d443c2dd1d3239b0336cde17656dd869635e2ed887b49640dda
+  metadata.gz: 2223825b1e9287148a7a4a0707b786b6ac88a4859b1566f4630706b3dffd50b13ef19815e70ffba85aa5669c37925a20895af68e4377098fd51c6250a680431b
+  data.tar.gz: 71d620559e2d9fd431ae93fd269bd4b573e13bf23295a4bb98cfa395f720ee3fa94bf0557fe562ae2e7e4492428b22ccdaf82c25c0082485ee2550cf82ee7c5c

data/AGENTS.md

@@ -4,9 +4,11 @@ About *using* the `railwatch` gem from a Rails application; copy
 this into that application's repository. Index of everything else:
 [`llms.txt`](llms.txt).
 
-Railwatch instruments a Rails app end to end and stores linked telemetry in
-two SQLite databases of the app's own (embedded, the default) or sends it to
-Railwatch Cloud. Every request, job attempt, scheduled task run, and command is
+Railwatch instruments a Rails app end to end and sends linked telemetry over
+HTTPS to a Railwatch server: Railwatch Cloud (`https://railwatch.rebulk.com`,
+the default), a self-hosted [railwatch-rs](https://github.com/Rebulk/railwatch-rs),
+or the one the [`railwatch-server`](https://github.com/Rebulk/railwatch-server)
+gem runs next to Puma. Every request, job attempt, scheduled task run, and command is
 an **execution**; every query, cache read, log line, outgoing HTTP call, LLM
 call, view render, exception, and span is a child of one, linked by
 `execution_id`/`trace_id`. It never writes to the app's primary database.
@@ -15,40 +17,41 @@ call, view render, exception, and span is a child of one, linked by
 
 ```sh
 bundle add railwatch
-bin/rails generate railwatch:install                                 # embedded: dashboard at /railwatch
-bin/rails generate railwatch:install --prompt-token --kamal-secrets  # or: Railwatch Cloud
+bin/rails generate railwatch:install --prompt-token --kamal-secrets  # Railwatch Cloud
+bin/rails generate railwatch:install --url=https://telemetry.example.com  # self-hosted railwatch-rs
 ```
 
-With no flags the install is embedded (see [Embedded mode](docs/embedded.md)):
-telemetry stays in two SQLite databases the app owns (`railwatch`,
-`railwatch_telemetry`, added to `config/database.yml`), Puma forks one writer
-for them (`plugin :railwatch` in `config/puma.rb`), and the dashboard is served
-at `/railwatch`. It is open in development and answers 401 elsewhere until
-`RAILS_ENV=production bin/rails railwatch:authentication:configure` sets a
-password. An exported `RAILWATCH_TOKEN` alone does not change the mode.
-`--cloud`, or any of `--prompt-token`, `--token-stdin`, `--url`,
-`--kamal-secrets`, sends telemetry to Railwatch Cloud instead.
-
-Both modes write `config/initializers/railwatch.rb`, mount `Railwatch::Engine`
-at `/railwatch`, add the Kamal `post-deploy` hook and the Inertia browser client
-where the app has them, and require `railwatch/rspec` (or `railwatch/minitest`)
-in the test helper; the cloud install then runs `railwatch:doctor`. A
+The generator writes `config/initializers/railwatch.rb`, mounts
+`Railwatch::Engine` at `/railwatch` (it serves only the browser beacon), adds
+the Kamal `post-deploy` hook and the Inertia browser client where the app has
+them, requires `railwatch/rspec` (or `railwatch/minitest`) in the test helper,
+and runs `railwatch:doctor` (`--no-doctor` skips it). A
 prompted/stdin/environment token goes into `.env` only when Git confirms that
-file is ignored; token values are never printed. Configuration lives only in
-that initializer; every option also has a `RAILWATCH_*` environment variable.
-An embedded install mirrors to Railwatch Cloud as well with a token and
-`c.export_enabled = true`.
+file is ignored; token values are never printed. Without a token the gem is
+inert. Configuration lives only in that initializer; every option also has a
+`RAILWATCH_*` environment variable.
+
+Embedded (the dashboard inside the app, no token to manage): add
+`gem "railwatch-server"` to the Gemfile and `plugin :railwatch_server` to
+`config/puma.rb`. It provisions `storage/railwatch/<env>` on first boot and
+points this agent at it. Its dashboard at `/railwatch` is gated by this gem's
+`http_basic_auth_*` settings (open in development, 401 elsewhere until
+`RAILS_ENV=production bin/rails railwatch:authentication:configure` sets a
+password) or, with Basic off, by `c.base_controller_class`.
+
+Railwatch 0.x's in-gem embedded mode (`c.transport = :local`, `plugin :railwatch`,
+the `railwatch`/`railwatch_telemetry` databases) is gone in 1.0; remove all three
+and add railwatch-server. Its old SQLite files are not migrated.
 
 ## Rake tasks
 
 | Task | Does |
 |---|---|
-| `bin/rails railwatch:doctor` | ✓/✗ per check. Embedded: databases, migrations, writer process, last write, maintenance, dashboard access, export. Cloud: token, token storage, ingest URL, reachability. Both: middleware, engine mount, deploy, sample rates, ignored types, Kamal hook, browser client and whether an entrypoint calls it, profiler backend, test matchers. Exits non-zero on a missing database, pending migrations, broken export, a missing or tracked token, or an unreachable host. **Run this first when telemetry is missing.** |
-| `bin/rails railwatch:authentication:configure` | Sets the embedded dashboard's HTTP Basic credentials for the current `RAILS_ENV`. |
-| `bin/rails railwatch:export:status` | What the export queue holds and whether it can send. |
-| `bin/rails railwatch:token` | Where to create a Railwatch Cloud ingest token for this app. |
-| `bin/rails railwatch:mcp` | Paste-ready MCP client configuration for this app's Railwatch Cloud. |
-| `bin/rails railwatch:deploy[ref,name,url]` | Records a deploy marker (in the embedded database, or on the cloud). Use as a release step when not deploying with Kamal. |
+| `bin/rails railwatch:doctor` | ✓/✗ per check: token, token storage, ingest URL, reachability, middleware, engine mount, deploy, sample rates, ignored types, Kamal hook, browser client and whether an entrypoint calls it, profiler backend, test matchers. Exits non-zero on a missing or tracked token, or an unreachable host. **Run this first when telemetry is missing.** |
+| `bin/rails railwatch:authentication:configure` | Sets the HTTP Basic credentials that gate railwatch-server's dashboard, for the current `RAILS_ENV`. |
+| `bin/rails railwatch:token` | Where to create an ingest token for this app on the server `ingest_url` points at. |
+| `bin/rails railwatch:mcp` | Paste-ready MCP client configuration for that server. |
+| `bin/rails railwatch:deploy[ref,name,url]` | Records a deploy marker on the server. Use as a release step when not deploying with Kamal. |
 | `bin/rails 'railwatch:sourcemaps[public,true]'` | Uploads Vite source maps for the configured deploy, then deletes acknowledged files. Run after building and before publishing assets. Omit `true` to retain files. See [Source maps](docs/source-maps.md). |
 
 ## Facade
@@ -89,9 +92,9 @@ Per action, in a controller class body: `railwatch_sample 0.01, only: :index`,
 ## Specs
 
 `require "railwatch/rspec"` in `spec/rails_helper.rb` (or `"railwatch/minitest"` in
-`test/test_helper.rb`). Railwatch must be enabled in the test env: an embedded
-install is, and needs `RAILS_ENV=test bin/rails db:prepare` once so its test
-databases exist; a cloud install needs any non-blank `RAILWATCH_TOKEN`. Records
+`test/test_helper.rb`). Railwatch must be enabled in the test env, which
+needs any non-blank `RAILWATCH_TOKEN` there (railwatch-server is off in test
+and does not set one). Records
 go to an in-memory transport, never over the wire. All matchers are block
 matchers.
 
@@ -117,7 +120,8 @@ melt in production.
 
 ## MCP
 
-Railwatch Cloud (not embedded mode) is an MCP server at `<ingest host>/mcp`.
+Railwatch Cloud and railwatch-rs are MCP servers at `<ingest host>/mcp`
+(with railwatch-server: the app's host plus `/railwatch/mcp`).
 Generate a personal token at Settings → Profile → "API & MCP token", then:
 
 ```sh

data/CHANGELOG.md

@@ -6,6 +6,72 @@
      filled in by the release commit, which is also the only commit that
      touches lib/railwatch/version.rb and Gemfile.lock. See CONTRIBUTING.md. -->
 
+## 1.0.0 (2026-10-22)
+
+- **Breaking: `railwatch` is the agent only.** It instruments the app and
+  sends to an ingest URL: Railwatch Cloud (the default,
+  `https://railwatch.rebulk.com`) or a self-hosted
+  [railwatch-rs](https://github.com/Rebulk/railwatch-rs) server
+  (`RAILWATCH_INGEST_URL`, `RAILWATCH_TOKEN`). Embedded mode is gone from
+  this gem: `transport :local` / `RAILWATCH_TRANSPORT`, the two SQLite
+  databases (`railwatch`, `railwatch_telemetry`) and their migrations, the
+  Puma writer (`plugin :railwatch`), the maintenance clock, export to the
+  cloud, the dashboard pages, its live channel and its compiled bundle.
+  The dashboard is part of the server now, and the gem has no runtime
+  dependency on `inertia_rails` or `tdigest`.
+  - The dashboard inside the app is the separate
+    [railwatch-server](https://github.com/Rebulk/railwatch-server) gem. It
+    runs the railwatch-rs server next to Puma and points this agent at it.
+  - Removed settings: `transport`, `issue_prefix`, `repository_url`,
+    `retention_days`, `dashboard_user`, `dashboard_open`, `writer_socket`,
+    `migration_busy_timeout`, and every `export_*`, with their
+    `RAILWATCH_*` variables. Removed rake tasks: `railwatch:vacuum`,
+    `railwatch:vacuum:status`, `railwatch:export:status`, `:rebind` and
+    `:discard`. Removed: `Railwatch.migrations_path`,
+    `Railwatch.url_helpers`, `Railwatch.frontend_path`.
+  - `http_basic_auth_enabled`, `http_basic_auth_user`,
+    `http_basic_auth_password`, `base_controller_class` and
+    `bin/rails railwatch:authentication:configure` stay. They are the gate
+    railwatch-server puts in front of its dashboard, and do nothing without
+    it.
+  - `bin/rails generate railwatch:install` sets up the agent only: token,
+    ingest URL (`--url` for a self-hosted server), the beacon mount, the
+    Kamal hook, the browser client and the test helpers. It no longer
+    writes `config/database.yml` or `config/puma.rb`, and `--cloud` is gone
+    because there is no other mode.
+  - The browser client moved to
+    `lib/generators/railwatch/install/templates/railwatch.ts`
+    (`Railwatch.browser_client_path`). Apps that already copied it keep
+    their copy at `app/frontend/lib/railwatch.ts`.
+  - Upgrading an embedded 0.x install: delete `c.transport = :local` (or
+    `RAILWATCH_TRANSPORT=local`), delete `plugin :railwatch` from
+    `config/puma.rb` (Puma refuses to boot with a plugin it cannot find),
+    and delete the `railwatch` and `railwatch_telemetry` entries from
+    `config/database.yml`. Then add `gem "railwatch-server"` and
+    `plugin :railwatch_server`. The old data in
+    `storage/<env>_railwatch.sqlite3` and
+    `storage/<env>_railwatch_telemetry.sqlite3` is not migrated: railwatch-rs
+    has no import for these files (`railwatch import-rails` reads a
+    Railwatch Cloud install, not this gem's embedded databases), so the new
+    dashboard starts empty. Keep the old files only if you want them; they
+    can be deleted.
+
+## 0.9.4 (2026-10-22)
+
+- Sampling recovers as soon as ingest does. A receiver refusing with a
+  `Retry-After` (a Railwatch server below its disk floor answers 503 with
+  `Retry-After: 60`) kept the app at 1/8 sampling for 50-60 s after it was
+  accepting again: the factor only halved per accepted delivery, and those
+  waited on 32-60 s backoff rungs. A refusal is now retried after its
+  `Retry-After` or 7.5-15 s, whichever is sooner (never sooner than the
+  backoff rung), and the first accepted delivery puts the factor back to
+  1x.
+- A refusal is no longer silent. One `[railwatch]` line when ingest starts
+  refusing, and one when it accepts again, with how many executions
+  backpressure sampled out and how many records were dropped meanwhile.
+  Both go through `on_unrecoverable` / `warn_on_data_loss`, like lost
+  batches.
+
 ## 0.9.3 (2026-10-18)
 
 - The dashboard's route helpers and its browser beacon follow the

data/README.md

@@ -6,37 +6,26 @@ outgoing HTTP, storage, views, and logs, and links them into one trace
 per execution, for about half a millisecond per request plus tens of
 microseconds per query, with zero writes to your database.
 
-By default all of it stays inside the app:
-[embedded mode](docs/embedded.md) serves the full dashboard at
-`/railwatch` out of two SQLite files your app owns, with no token, no
-Node, no Redis and no job worker. Railwatch Cloud is optional: it
-delivers alerts to Slack, email, webhooks or Linear (including when the
-app is down), serves MCP to your AI assistant, and puts many apps and
-servers in one place.
+The gem is the agent. It sends what it records over HTTPS to a
+Railwatch server, which stores it, groups exceptions into issues, sends
+alerts, and serves the dashboard and an MCP server:
 
-## Install
-
-```sh
-bundle add railwatch                  # 1. add the public gem
-bin/rails generate railwatch:install  # 2. embedded: databases, Puma writer, dashboard at /railwatch
-```
-
-Restart and open `/railwatch`. It is open in development; before you
-deploy, give it a password with
-`RAILS_ENV=production bin/rails railwatch:authentication:configure`
-(it answers 401 in production until you do). On a PostgreSQL or MySQL
-app without the `sqlite3` gem, the generator adds it to the Gemfile;
-run `bundle install` and `bin/rails db:prepare` to finish.
+- **Railwatch Cloud** at <https://railwatch.rebulk.com>, the default.
+- **Self-hosted [railwatch-rs](https://github.com/Rebulk/railwatch-rs)**,
+  one static binary for many apps ([Self-hosting](docs/self-hosting.md)).
+- **Embedded**: the [`railwatch-server`](https://github.com/Rebulk/railwatch-server)
+  gem runs that server next to Puma for one app and serves the dashboard
+  at `/railwatch`, with nothing else to run.
 
-To send everything to Railwatch Cloud instead, pass `--cloud` or a token
-option:
+## Install
 
 ```sh
-bundle add railwatch
-bin/rails generate railwatch:install --prompt-token  # hidden token input plus app wiring
+bundle add railwatch                                # 1. add the public gem
+bin/rails generate railwatch:install --prompt-token # 2. hidden token input plus app wiring
 bin/rails railwatch:doctor                          # check every piece is wired up after restart
 ```
 
+For a self-hosted server, add `--url=https://telemetry.example.com`.
 The generator's flags, getting a token, and deploying with Kamal,
 Docker, Heroku, or Render are covered in
 [Getting started](docs/getting-started.md). For an unreleased revision,
@@ -46,6 +35,36 @@ use the Git source instead:
 gem "railwatch", github: "Rebulk/railwatch"
 ```
 
+### Embedded
+
+To keep everything inside the app, add `railwatch-server` next to this
+gem:
+
+```ruby
+# Gemfile
+gem "railwatch"
+gem "railwatch-server"
+```
+
+```ruby
+# config/puma.rb
+plugin :railwatch_server
+```
+
+It provisions its data under `storage/railwatch/<env>` on first boot and
+points this gem at it, so there is no token to manage. The dashboard at
+`/railwatch` is open in development and answers 401 elsewhere until you
+give it a password with
+`RAILS_ENV=production bin/rails railwatch:authentication:configure`, or
+put it behind your own admin authentication
+([Configuration](docs/configuration.md#dashboard-gate-railwatch-server)).
+Everything else is in the
+[railwatch-server README](https://github.com/Rebulk/railwatch-server#readme).
+
+Railwatch 0.x kept embedded telemetry in two SQLite databases written by
+`plugin :railwatch`. 1.0 removes that mode; see
+[Coming from 0.x embedded mode](docs/getting-started.md#coming-from-0x-embedded-mode).
+
 ## What you get
 
 - Requests, jobs, scheduled tasks, commands, queries, exceptions, and
@@ -63,8 +82,8 @@ gem "railwatch", github: "Rebulk/railwatch"
   and browser errors ([Getting started](docs/getting-started.md)).
 - RSpec and Minitest matchers that turn a query budget into a CI gate
   ([Testing](docs/testing.md)).
-- With Railwatch Cloud, an MCP server so Claude Code, Cursor, VS Code, or
-  Zed can read your production data
+- An MCP server on the Railwatch server, so Claude Code, Cursor, VS Code,
+  or Zed can read your production data
   ([AI assistants and MCP](docs/ai-and-mcp.md)).
 
 Configuration lives in `config/initializers/railwatch.rb`; most options
@@ -85,36 +104,12 @@ expect { get "/widgets" }.to have_railwatch_queries(at_most: 6)
 expect { get "/widgets" }.not_to have_railwatch_n_plus_one
 ```
 
-## Embedded mode
-
-Telemetry goes to two SQLite files the app owns -- `railwatch` for
-issues, comments and saved views, `railwatch_telemetry` for what the app
-reports -- and the dashboard is served at `/railwatch` from a bundle
-shipped inside the gem. Nothing leaves the machine unless you turn on
-export to Railwatch Cloud, and there is nothing else to run.
-
-Puma forks a single writer process (`plugin :railwatch`, which the
-installer adds) that owns both files. The web workers hand it batches
-over a Unix socket instead of writing SQLite on their own threads, and it
-runs the maintenance clock too, so exception grouping, rollups, retention
-and threshold scans happen without a queue.
-
-That dashboard reads every query, log line and exception the app
-produced, so it is gated the way Mission Control Jobs is: HTTP Basic is
-on, and with no credentials every request is 401 until you set them
-with `bin/rails railwatch:authentication:configure`. Development is the
-exception: with no credentials set there, it is open. Apps that would
-rather use their own authentication turn Basic off and gate the pages
-with `base_controller_class` or a routes constraint around the mount; a
-`dashboard_user` resolver then names the operator and authorizes live
-updates, but does not gate pages. [Embedded mode](docs/embedded.md)
-covers all of it, including upgrades and what it costs to store.
-
 ## Documentation
 
-- [Getting started](docs/getting-started.md) — the embedded install, the
-  Railwatch Cloud install and its token, the three optional lines, and
-  deploying with Kamal, Docker, Heroku, Render, or none of them.
+- [Getting started](docs/getting-started.md) — the install and its token,
+  embedded with railwatch-server, moving from 0.x embedded mode, the three
+  optional lines, and deploying with Kamal, Docker, Heroku, Render, or none
+  of them.
 - [Configuration](docs/configuration.md) — every option and `RAILWATCH_*`
   variable, field by field.
 - [Record types](docs/records.md) — every record Railwatch ships and every
@@ -122,17 +117,13 @@ covers all of it, including upgrades and what it costs to store.
 - [Testing](docs/testing.md) — the RSpec and Minitest matchers, and a CI
   performance gate.
 - [AI assistants and MCP](docs/ai-and-mcp.md) — connecting Claude Code,
-  Cursor, VS Code, or Zed to your production data through Railwatch
-  Cloud.
+  Cursor, VS Code, or Zed to your production data.
 - [Replacing Sentry](docs/replacing-sentry.md) — a step-by-step migration,
   option by option and call site by call site.
 - [Coming from Laravel Nightwatch](docs/replacing-nightwatch.md) — the
   record-type mapping and the sampling model, for Laravel people.
-- [Embedded mode](docs/embedded.md) — the default: the whole dashboard
-  inside your app, telemetry in your own SQLite files, and optional
-  export to Railwatch Cloud.
 - [Self-hosting](docs/self-hosting.md) — pointing the gem at your own
-  Railwatch Cloud.
+  railwatch-rs server.
 - [Troubleshooting](docs/troubleshooting.md) — every failure mode, paired
   with the `railwatch:doctor` line it shows up as.
 - [FAQ](docs/faq.md) — overhead numbers, retention, PII posture, SQLite.

data/config/routes.rb

@@ -2,63 +2,4 @@
 
 Railwatch::Engine.routes.draw do
   post "beacon", to: "beacon#create"
-
-  # The embedded dashboard. Same URL shape as the hosted platform so the
-  # prebuilt bundle's route helpers resolve unchanged once js-routes knows
-  # the mount point; a singleton install always answers for app 1, env 1.
-  root to: redirect { |_p, req| "#{req.script_name}/apps/1/envs/1" }
-  get "dashboard", to: redirect { |_p, req| "#{req.script_name}/apps/1/envs/1" }
-  get "docs", to: redirect("https://railwatch.rebulk.com/docs")
-
-  scope "apps/:application_id", as: :application do
-    get "/", to: redirect { |p, req| "#{req.script_name}/apps/#{p[:application_id]}/envs/1" }
-    scope "envs/:environment_id", as: :environment do
-      get "/", to: "overview#show", as: :overview
-      resources :requests, only: [ :index, :show ] do
-        get "routes/:group_hash", to: "requests#route", on: :collection, as: :route
-      end
-      resources :jobs, only: [ :index, :show ] do
-        get "classes/:group_hash", to: "jobs#klass", on: :collection, as: :klass
-      end
-      resources :scheduled_tasks, only: [ :index, :show ]
-      resources :commands, only: [ :index, :show ]
-      resources :executions, only: [ :show ]
-      resources :queries, only: [ :index, :show ]
-      resources :spans, only: [ :index, :show ]
-      resources :profiles, only: [ :index, :show ]
-      resources :attachments, only: [ :show ]
-      get "traces/:trace_id", to: "traces#show", as: :trace
-      resources :view_renders, path: "views", only: [ :index ]
-      resources :transactions, only: [ :index ]
-      resources :deprecations, only: [ :index ]
-      resources :exceptions, only: [ :index ]
-      resources :cache_events, path: "cache", only: [ :index ]
-      resources :mails, path: "mail", only: [ :index ]
-      resources :notifications, only: [ :index ]
-      resources :broadcasts, only: [ :index ]
-      resources :outgoing_requests, only: [ :index ]
-      resources :llm_calls, path: "llm", only: [ :index ]
-      resources :storage_ops, path: "storage", only: [ :index ]
-      resources :logs, only: [ :index ]
-      resources :people, path: "users", only: [ :index, :show ]
-      resources :deploys, only: [ :index, :show ]
-      resources :releases, only: [ :index, :show ]
-      resources :visits, only: [ :index ]
-      resources :processes, only: [ :index ]
-      resources :tenants, only: [ :index, :show ]
-      resources :saved_views, only: [ :create, :update, :destroy ]
-      resources :thresholds, only: [ :index, :create, :update, :destroy ]
-      resources :anomaly_rules, only: [ :create, :update, :destroy ]
-      resources :alerts, only: [ :index ]
-    end
-  end
-
-  resources :issues, only: [ :index, :show, :update ] do
-    resources :comments, only: [ :create ]
-    post :bulk, on: :collection
-    get :merge_candidates, on: :member
-  end
-  resources :alerts, only: [ :index ] do
-    post :retry, on: :member
-  end
 end

data/docs/ai-and-mcp.md

@@ -1,6 +1,7 @@
 # AI assistants and MCP
 
-Railwatch Cloud is an [MCP](https://modelcontextprotocol.io) server. Point
+Railwatch Cloud, and any railwatch-rs server, is an
+[MCP](https://modelcontextprotocol.io) server. Point
 Claude Code, Claude Desktop, Cursor, VS Code, or Zed at it and the assistant
 sitting in your editor can read the same production data your dashboards
 show: issues and their stack traces, slow routes, the queries and N+1s
@@ -9,13 +10,13 @@ crash-free rates per release. It can also write — resolve an issue, set a
 priority, leave a comment — and every write is signed with your user and the
 agent's name in the issue's activity feed.
 
-MCP is a Railwatch Cloud feature. The embedded dashboard at `/railwatch`
-does not serve it; an embedded install gets it by
-[exporting to the cloud](embedded.md#three-ways-to-run-it).
-
 The endpoint is `<your ingest host>/mcp`. For the hosted platform that's
 `https://railwatch.rebulk.com/mcp`; if you self-host, it is your own host (see
-[`self-hosting.md`](self-hosting.md)). The gem knows which one you're on:
+[`self-hosting.md`](self-hosting.md)). With the `railwatch-server` gem the
+server runs under the app's dashboard path, so the endpoint is the app's own
+host plus `/railwatch/mcp`; see the
+[railwatch-server README](https://github.com/Rebulk/railwatch-server#readme).
+For Railwatch Cloud and a self-hosted server the gem knows which one you're on:
 
 ```sh
 bin/rails railwatch:mcp
@@ -225,9 +226,9 @@ Copy either into your own app's repo to give its agent the same context.
 
 ## See also
 
-- [`getting-started.md`](getting-started.md) — install, the cloud token,
+- [`getting-started.md`](getting-started.md) — install, the token,
   first request.
 - [`self-hosting.md`](self-hosting.md) — pointing the gem, and this endpoint,
-  at your own platform.
+  at your own server.
 - [`troubleshooting.md`](troubleshooting.md) — when something isn't
   reporting.