nylorun 0.9.0-beta → 0.11.1-beta

package/CHANGELOG.md

@@ -1,5 +1,92 @@
 # nylorun
 
+## 0.11.1-beta
+
+### Patch Changes
+
+- Pin runtime to the tested release.
+- Pin studio to the tested release.
+
+## 0.11.0-beta
+
+### Minor Changes
+
+- 713e676: **Remote MCP servers only (blueprint D47).** Nylorun accepts `streamable-http` and `sse` MCP servers, declared by URL and reached through the gates; stdio servers and plugin roots are gone. See MIGRATION.md.
+
+  - **Breaking (`@nylorun/core`):** `McpServerManifest` and the manifest schema keep only `streamable-http` and `sse`. A `stdio` server is refused by `.mcp({...})` (`McpError`, code `mcp.stdio`), by `Agent.from` and by the wire schema, all with one message (`stdioMcpRefusal`): "MCP server 'x' uses stdio; Nylorun accepts remote MCP servers only (streamable-http or sse). Run the server behind an HTTP transport and declare its URL." `PutAgentRequest` loses `pluginRoots`, `CapabilityDeclaration` loses `pluginRoot`, and the Harness API's `RunRouting` loses `pluginRoots`.
+  - **Breaking (`@nylorun/agents`):** `.plugin()` and `plugin()` throw `PluginError` (code `plugin.mcp-stdio`) for a stdio server in a plugin's `mcp.json`; its remote servers and skills load as before. `saveAgent` no longer sends plugin roots. `prepareStdioLaunch`, `expandPluginPlaceholders` and `StdioLaunch` are removed.
+  - **Breaking (`@nylorun/runtime`):** no stdio MCP launcher: `PUT /v1/agents/:id` refuses a stdio server (`400`) and `pluginRoots`. `TenantConfig.childEnv`, `TenantPaths.pluginData` and `tmp`, `tenantChildEnvironment`, `startEphemeralRuntime({ baseline })` and `configForFactory`'s `baseline` and `hostConfig` are removed; the harness service no longer takes `childEnv` or `paths.pluginData`.
+  - `nylorun`: the local stack no longer mounts the Host root's `plugins/` into the runtime and harness containers, nor the Tenant's `plugin-data/`, `home/` and `tmp/` into the harness, which now mounts only `sandboxes/`.
+
+- c135267: **Action endpoints are removed (manifest-only agents, M6).** The Runtime runs no code of yours during a session: an agent's tools are HTTP tools, remote MCP servers, agents used as tools and the Runtime's built-ins. Protocol stays 8; the `action-endpoints` feature is gone, so a client that requires it is refused. See MIGRATION.md, "Action endpoints are removed".
+
+  - **Breaking (`@nylorun/core`):** the `Action`, endpoint (`PutEndpointsRequest`, `Endpoint`, `EndpointHealth`, …) and delivery schemas, `SIGNATURE_HEADER`, `OUTCOME_HEADER`, `DELIVERY_TOKEN_TYPE` and the `action.*` events (`action.pending`, `.delivered`, `.delivery_failed`, `.completed`, `.uncertain`) are removed, and `ToolDefinition.background` with them. `ActionOutcome` is renamed `EffectOutcome`. Tenant status loses `checks.endpoints`, `agents[].registered` and `agents[].endpoint`, and `counts.pendingActions`; the session view loses `actions`. A `turn.paused` interaction carries the tool call's `callId`. New `codeToolsOf` and `codeToolRefusal` name a definition's tools that would run your code. The Harness API is v2 (`HARNESS_API_VERSION = 2`): `TurnStart.options.holdMs` and `effect.resolved` are removed.
+  - **Breaking (`@nylorun/harness`):** held runs are gone: `createHarness` loses `holdMs`, and `apiHost` its `hold` option.
+  - **Breaking (`@nylorun/agents`):** `createActionHandler`, `executeAction`, `createActionSandbox`, `definitionDeclaresSandbox`, `isActionSandboxTool` and the `Action`, `ActionOutcome`, `ActionHandler`, `ActionHandlerOptions`, `RegisterOptions`, `ExecuteActionOptions` and `ExecutableDefinition` types are removed. `saveAgent` refuses a code tool (`tool({ run })`) or a flow tool stage before sending; its `implementationVersion` is optional (`NYLORUN_IMPLEMENTATION_VERSION`, else `dev`).
+  - **Breaking (`@nylorun/runtime`):** `/v1/endpoints` and `/v1/actions/*` answer `404`; delivery tokens, the deliverer, background tools, held runs (`TenantConfig.actionHoldMs`), `DurableExecution.deliver`, the Restate `NylorunAction` object, the `action_result` wake and the gates service's `/nylorun/v1/deliveries` are removed, and a migration drops the `actions` and `endpoints` tables. `PUT /v1/agents/:id` refuses a definition with a code tool or a flow tool stage (`400`); a tool the Runtime cannot run fails with `tool.unavailable`. The fixture model answers in text when the agent offers no `lookup_order` tool.
+  - **Breaking (`@nylorun/cli`):** `nylo endpoints` is removed (a usage error that says why); `nylo status` shows uncertain effects instead of pending Actions.
+  - **Breaking (`@nylorun/create-agent`):** the starter saves its agent with `saveAgent` and runs no server: no Action endpoint, `PORT` or `NYLORUN_ACTIONS_URL`. Its assistant has no tools, with a commented `http()` tool to start from.
+  - `nylorun`: the local stack's comments speak of MCP servers and HTTP tools on this machine, not Action endpoints.
+  - `@nylorun/studio`: the `action.*` event views and delivery status are removed; the chat shows `tool.completed`, and the Agent Manifest tab lists tools without a target as code tools.
+
+### Patch Changes
+
+- Pin core to the tested release.
+- Pin runtime to the tested release.
+- Pin studio to the tested release.
+- Updated dependencies [4bd2a0b]
+- Updated dependencies [a64aaca]
+- Updated dependencies [40b7648]
+- Updated dependencies [713e676]
+- Updated dependencies [c135267]
+- Updated dependencies [d36f0d9]
+- Updated dependencies [107b07d]
+  - @nylorun/core@0.15.0-beta
+
+## 0.10.0-beta
+
+### Major Changes
+
+- 7f763c3: **The Admin API and the operator listener are gone (Runtime and Management APIs, step A5).** Host work moves to the machine: `nylorun` runs `nylorun-operate` inside the runtime container, and every remote client uses the Runtime API or the Management API.
+
+  - **Breaking (`@nylorun/runtime`):** `/v1/admin/*` (status, host, shutdown, keys, openapi.json) is removed; it answers like any unknown route. The operator listener, `NYLORUN_ADMIN_LISTEN_PORT`, `NYLORUN_ADMIN_LISTEN_HOST`, `NYLORUN_ADMIN_ALLOWED_HOSTS` and `host.json`'s `adminPort` are gone, and so is the `admin-openapi.json` package file. Stop the Host with SIGTERM. `nylorun-operate status [--json]` reports the version, protocol and the Tenant's id, name, state and cause, exiting 2 when the Tenant is not open. `/ready` adds `harness: { mode, connected }` while the Tenant is open. `startEphemeralRuntime` loses `operatorListener` and `adminUrl`. The admin key stays: it derives Studio's key.
+  - **Breaking (`@nylorun/admin`):** `createAdmin()` is the Management API client (`tenant`, `keys`, `models`, `vaults`, `signingKeys`, `settings`) with a management key: explicit `{ url, key }`, else `NYLORUN_RUNTIME_URL` + `NYLORUN_MANAGEMENT_KEY`, else the Project link's or the local Host root's management key. `status()`, `adminUrl`, the Admin API keys, `NYLORUN_ADMIN_URL`/`NYLORUN_ADMIN_KEY` and `OPERATOR_KEYS_FEATURE` are removed; `deriveStudioToken` and `mintStudioLoginToken` stay.
+  - **Breaking (`@nylorun/core`):** `admin-status` leaves `PROTOCOL_FEATURES` (the Host still advertises it for protocol 5–7 clients) and `operator-keys` is removed; `AdminStatusSchema`, `AdminHostStatusSchema`, `HostAggregateSchema` and `HostShutdownResponseSchema` are removed.
+  - **Breaking (`nylorun`):** no admin port: `NYLORUN_ADMIN_PORT` is no longer written or published (an existing one is ignored). `nylorun start` waits for `/ready`, and `nylorun status` reads readiness from `/ready` and the Tenant from `nylorun-operate status`.
+  - `@nylorun/cli`: `nylo status` no longer falls back to the Admin API; when the Tenant does not answer it points to `npx nylorun status`.
+
+### Minor Changes
+
+- 3b3bdc6: **The clients use management keys (Runtime and Management APIs, step A3).** The protocol stays at 7; every client keeps working against a protocol 7 Runtime's routes.
+
+  - `nylorun`: `nylorun start` keeps an application key (`project`) and a management key (`project-management`) for a Project, in `<Host root>/project-credentials.json` and the Project's `.nylorun/credentials.json` (still format 1, with new `managementKey` and `managementPrincipalId` fields). A credentials file holding only an application key gains a management key at the next start. Commands outside a project keep `cli` and `cli-management`. Keys are issued through `nylorun-operate` in the runtime container instead of the Admin API, and `nylorun key put <id> --management` puts a management key. Seeding the Tenant and `nylorun mcp connect` use the management key (`/v1/tenant/vaults`). Studio reaches the Runtime's public listener.
+  - `@nylorun/cli`: `status`, `reset`, `configure`, `doctor` and `access signing-keys` use the Management API through `@nylorun/admin` with the Project's management key, or `NYLORUN_MANAGEMENT_KEY`.
+  - `@nylorun/studio`: local Studio needs no login. A request on the published loopback address (`localhost` or `127.0.0.1` at Studio's port) acts as signed in; hosts behind a sign-in proxy and embedding keep their login, and state-changing requests still need Studio's own `Origin`. Studio learns its Tenant from `GET /v1/tenant` with its key instead of the Admin API, and its Connections page manages vaults through `@nylorun/admin/client` at `/v1/tenant/vaults`.
+  - **Breaking (`@nylorun/admin`, `@nylorun/runtime`): Studio's key is derived from the admin key alone.** `deriveStudioToken(adminKey)` takes no Tenant id (HMAC-SHA256 over `nylorun/studio/v2`). The Host registers the new key's hash at its next start, replacing the old one; an app that embeds Studio and derives its key must update.
+  - `@nylorun/core`: `ProjectCredentialsFileSchema` gains optional `managementKey` and `managementPrincipalId`.
+
+### Patch Changes
+
+- b28bdd7: **Local MCP servers work on a local Tenant, and a server that does not connect shows.** Additive; the protocol stays at 7.
+
+  - `@nylorun/runtime`: remote MCP servers (`streamable-http`, `sse`) are reached under the Host's address policy, as Action endpoints are (`NYLORUN_ENDPOINT_*`, `tenant/outbound.ts`). In the local Docker stack `localhost`, `127.0.0.1` and `[::1]` now mean the machine that runs Docker (`host.docker.internal`), so `.mcp({ x: { type: "streamable-http", url: "http://localhost:3002/x" } })` connects where it used to fail with `fetch failed`. With `NYLORUN_ENDPOINT_PRIVATE=refuse` a server on a private address is refused; with `NYLORUN_ENDPOINT_HTTP=refuse` an `http` server is refused. Redirects are still not followed. A connection failure now names its cause (`connect ECONNREFUSED …`) instead of `fetch failed`. This applies in the gateway, a harness process and an in-process Tenant. `guardedFetch` takes `stream: true`: the answer streams, unbounded, with no timeout but the caller's signal.
+  - `@nylorun/core`: new session event `mcp.discovered`, recorded once on the session's first turn with the MCP snapshot: one entry per declared server with `outcome` (`connected`, `refused`, `failed`), `message` and the number of `tools` it added (`McpDiscoveredPayloadSchema`, `McpServerOutcomeSchema`). A server that does not connect adds no tools for the session's life; this is where that shows in the event log, beside `mcpDiagnostics`.
+  - `@nylorun/agents`: `.plugin()` and `plugin()` emit a process warning (`NylorunPluginWarning`, the diagnostic's code) for each part of the package they skip, so building or registering the agent says when a plugin's MCP server was dropped. The `plugin.mcp-server-skipped` message now says why: for example, plain `http` is accepted only for `localhost`, `127.0.0.1` or `[::1]`.
+  - `@nylorun/studio`: the event list labels `mcp.discovered` and summarizes each server's outcome.
+
+- 7a22f7f: **`nylorun start` opens no browser.** `start` (and `up`) prints the Runtime and Studio URLs, says to run `nylorun studio` to sign a browser in to Studio, and ends with a pointer to `nylorun --help`. It no longer mints a Studio login token or opens Studio, also in a terminal. `--no-open` is still accepted and ignored. `nylorun studio` signs a browser in as before.
+- Pin core to the tested release.
+- Pin runtime to the tested release.
+- Pin studio to the tested release.
+- Updated dependencies [3b3bdc6]
+- Updated dependencies [6576e12]
+- Updated dependencies [b28bdd7]
+- Updated dependencies [cc107b1]
+- Updated dependencies [7f763c3]
+- Updated dependencies [98b0d37]
+- Updated dependencies [c66d8ed]
+  - @nylorun/core@0.14.0-beta
+
 ## 0.9.0-beta
 
 ### Major Changes

package/README.md

@@ -34,8 +34,8 @@ npx nylorun doctor                 # Node 24+, Docker, Compose v2, and the Tenan
 ## Commands
 
 ```sh
-nylorun up|start [--tenant <name>] [--no-link] [--no-studio] [--no-open] [--allow-downgrade] [--studio-embed-origin <origin>]... [--studio-embed-origin-reset] [--restate-ui]
-                                   # create (first run) and start the Tenant; link the project; print the URLs; open Studio signed in
+nylorun up|start [--tenant <name>] [--no-link] [--no-studio] [--allow-downgrade] [--studio-embed-origin <origin>]... [--studio-embed-origin-reset] [--restate-ui]
+                                   # create (first run) and start the Tenant; link the project; print the URLs
                                    # --restate-ui (or NYLORUN_RESTATE_UI=1): publish Restate's UI on loopback for this start
 nylorun down|stop [--tenant <name> | --all]   # stop the containers (--all: every Tenant's); keep volumes
 nylorun status [--tenant <name>] [--json]   # the Tenant, its Host root and id, services, endpoints, Runtime health
@@ -46,7 +46,7 @@ nylorun ls [--json]                # the Tenants on this machine, with their sta
 nylorun delete <tenant> --yes      # remove a Tenant: containers, volumes, Host root and vault key
 nylorun sandbox ls [--tenant <name>] [--label <key=value>]... [--json]   # the running Tenant's sandboxes
 nylorun sandbox rm <id> [--tenant <name>]   # delete a sandbox and its files
-nylorun key put <id> [--tenant <name>]      # create or rotate the Tenant's operator key <id>; prints it once
+nylorun key put <id> [--management] [--tenant <name>]   # create or rotate the Tenant's application key <id> (--management: a management key); prints it once
 nylorun key list [--tenant <name>] [--json] # the Tenant's keys: id, role, when issued
 nylorun key rm <id> [--tenant <name>]       # delete a key: it stops working at once
 nylorun mcp connect <url> --server <name> [--vault <id>] [--client-id <id>] [--tenant <name>] [--no-open]   # sign the Tenant in to a remote MCP server with OAuth
@@ -135,18 +135,22 @@ recorded version.
 ## The Project link
 
 `nylorun start` in a project waits until the Tenant is open
-(`/v1/admin/status`), then writes, in a `.nylorun/` directory (mode 0700, with
+(`/ready`), then writes, in a `.nylorun/` directory (mode 0700, with
 its own `.gitignore` of `*`):
 
 - `link.json`: `{ "format": 3, "tenant", "tenantId", "hostUrl", "hostId" }`.
   `tenant` is the local Tenant's name; the Tenant id is information only:
   nothing in a request selects a Tenant.
 - `credentials.json` (mode 0600): `{ "format": 1, "applicationKey",
-  "principalId" }`, the operator key `project`. A later `start` keeps the file
-  while its key still reaches the Tenant (one authenticated read); otherwise it
-  writes the Tenant's `project` key, which the Host root keeps in
-  `project-credentials.json` (mode 0600) so every checkout linked to the Tenant
-  shares one key, or puts a new one through the Admin API.
+  "principalId", "managementKey", "managementPrincipalId" }`, the application
+  key `project` (for the Runtime API) and the management key
+  `project-management` (for the Management API). A later `start` keeps the file
+  while both keys still reach the Tenant (one authenticated read each);
+  otherwise it writes the Tenant's `project` and `project-management` keys,
+  which the Host root keeps in `project-credentials.json` (mode 0600) so every
+  checkout linked to the Tenant shares them, or puts new ones through
+  `nylorun-operate keys`. A file from an earlier release, with only an
+  application key, keeps it and gains the management key.
 
 Later starts reuse the Tenant and rewrite the link only when the Tenant's name,
 URL, Host or id changed (after `nylorun reset`, for example). When it writes a
@@ -162,19 +166,28 @@ both share it. `--no-link` starts a Tenant without linking the working
 directory (scripts). A link of an older nylorun (format 0 to 2) counts as no
 link: `start` replaces it.
 
-No key is derived from the admin key but Studio's. A project holds the operator
-key `project`; a key an older nylorun derived for it keeps working while it
-authenticates and is replaced by the operator key otherwise.
-
-## Operator keys
-
-`nylorun key put <id>` creates the running Tenant's key `<id>` (or rotates it:
-the previous key stops working at once) and prints it once on stdout.
-`nylorun key list [--json]` shows each key's id, role and when it was issued,
-never the keys; `nylorun key rm <id>` deletes one. Ids match
-`^[a-z][a-z0-9-]{0,31}$`; `studio` belongs to Studio and is refused. Give each
-app server its own key. `nylorun sandbox` and `nylorun mcp` use the linked
-project's key, or the key `cli` they put once and keep in
+No key is derived from the admin key but Studio's. A project holds the
+application key `project` and the management key `project-management`; a key
+an older nylorun derived for it keeps working while it authenticates and is
+replaced by the application key otherwise.
+
+## Keys
+
+Every Tenant serves the Runtime API, which takes **application keys**, and the
+Management API (`/v1/tenant/*`), which takes **management keys**
+([SELF_HOSTING.md](../SELF_HOSTING.md#keys)). `nylorun key` manages both on the
+running Tenant through `nylorun-operate` in its runtime container, so only this
+machine can issue a management key.
+
+`nylorun key put <id>` creates the application key `<id>` (or rotates it: the
+previous key stops working at once) and prints it once on stdout; with
+`--management` it puts a management key. `nylorun key list [--json]` shows each
+key's id, role and when it was issued, never the keys; `nylorun key rm <id>`
+deletes one. Ids match `^[a-z][a-z0-9-]{0,31}$`; `studio` belongs to Studio and
+`bootstrap` to `NYLORUN_MANAGEMENT_KEY_FILE`, and both are refused. Putting an
+id that holds the other role is refused. Give each app server its own
+application key. `nylorun sandbox` and `nylorun mcp` use the linked project's
+keys, or the keys `cli` and `cli-management` they put once and keep in
 `<Host root>/cli-credentials.json` (mode 0600).
 
 `nylorun mcp connect <url> --server <name>` signs the running Tenant in to a
@@ -201,12 +214,9 @@ project, and each has the label `dev.nylorun.tenant: <name>`. For Tenant `shop`:
 | Volumes | `nylorun-shop-postgres`, `nylorun-shop-restate`, `nylorun-shop-s2-lite`, `nylorun-shop-rustfs`, `nylorun-shop-workspaces` |
 
 The `harness` container (the Runtime image as `--service harness`) runs agent
-turns, stdio MCP servers and workspaces, apart from the `runtime` container. It
-holds only the harness token (`NYLORUN_HARNESS_TOKEN` in `.env`), mounts only
-the Tenant directory's `sandboxes/`, `plugin-data/`, `home/` and `tmp/`, and the
-Host root's `plugins/` read-only at its own path: put a plugin whose stdio MCP
-server the agent runs under `~/.nylorun/tenants/<name>/plugins/` and load it from
-there. `NYLORUN_HARNESS=in-process` in `.env` rolls back to running them in the
+turns and workspaces, apart from the `runtime` container. It holds only the
+harness token (`NYLORUN_HARNESS_TOKEN` in `.env`) and mounts only the Tenant
+directory's `sandboxes/`. `NYLORUN_HARNESS=in-process` in `.env` rolls back to running them in the
 `runtime` container (no `harness` container); `nylorun status` shows which.
 
 Postgres initialises the Tenant's database with C collation. Restate runs with
@@ -214,8 +224,8 @@ its own defaults. A running Tenant uses about 1.2 GB, most of it Restate; stop
 the Tenants you are not using (`nylorun stop`, or `nylorun stop --all`). The Runtime and Studio images are pinned by
 this release (`package.json` `nylorun.runtime` and `nylorun.studio`);
 `NYLORUN_RUNTIME_IMAGE` and `NYLORUN_STUDIO_IMAGE` override them (local builds,
-CI). Ports publish on loopback only: the Runtime on `8787`, its operator
-listener (Admin API) on `8788` and Studio on `4161`, or free ports chosen on the
+CI). Ports publish on loopback only: the Runtime on `8787` and Studio on
+`4161`, or free ports chosen on the
 Tenant's first start, avoiding the ports other Tenants keep, and kept in its
 `.env`. Restate's UI and admin API (unauthenticated) are not published; `nylorun
 start --restate-ui` (or `NYLORUN_RESTATE_UI=1`) publishes them for that start on
@@ -223,14 +233,18 @@ start --restate-ui` (or `NYLORUN_RESTATE_UI=1`) publishes them for that start on
 
 `start`, `status`, `ls` and `nylorun studio` give Studio as
 `http://localhost:<port>` (`studio.url` in `status --json`). Studio has no
-password: in a terminal (not in CI, and not with `--no-open`), `start` asks the
-Studio container for a single-use login token with the admin key (`POST
-/_studio/login-tokens`) and opens `http://localhost:<port>/login?token=…` on the
-Tenant's page in the browser. That sets a session cookie for 30 days, which
-survives Studio restarts, so the printed URL keeps working in that browser. The
-token itself is never printed unless no browser starts. Otherwise `start` says
-to run `nylorun studio`, which signs a browser in the same way; `nylorun studio
---no-open` prints the login URL (it works once, for two minutes) instead.
+password, and `start` opens no browser: it prints the URLs and says to run
+`nylorun studio` to sign a browser in (`--no-open` is accepted and ignored).
+`nylorun studio` asks the Studio container for a single-use login token with the
+admin key (`POST /_studio/login-tokens`) and opens
+`http://localhost:<port>/login?token=…` on the Tenant's page in the browser.
+That sets a session cookie for 30 days, which survives Studio restarts, so the
+printed URL keeps working in that browser. The token itself is never printed
+unless no browser starts; `nylorun studio --no-open` prints the login URL (it
+works once, for two minutes) instead.
+Studio needs no login on its published loopback address (`localhost` or
+`127.0.0.1` at its port): a browser on this machine is served as signed in. A
+host behind a sign-in proxy and an embedding app keep their sign-in.
 
 Browsers share cookies across the ports of one host, so each Tenant's Studio
 sets its own session cookie, `nylorun_studio_<name>`
@@ -309,8 +323,8 @@ bind-mounted into the Runtime and Studio containers, and holds `tenant.json`
 (`{ "format": 1, "name", "project"? }`: the Tenant's name and the project it
 was created for), `host.json` (the client-facing host and port),
 `host-credentials.json` (the admin key, mode 0600), `project-credentials.json`
-and `cli-credentials.json` (the operator keys `project` and `cli`, mode 0600, when
-they were put), the Docker Compose files in `docker/`, the Tenant directory `tenant/` (homes, logs) and `keys/vault-kek`,
+and `cli-credentials.json` (the keys `project` and `project-management`, `cli`
+and `cli-management`, mode 0600, when they were put), the Docker Compose files in `docker/`, the Tenant directory `tenant/` (homes, logs) and `keys/vault-kek`,
 the Tenant's vault key, which only the gateway container mounts. The Tenant's data lives in its Postgres, Restate and S2 volumes.
 
 `nylorun reset` deletes the selected Tenant's volumes, `tenant/` and `keys/`, and keeps

package/dist/doctor.js

@@ -42,7 +42,7 @@ export async function doctorStack(options) {
         (!report.tenant.runtime.healthy ||
             !report.tenant.gateway.healthy ||
             (report.tenant.harness.mode === "remote" && !report.tenant.harness.healthy) ||
-            report.tenant.tenant?.cause !== undefined);
+            (report.tenant.tenant !== undefined && report.tenant.tenant.state !== "open"));
     const failed = !nodeOk || !checks.docker.ok || checks.compose?.ok === false || broken;
     if (options.json) {
         log(JSON.stringify(report, null, 2));
@@ -103,7 +103,7 @@ export async function doctorStack(options) {
                     "tenant id",
                     local.tenant.state === "open"
                         ? `✓ ${local.tenant.id ?? "?"} open`
-                        : `✗ ${local.tenant.id ?? "?"} unavailable${local.tenant.cause ? `: ${local.tenant.cause.code}: ${local.tenant.cause.repair}` : " (opening)"}`,
+                        : `✗ ${local.tenant.id ?? "?"} unavailable${local.tenant.cause || local.tenant.message ? `: ${[local.tenant.cause, local.tenant.message].filter(Boolean).join(": ")}` : " (opening)"}`,
                 ]);
             rows.push(["studio", `${local.studio.url ?? "?"} · ${local.studio.state}`]);
         }

package/dist/project/link.d.ts

@@ -22,16 +22,24 @@ export declare function writeProjectLink(projectRoot: string, link: {
     hostId: string;
     tenantId: string;
 }): Promise<void>;
-/** An application key and its principal: `credentials.json`'s content (format 1). */
+/**
+ * An application key and its principal, and the management key and its principal when the file
+ * has one: `credentials.json`'s content (format 1).
+ */
 export interface KeyCredentials {
     applicationKey: string;
     principalId: string;
+    management?: {
+        key: string;
+        principalId: string;
+    };
 }
-/** The Project's application key and principal, or undefined when absent or unreadable. */
+/** The Project's keys, or undefined when absent or unreadable. */
 export declare function readProjectCredentials(projectRoot: string): Promise<KeyCredentials | undefined>;
 /**
- * A credentials file (`{ format: 1, applicationKey, principalId }`): the Project's, or one the
- * nylorun commands keep in the Host root. Undefined when absent or unreadable.
+ * A credentials file (`{ format: 1, applicationKey, principalId, managementKey?,
+ * managementPrincipalId? }`): the Project's, or one the nylorun commands keep in the Host root.
+ * Undefined when absent or unreadable.
  */
 export declare function readCredentialsFile(path: string): Promise<KeyCredentials | undefined>;
 /** `.nylorun/credentials.json` (format 1, mode 0600). */

package/dist/project/link.js

@@ -67,20 +67,27 @@ export async function writeProjectLink(projectRoot, link) {
         tenantId: link.tenantId,
     });
 }
-/** The Project's application key and principal, or undefined when absent or unreadable. */
+/** The Project's keys, or undefined when absent or unreadable. */
 export async function readProjectCredentials(projectRoot) {
     return await readCredentialsFile(credentialsPath(projectRoot));
 }
 /**
- * A credentials file (`{ format: 1, applicationKey, principalId }`): the Project's, or one the
- * nylorun commands keep in the Host root. Undefined when absent or unreadable.
+ * A credentials file (`{ format: 1, applicationKey, principalId, managementKey?,
+ * managementPrincipalId? }`): the Project's, or one the nylorun commands keep in the Host root.
+ * Undefined when absent or unreadable.
  */
 export async function readCredentialsFile(path) {
     try {
         const value = JSON.parse(await readFile(path, "utf8"));
-        return typeof value.applicationKey === "string" && typeof value.principalId === "string"
-            ? { applicationKey: value.applicationKey, principalId: value.principalId }
-            : undefined;
+        if (typeof value.applicationKey !== "string" || typeof value.principalId !== "string")
+            return undefined;
+        return {
+            applicationKey: value.applicationKey,
+            principalId: value.principalId,
+            ...(typeof value.managementKey === "string" && typeof value.managementPrincipalId === "string"
+                ? { management: { key: value.managementKey, principalId: value.managementPrincipalId } }
+                : {}),
+        };
     }
     catch {
         return undefined;
@@ -97,5 +104,11 @@ export async function writeCredentialsFile(path, credentials) {
         format: 1,
         applicationKey: credentials.applicationKey,
         principalId: credentials.principalId,
+        ...(credentials.management
+            ? {
+                managementKey: credentials.management.key,
+                managementPrincipalId: credentials.management.principalId,
+            }
+            : {}),
     });
 }

package/dist/project/seed.d.ts

@@ -21,7 +21,8 @@ export declare function readProjectEnv(projectRoot: string): Record<string, stri
 export declare function seedTenant(input: {
     fetch: FetchLike;
     runtimeUrl: string;
-    applicationKey: string;
+    /** The Project's management key: seeding is the Management API's. */
+    managementKey: string;
     projectRoot: string;
 }): Promise<SeedResult>;
 export {};

package/dist/project/seed.js

@@ -45,11 +45,11 @@ function modelFromEnv(env, projectRoot) {
     }
     return undefined;
 }
-async function call(fetch, url, applicationKey, init = {}) {
+async function call(fetch, url, managementKey, init = {}) {
     const response = await fetch(url, {
         ...(init.method ? { method: init.method } : {}),
         headers: {
-            authorization: `Bearer ${applicationKey}`,
+            authorization: `Bearer ${managementKey}`,
             [PROTOCOL_HEADER]: String(PROTOCOL_VERSION),
             accept: "application/json",
             ...(init.body === undefined ? {} : { "content-type": "application/json" }),
@@ -76,7 +76,7 @@ export async function seedTenant(input) {
     const result = { applied: [], kept: [] };
     const sandbox = env.NYLORUN_SANDBOX?.trim();
     if (sandbox === "auto" || sandbox === "virtual") {
-        const body = (await call(input.fetch, `${base}/v1/tenant/config/seed`, input.applicationKey, {
+        const body = (await call(input.fetch, `${base}/v1/tenant/config/seed`, input.managementKey, {
             method: "PUT",
             body: { requestId: randomUUID(), sandbox: { backend: sandbox } },
         }));
@@ -90,12 +90,12 @@ export async function seedTenant(input) {
     const seeded = modelFromEnv(env, input.projectRoot);
     if (!seeded)
         return result;
-    const current = (await call(input.fetch, `${base}/v1/tenant/model`, input.applicationKey));
+    const current = (await call(input.fetch, `${base}/v1/tenant/model`, input.managementKey));
     if (current.configured === true) {
         result.kept.push("model");
         return result;
     }
-    await call(input.fetch, `${base}/v1/tenant/model`, input.applicationKey, {
+    await call(input.fetch, `${base}/v1/tenant/model`, input.managementKey, {
         method: "PUT",
         body: {
             requestId: randomUUID(),

package/dist/stack/commands.d.ts

@@ -1,10 +1,9 @@
-import type { HostTenant } from "@nylorun/core/contracts";
 import { type ComposeService, type DockerRunner } from "./docker.js";
 import type { HarnessMode, SandboxStackEnv } from "./env-file.js";
 import { type StackPaths } from "./paths.js";
 import type { PortProbe } from "./ports.js";
 import { type FetchLike } from "./studio-login.js";
-import { type AdminEndpoint } from "./operator-keys.js";
+import { type OperateEndpoint } from "./operator-keys.js";
 export declare const STACK_SERVICES: readonly ["postgres", "restate", "s2-lite", "rustfs", "gateway", "runtime", "harness", "studio"];
 export declare const stackUsage: string;
 export interface StackDeps {
@@ -21,7 +20,7 @@ export interface StackDeps {
     err(line: string): void;
     /** Ask a yes/no question on the terminal; undefined when not interactive. */
     confirm?(question: string): Promise<boolean>;
-    /** A developer is at a terminal: `start` may open a browser. */
+    /** A developer is at a terminal. */
     interactive?: boolean;
     /** Open `url` in a browser; false when no browser could be started. */
     openBrowser(url: string): Promise<boolean>;
@@ -53,10 +52,20 @@ export declare function parseStackFlags(args: readonly string[], allowed: {
     lists?: readonly string[];
     aliases?: Record<string, string>;
 }, usage: string): Flags;
-/** The Host's one Tenant as `/v1/admin/status` reports it (no envelope). */
-export type StackTenant = Pick<HostTenant, "id" | "name" | "state" | "cause">;
-/** Printed by `start` when it does not open Studio itself. */
+/** The Host's one Tenant as `nylorun-operate status --json` reports it. */
+export interface StackTenant {
+    /** Null until the Tenant row has been read. */
+    id: string | null;
+    name: string | null;
+    state: "open" | "unavailable";
+    /** Why it cannot open (`schema-too-new`, `database-layout-old`, …); `message` says more. */
+    cause?: string;
+    message?: string;
+}
+/** Printed by `start`, which prints Studio's URL and opens no browser. */
 export declare const STUDIO_SIGN_IN_HINT = "To sign a browser in to Studio, run \"npx nylorun studio\".";
+/** Printed last by `start`. */
+export declare const HELP_HINT = "Run \"npx nylorun --help\" to see what else nylorun can do.";
 export interface StackStatus {
     /** The Tenant's name. */
     name: string;
@@ -67,13 +76,13 @@ export interface StackStatus {
     state: "running" | "stopped" | "absent";
     runtime: {
         url?: string;
-        /** The Admin API (operator listener), when the Tenant publishes one. */
-        adminUrl?: string;
         healthy: boolean;
+        /** `/ready`: the Tenant is open and the Runtime's stores answer. */
+        ready: boolean;
         version?: string;
         hostId?: string;
     };
-    /** The Tenant as the Runtime reports it, while it answers. */
+    /** The Tenant as `nylorun-operate status` reports it, while the runtime container runs. */
     tenant?: StackTenant;
     studio: {
         /** `http://localhost:<port>`: also what an embedding app frames (same site as its own localhost). */
@@ -117,9 +126,8 @@ export interface StackEndpoints {
     home: string;
     /** `http://localhost:<port>` */
     runtimeUrl: string;
-    /** The operator listener (Admin API). */
-    adminUrl: string;
     hostId: string;
+    /** The admin key (host-credentials.json): it mints Studio logins. */
     adminKey: string;
     studioPort: number;
     /** `http://localhost:<studio port>` */
@@ -129,31 +137,32 @@ export interface StackEndpoints {
     /** This call started the Runtime (it was not running before). */
     started: boolean;
 }
-/** The running Tenant's API, reached with an operator key (`nylorun sandbox`). */
+/** The running Tenant's APIs and their keys (`nylorun sandbox`, `nylorun mcp`). */
 export interface TenantApi {
     /** The Tenant's name. */
     name: string;
     runtimeUrl: string;
     /**
-     * The linked project's key (`.nylorun/credentials.json`) when it reaches the Tenant, else
-     * the operator key `cli` the Host root keeps (`cli-credentials.json`).
+     * The linked project's keys (`.nylorun/credentials.json`) when both reach the Tenant, else
+     * the keys `cli` and `cli-management` the Host root keeps (`cli-credentials.json`).
      */
     applicationKey: string;
+    managementKey: string;
 }
-/** The selected Tenant's Admin API while it runs: `nylorun key` and `runningTenantApi`. */
-export interface RunningAdmin extends AdminEndpoint {
+/** The selected Tenant's `nylorun-operate` while it runs: `nylorun key` and `runningTenantApi`. */
+export interface RunningOperate extends OperateEndpoint {
     /** The Tenant's name. */
     name: string;
     runtimeUrl: string;
     paths: StackPaths;
 }
 /**
- * The selected Tenant's Admin API while it runs; exit 3 when it is not running, 7 when it is
- * not open.
+ * The selected Tenant's `nylorun-operate` while it runs; exit 3 when it is not running, 7 when
+ * it is not open.
  */
-export declare function runningAdmin(deps: StackDeps, options?: {
+export declare function runningOperate(deps: StackDeps, options?: {
     name?: string;
-}): Promise<RunningAdmin>;
+}): Promise<RunningOperate>;
 /**
  * The selected Tenant's API while it runs: commands that read or change the Tenant's data never
  * start it. Exit 3 when it is not running, 7 when it is not open.