@nylorun/cli 0.3.0-beta → 0.4.0-beta

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # @nylorun/cli
 
+## 0.4.0-beta
+
+### Minor Changes
+
+- bf1c2da: **The local Runtime and Studio run as a Docker Compose stack that the CLI manages; Studio ships only as its image (breaking beta).**
+
+  - `nylorun start` writes `<Host root>/stack/compose.yaml` and `.env` (mode 0600) and starts Postgres, Restate, s2-lite, the Runtime and Studio on loopback ports, with the Runtime and Studio images this CLI pins (`nylorun.runtime`, `nylorun.studio`; `NYLORUN_RUNTIME_IMAGE` and `NYLORUN_STUDIO_IMAGE` override them). `nylorun stop` keeps the volumes; `nylorun status [--json] [--env]` reports services and health; `nylorun reset [--yes]` deletes the volumes and every Tenant.
+  - `nylorun dev` starts the stack if it is not running, creates the Project's Tenant on first run, opens Studio on that Tenant through a single-use login URL (`next=/tenants/<id>`), and runs the application with `NYLORUN_RUNTIME_URL=http://localhost:<port>`. `--no-open` prints the URL only; `--no-studio` skips Studio. `--local-ui` is removed (exit 2).
+  - `nylorun logs` and `nylorun studio` are the stack commands (`nylorun stack <command>` still works). `nylorun studio` lands on the linked Project's Tenant.
+  - `nylorun runtime up|down|restart|run|status|logs` and the `up`/`down` aliases are removed; they exit 2 and name `nylorun start|stop|status|logs`. `nylorun runtime status --env` is now `nylorun status --env`.
+  - `nylorun doctor` checks Node 24+, Docker, Compose v2 and the stack's health; `doctor runtime` is an alias of it.
+  - `@nylorun/studio` is private and ships only as `ghcr.io/nylorun/studio`: `startStudio`, the hosted (`local.nylorun.studio`) and local UI modes, pairing, the `nylorun-studio` bin and the UI bundle download are removed.
+  - `npm create @nylorun/agent` no longer adds `@nylorun/studio` or a `studio` script, checks for Docker with Compose v2 instead of a global `@nylorun/runtime`, and accepts `--no-studio` only as a deprecated no-op.
+
+- bf1c2da: **`nylorun dev --ephemeral` runs on the Docker stack, with a Tenant-level fixture model (breaking beta).**
+
+  - `nylorun dev --ephemeral` creates a temporary Tenant through `@nylorun/admin` (no Project link written), seeds it from `.env` with the fixture model, opens Studio on it and runs the watcher; the Tenant is deleted with its active work cancelled when the watcher ends, Ctrl-C included. It needs a Runtime that advertises `tenant-fixture-model`.
+  - `PUT /v1/tenant/config/seed` accepts `fixtureModel: true`, stored as Tenant setting `model.fixture`: that Tenant's model calls use the Runtime's fixture model while other Tenants on the Host keep theirs. `HOST_PROTOCOL` advertises the new optional feature `tenant-fixture-model` (`OPTIONAL_HOST_FEATURES` in `@nylorun/core/compatibility`); clients do not require it.
+  - `startEphemeralRuntime()` keeps its signature but its Tenants live in memory instead of SQLite under the Host root; nothing survives `close()`.
+  - Closing a Tenant waits for running advances at most the advance grace period (30 s by default) and then abandons them; their lease lapses and the next advance takes over.
+  - A Worker stop, Tenant close or ended Restate attempt no longer fails or cancels the turn it interrupts: outcomes already returned are recorded, nothing is settled, and the next advance resumes the turn from its checkpoint. Only a user cancel settles `cancelled`; an advance deadline fails the turn with the deadline's message.
+
+- ba1b239: **`nylorun` sets up the local stack; `@nylorun/cli` becomes the Runtime client `nylo` (breaking beta).**
+
+  - New unscoped package **`nylorun`**: `npx nylorun up` sets up the Docker stack on the first run and starts it after that, from any directory; `npx nylorun down` stops it (volumes are kept). `up` and `down` are aliases of `start` and `stop`. It also owns `status`, `logs`, `studio`, `reset` and `doctor`, pins the Runtime and Studio images (`package.json` `nylorun.runtime` / `nylorun.studio`), depends on `@nylorun/core` only, and never creates Tenants.
+  - **`@nylorun/cli`** is the Runtime client with the command **`nylo`**: `nylo tenant create [name]` (creates the Tenant; in a project, writes the Project link and seeds the model provider and sandbox from `.env`), `nylo tenant current|list|use|status|reset|delete`, `nylo configure`, `nylo env` (was `nylorun status --env`) and `nylo doctor sandbox`. It no longer provides the `nylorun` command or the stack commands.
+  - **Removed:** `nylorun dev` and `nylorun dev --ephemeral`. Link once with `nylo tenant create`, then run the project's own `npm run dev`. Moved commands exit 2 and name their replacement.
+  - **Starter:** the generated project depends on `@nylorun/agents` only (no Nylorun devDependency); `dev` is `tsx watch --env-file-if-exists=.env src/main.ts`. `npm create @nylorun/agent` installs the project and prints the next steps (`npx nylorun up`, `npx @nylorun/cli tenant create`, `npm run dev`) instead of starting development; `--no-open` is accepted and ignored.
+  - `connectAgents` names those steps when it finds no Runtime connection. Runtime repair hints, model errors and core's sandbox message name `nylo` and `nylorun up`.
+
+- bf1c2da: **The microsandbox backend is removed; the Runtime runs sandbox tools on the virtual backend only.** The optional `microsandbox` dependency is gone. `sandbox.backend` and `NYLORUN_SANDBOX` accept `auto` or `virtual`, and `auto` selects `virtual`. A Tenant that stored `microsandbox` reads it as `auto`. `nylorun doctor sandbox` and the `nylorun dev` banner report only the virtual shell.
+- bf1c2da: **Tenants can register a Studio principal.** `CreateTenantRequest` gains optional `studioCredentialHash` behind the new protocol feature `studio-principal`; the Runtime stores it as application principal `studio`, and idempotent create compares it too. `@nylorun/admin` exports `deriveStudioToken(adminKey, tenantId)` (HMAC-SHA256 over `nylorun/studio/v1`, NUL, Tenant id) and `createTenant` sends the hash of that key, so Studio can reach any Tenant's API with a key derived from the admin key. Clients require the new feature, so upgrade the Runtime with them.
+- 1d84b3e: **Native Windows is no longer supported; Windows developers use WSL2.** Nylorun runs on macOS and Linux. On native Windows, `nylorun` and `npm create @nylorun/agent` stop with WSL2 guidance. Install Node 24 and Docker (Docker Desktop's WSL integration) inside your WSL distribution and keep projects in its Linux filesystem. The Windows-only process handling (`taskkill`, `.cmd` shims, `npm.cmd`) is removed. `nylorun doctor` reports WSL as `Linux (WSL: <distribution>)`.
+
+### Patch Changes
+
+- 1d84b3e: Opening the browser no longer crashes the CLI when no opener is installed (no `xdg-open` on a minimal Linux or WSL): it reports that and leaves the printed Studio URL to open by hand. Inside WSL, the CLI opens the Windows browser with `wslview`.
+- Pin agents to the tested release.
+- Pin admin to the tested release.
+- Updated dependencies [ba1b239]
+- Updated dependencies [bf1c2da]
+- Updated dependencies [bf1c2da]
+- Updated dependencies
+- Updated dependencies
+  - @nylorun/agents@0.7.0-beta
+  - @nylorun/admin@0.3.0-beta
+
 ## 0.3.0-beta
 
 ### Minor Changes
@@ -9,7 +56,9 @@
   - Dependencies: `@nylorun/agents` and `@nylorun/admin` only (no `@nylorun/runtime`, no `@nylorun/studio`).
   - `nylorun runtime …` finds `nylorun-runtime` on PATH and checks its launcher and Host protocol; a missing or incompatible Runtime exits 1 with the install command for the recommended version (`package.json` `nylorun.runtime`). Nothing is downloaded. `nylorun doctor runtime` checks the prerequisites.
   - `nylorun dev` runs the application entry under `tsx watch`; creates Tenants through `@nylorun/admin`.
-  - **Removed:** `nylorun serve`, `nylorun studio`, `--no-studio`, in-process Project runner.
+  - **Removed:** `nylorun serve` and the in-process Project runner. `nylorun studio`
+    remains the Project-aware Studio command, and `nylorun dev --no-studio`
+    remains the headless development path.
   - Install as a **devDependency**; production `start` is `node dist/src/main.js`.
 
 - c49efed: **Breaking (pre-1.0 minor):** Replace a single SQLite Runtime per Project or home directory with a **Runtime Host** that serves isolated **Tenants**, selected by `Nylorun-Tenant` and negotiated with `Nylorun-Protocol` (protocol `2`, feature `runtime-tenants`). Vocabulary: Host root + Tenant + Project link.

package/README.md

@@ -1,108 +1,85 @@
 # @nylorun/cli
 
-The local `nylorun` executable. Depends on `@nylorun/agents` and `@nylorun/admin`
-only among Nylorun packages — it runs the installed Runtime's **launcher** as a
-process and never imports `@nylorun/runtime`. Vocabulary:
+The Runtime client, command `nylo`: it acts on a Runtime's Tenants, the local
+stack's or any Runtime reachable by URL and key. Setting up and running the
+local stack is [`nylorun`](../nylorun/README.md)'s job; the two packages are
+independent and never call each other. Depends on `@nylorun/agents` and
+`@nylorun/admin` only among Nylorun packages. Vocabulary:
 [runtime/src/CONTEXT.md](../runtime/src/CONTEXT.md).
 
-Prerequisites, installed by the developer (the CLI never downloads them):
-
 ```sh
-node --version                            # 24 or newer
-npm install --global @nylorun/runtime     # provides nylorun-runtime
-nylorun doctor runtime                    # checks both
+npx nylorun up                        # the local stack (nylorun)
+npx @nylorun/cli tenant create        # this project's Tenant, linked in .nylorun/
 ```
 
+## Commands
+
 ```sh
-nylorun runtime up                 # launcher: start the Host
-nylorun runtime down               # stop the Host; keep Tenants and host.json
-nylorun runtime status             # Host id, address, version, Tenant list
-nylorun runtime status --env       # export lines for the linked Project
-nylorun runtime logs [--follow]    # Host + Tenant logs
-nylorun runtime restart            # restart onto the installed Runtime
-nylorun runtime run                # attached foreground Host
-nylorun dev [entry]                # up → link/create Tenant → tsx watch entry
-nylorun dev --ephemeral            # temporary Host root + one Tenant
-nylorun dev --local-ui             # also start Studio with a local dashboard
-nylorun studio [--local-ui]        # start Studio (launch URL + proxy token)
-nylorun configure                  # replace model credential on the linked Tenant
-nylorun tenant list|delete|status|reset
-nylorun doctor runtime             # prerequisites: Node 24+, installed Runtime
-nylorun doctor sandbox             # sandbox backend via Tenant API
+nylo tenant create [name]             # create a Tenant; in a Project, link it and seed it from .env
+nylo tenant current|list [--json]|use <name-or-id>|status [--json]|reset|delete
+nylo configure                        # set or replace the model provider on the linked Tenant
+nylo env                              # export lines for the linked Project
+nylo doctor sandbox [--json]          # sandbox backend via the Tenant API
 ```
 
-`nylorun serve` remains removed. Production `start` is
-`node dist/src/main.js` with `connectAgents` in the application.
-`--local-ui` cannot be combined with `--no-studio`.
-
-## The launcher
-
-`nylorun runtime …` finds `nylorun-runtime` on PATH, checks that it speaks
-launcher protocol 1 and a compatible Host protocol, and invokes it with
-`--json`. The Host runs on the same Node, from the installed
-`@nylorun/runtime`. When the launcher is missing or incompatible, the command
-exits 1 with the install command for the recommended version
-(`cli/package.json` `nylorun.runtime`). A project devDependency on
-`@nylorun/runtime` also works, because npm scripts put `node_modules/.bin` on
-PATH. See [building a desktop client](../docs/building-a-desktop-client.md)
-for the launcher contract.
-
-`dev` starts (or reuses) the Host via the launcher, creates a Tenant through
-`@nylorun/admin` when the Project has no link, writes format-1 link +
-credentials, and spawns `tsx watch <entry>` with
-`NYLORUN_RUNTIME_URL`, `NYLORUN_TENANT` and `NYLORUN_SERVER_KEY`. The ready
-banner hints `Studio: npm run studio`, or prints the Studio `launchUrl` when
-started with `--local-ui`. Ctrl-C stops the child; the Host stays up.
-`nylorun studio` resolves `@nylorun/studio`, supplies `cacheDir` from the Host
-root (`NYLORUN_HOME` / `~/.nylorun`, never cwd), and prints `launchUrl`.
-
-## Host root, Tenants and Project link
-
-The **Host root** is `NYLORUN_HOME` or `~/.nylorun` (resolved absolute once).
-It holds `host.json`, admin credentials and every Tenant; the Runtime itself
-is installed by npm. Isolation is per **Tenant**, not per Project directory.
+Local stack commands (`up`, `down`, `start`, `stop`, `status`, `logs`,
+`studio`, `reset`) exit 2 naming `npx nylorun <command>`. `nylorun dev` was
+removed: link once with `nylo tenant create`, then run the project's own
+`npm run dev` (`tsx watch src/main.ts`).
+
+## `nylo tenant create`
+
+The Admin API connection resolves from `NYLORUN_ADMIN_URL` and
+`NYLORUN_ADMIN_KEY`, else from the local Host root (`NYLORUN_HOME` or
+`~/.nylorun`: `host.json` and the admin key that `nylorun up` wrote). With no
+Runtime answering, it exits 6 and names `npx nylorun up`.
+
+Inside a Project (the nearest `.nylorun/` or `package.json`):
+
+1. Creates the Tenant, named after `package.json` unless a name is given.
+2. Writes the format-1 link and credentials (see below). A Project that is
+   already linked is refused: use `nylo tenant use` or `nylo tenant delete`.
+3. Seeds the Tenant from `.env`: `NYLORUN_SANDBOX`, and the model provider from
+   `MODEL_PROVIDER`, `MODEL`, `MODEL_PROVIDER_API_KEY` (or a credential in
+   `.nylorun/auth.json`) into the Tenant vault. Without them it says to set the
+   provider in Studio or with `nylo configure`.
+
+Outside a Project it creates the Tenant and prints the three `NYLORUN_*`
+exports once; the Host keeps only a hash of the application key.
+
+## Project link
 
 A **Project** stores only:
 
-- `.nylorun/link.json` — `{ format, hostUrl, hostId, tenantId }`
-- `.nylorun/credentials.json` — application key and principal id (0600); no
+- `.nylorun/link.json`: `{ format, hostUrl, hostId, tenantId }`
+- `.nylorun/credentials.json`: application key and principal id (0600), no
   executor tokens
 - `.nylorun/.gitignore` containing `*`
 
+`connectAgents` in `@nylorun/agents` reads the link (or the three variables),
+so the project's `npm run dev` and `npm start` need no Nylorun tool.
+
 ```sh
-eval "$(npx nylorun runtime status --env)"
+eval "$(npx @nylorun/cli env)"
 # → NYLORUN_RUNTIME_URL, NYLORUN_SERVER_KEY, NYLORUN_TENANT
 ```
 
-Port defaults to `8787` on loopback. On first Host setup, if that port is
-taken, the launcher picks a free loopback port and persists it. Explicit
-`--port` is strict.
-
 ## Exit codes
 
 | Code | Meaning |
 | --- | --- |
-| 0 | Success, including `down` when nothing was running |
-| 1 | Generic failure / launcher operation failed |
-| 2 | Usage error |
-| 3 | `runtime status` or `logs`: not running |
-| 4 | Port held by another process |
-| 5 | Protocol / feature incompatible with this CLI |
-| 7 | The Host did not become ready |
+| 0 | Success |
+| 1 | Generic failure |
+| 2 | Usage error, or a moved or removed command |
+| 6 | No Runtime at the linked or local URL |
 | 130 / 143 | SIGINT / SIGTERM |
 
-Install the CLI as a **devDependency**. Generated applications keep
-`@nylorun/agents` alone in production dependencies.
-
 ## Troubleshooting
 
 | Symptom | What to do |
 | --- | --- |
-| Quarantined Tenant | `nylorun tenant status` shows reason and `repair` |
-| `426` / exit 5 | Upgrade CLI / Runtime pin, or pin a matching older set |
-| Port conflict | Stop the other process or `nylorun runtime up --port <n>` |
-| Logs | `nylorun runtime logs --follow` |
-| Runtime not installed | `npm install --global @nylorun/runtime`; `nylorun doctor runtime` checks |
-
-See [package architecture](../docs/design/package-architecture.md) and
-[MIGRATION.md](../MIGRATION.md#runtime-clients-and-admin-api-breaking-beta).
+| No Runtime answers | `npx nylorun up`, then `npx nylorun status` |
+| Quarantined Tenant | `nylo tenant status` shows the reason and `repair` |
+| `426` from the Runtime | Upgrade the CLI, or pin a matching older set |
+
+See [MIGRATION.md](../MIGRATION.md).

package/dist/{runtime/baseline.js → baseline.js}

@@ -1,5 +1,4 @@
 /**
- * // CLIENTS-CCR: owned by WS-F1 (moves from cli/src/host/baseline.ts).
  * Snapshot of the process environment at CLI module load.
  */
 const snapshot = Object.freeze({

package/dist/cli.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-import "./runtime/baseline.js";
+import "./baseline.js";

package/dist/cli.js

@@ -1,28 +1,27 @@
 #!/usr/bin/env node
-import "./runtime/baseline.js";
-import { createRequire } from "node:module";
-import { join } from "node:path";
+import "./baseline.js";
 import { ConfigurationCancelled, configureProvider, fetchModelCatalog, } from "./model/configure.js";
 import { putHostModel } from "./model/host-model.js";
-import { develop, developmentPreflight, startStudio } from "./dev.js";
 import { CliError } from "./errors.js";
-import { runtimeCommand, runtimeUsage } from "./runtime/commands.js";
-import { findProjectRoot, requireProjectRoot } from "./project/root.js";
-import { printLinkedEnvExports } from "./project/attach.js";
+import { findProjectRoot } from "./project/root.js";
+import { printLinkedEnvExports } from "./project/env.js";
 import { readLink as readProjectLink } from "./project/link.js";
 import { readCredentials as readProjectCredentials } from "./project/credentials.js";
 import { tenantCommand } from "./tenant/commands.js";
-import { resolveHome } from "./runtime/launcher.js";
-const usage = `nylorun <runtime|up|down|logs|dev|studio|configure|doctor|tenant>
+const usage = `nylo <tenant|configure|env|doctor>
 
-${runtimeUsage}
+Runtime client (the local stack's Runtime, or any Runtime by URL and key):
+  tenant create [name]                    create a Tenant; in a Project, link it and seed it from .env
+  tenant current|list [--json]|use <name-or-id>|status [--json]|reset|delete
+  configure                               set the linked Tenant's model provider
+  env                                     print the linked Project's NYLORUN_* variables as exports
+  doctor sandbox [--json]                 show which sandbox backend this Tenant's Host offers
 
-  dev [entry] [--ephemeral] [--local-ui] [--no-studio] [--no-open]
-  studio [--local-ui] [--port <n>] [--no-open]
-  configure
-  doctor runtime [--json]  check the prerequisites: Node 24+ and an installed Runtime
-  doctor sandbox [--json]  show which sandbox backend this Tenant's Host offers
-  tenant current|list [--json]|use <name-or-id>|status [--json]|reset|delete`;
+The local stack is managed by the nylorun package: npx nylorun up|down|status|logs|studio`;
+/** Local stack commands, which moved to the nylorun package. */
+const STACK_COMMANDS = new Set([
+    "up", "down", "start", "stop", "status", "logs", "studio", "reset", "stack", "runtime", "restart", "run",
+]);
 function parseFlags(args, allowed = {}) {
     const booleans = new Set();
     const values = new Map();
@@ -58,14 +57,6 @@ function parseFlags(args, allowed = {}) {
     return { rest, booleans, values };
 }
 const usageError = (message) => new CliError(message, 2);
-function parsePort(value) {
-    if (value === undefined || !/^\d+$/u.test(value))
-        throw usageError(`Invalid --port: ${value ?? "(missing)"}`);
-    const port = Number(value);
-    if (!Number.isInteger(port) || port < 1 || port > 65535)
-        throw usageError(`Invalid --port: ${value}`);
-    return port;
-}
 async function resolveLinkedAuth(projectRoot) {
     const link = await readProjectLink(projectRoot);
     const credentials = await readProjectCredentials(projectRoot);
@@ -83,106 +74,34 @@ async function resolveLinkedAuth(projectRoot) {
     if (url && key && tenantId) {
         return { url, key, tenantId, tenantName: tenantId };
     }
-    throw new CliError(`No Project link in ${projectRoot}. Run nylorun dev, or set NYLORUN_RUNTIME_URL, NYLORUN_SERVER_KEY and NYLORUN_TENANT.`, 1);
+    throw new CliError(`No Project link in ${projectRoot}. Run nylo tenant create, or set NYLORUN_RUNTIME_URL, NYLORUN_SERVER_KEY and NYLORUN_TENANT.`, 1);
 }
 async function main() {
-    const [rawCommand, ...rawArgs] = process.argv.slice(2);
-    if (!rawCommand || rawCommand === "--help" || rawCommand === "-h")
+    const [command, ...args] = process.argv.slice(2);
+    if (!command || command === "--help" || command === "-h")
         return void console.log(usage);
-    const aliases = {
-        up: "up",
-        down: "down",
-        logs: "logs",
-    };
-    const command = rawCommand in aliases ? "runtime" : rawCommand;
-    const args = rawCommand in aliases ? [aliases[rawCommand], ...rawArgs] : rawArgs;
+    if (process.platform === "win32")
+        throw new CliError("Nylorun does not run on native Windows. Use WSL2: install Node 24 and Docker (Docker Desktop's WSL integration) inside your WSL distribution and run nylorun there (https://learn.microsoft.com/windows/wsl/install).", 1);
     if (command === "tenant")
         return await tenantCommand(args);
-    if (command === "runtime") {
-        // F2-7: envHook prints the linked Project's three variables.
-        return await runtimeCommand(args, {
-            envHook: async () => {
-                const root = findProjectRoot() ?? process.cwd();
-                await printLinkedEnvExports(root);
-            },
-        });
+    if (command === "env") {
+        if (args.length)
+            throw usageError("Usage: nylo env");
+        await printLinkedEnvExports(findProjectRoot() ?? process.cwd());
+        return;
     }
     if (command === "doctor") {
         const [topic, ...options] = args;
-        if ((topic !== "sandbox" && topic !== "runtime") ||
-            options.some((option) => option !== "--json"))
-            throw usageError("Usage: nylorun doctor runtime|sandbox [--json]");
-        const { doctorRuntime, doctorSandbox } = await import("./doctor.js");
-        const json = options.includes("--json");
-        if (topic === "runtime")
-            await doctorRuntime({ json });
-        else
-            await doctorSandbox({ json });
-        return;
-    }
-    if (command === "dev") {
-        const flags = parseFlags(args, {
-            booleans: ["--ephemeral", "--local-ui", "--no-studio", "--no-open"],
-        });
-        if (flags.rest.length > 1)
-            throw usageError(usage);
-        if (flags.booleans.has("--local-ui") && flags.booleans.has("--no-studio"))
-            throw usageError("--local-ui cannot be combined with --no-studio.");
-        requireProjectRoot();
-        developmentPreflight([
-            ...flags.rest,
-            ...[...flags.booleans],
-        ]);
-        process.exitCode = await develop({
-            ...(flags.rest[0] ? { entry: flags.rest[0] } : {}),
-            flags: [...flags.booleans],
-        });
-        return;
-    }
-    if (command === "serve") {
-        throw usageError("nylorun serve was removed. Use nylorun dev [entry] in development, or node dist/src/main.js with NYLORUN_RUNTIME_URL, NYLORUN_TENANT and NYLORUN_SERVER_KEY.");
-    }
-    if (command === "studio") {
-        const flags = parseFlags(args, {
-            booleans: ["--local-ui", "--no-open"],
-            values: ["--port"],
-        });
-        if (flags.rest.length)
-            throw usageError(usage);
-        const projectRoot = findProjectRoot() ?? process.cwd();
-        // Surface missing Studio early with the same Install message as preflight.
-        try {
-            createRequire(join(projectRoot, "package.json")).resolve("@nylorun/studio");
-        }
-        catch {
-            throw new Error("Install @nylorun/studio to use the Studio dashboard.");
-        }
-        const auth = await resolveLinkedAuth(projectRoot);
-        const localUi = flags.booleans.has("--local-ui");
-        // I2: startStudio default is hosted; `--local-ui` forces local + cacheDir.
-        const dashboard = await startStudio({
-            runtimeUrl: auth.url,
-            serverKey: auth.key,
-            tenant: { id: auth.tenantId, name: auth.tenantName },
-            open: !flags.booleans.has("--no-open"),
-            localUi,
-            cacheDir: resolveHome(),
-            projectRoot,
-            ...(flags.values.has("--port")
-                ? { port: parsePort(flags.values.get("--port")) }
-                : {}),
-        });
-        console.log(`Studio        ${dashboard.launchUrl}`);
-        if (!localUi && dashboard.launchUrl.startsWith("https://local.nylorun.studio")) {
-            console.log(`Safari or offline: nylorun studio --local-ui`);
-        }
-        await new Promise((resolve, reject) => {
-            const close = () => void dashboard.close().then(resolve, reject);
-            process.once("SIGINT", close);
-            process.once("SIGTERM", close);
-        });
+        if (topic !== "sandbox" || options.some((option) => option !== "--json"))
+            throw usageError("Usage: nylo doctor sandbox [--json]. Check the local stack with npx nylorun doctor.");
+        const { doctorSandbox } = await import("./doctor.js");
+        await doctorSandbox({ json: options.includes("--json") });
         return;
     }
+    if (command === "dev")
+        throw usageError("nylorun dev was removed: run nylo tenant create once in your project, then your project's npm run dev.");
+    if (STACK_COMMANDS.has(command))
+        throw usageError(`The local stack moved to the nylorun package: npx nylorun ${command}`);
     if (command === "configure") {
         const flags = parseFlags(args);
         if (flags.rest.length)
@@ -195,7 +114,7 @@ async function main() {
         process.once("SIGTERM", () => cancel("SIGTERM"));
         const health = await fetch(`${auth.url}/health`).catch(() => undefined);
         if (!health?.ok)
-            throw new CliError(`No Runtime Host is listening at ${auth.url}. Start one with "nylorun runtime up".`, 6);
+            throw new CliError(`No Runtime is listening at ${auth.url}. Start the local stack with "npx nylorun up".`, 6);
         const catalog = await fetchModelCatalog({
             url: auth.url,
             key: auth.key,

package/dist/doctor.d.ts

@@ -1,4 +1,3 @@
-import { type AgentManifest } from "@nylorun/agents";
 export type SandboxReport = {
     preference: string;
     backend: string | null;
@@ -13,17 +12,7 @@ export type SandboxReport = {
     }[];
     defaultImage?: string;
 };
-/**
- * `nylorun doctor runtime`: check the two prerequisites (Node 24+ and an
- * installed `@nylorun/runtime`) and print the fix for each one that fails.
- * Exits 1 when a prerequisite is missing; installs nothing.
- */
-export declare function doctorRuntime(options: {
-    json: boolean;
-}): Promise<void>;
-/** `nylorun doctor sandbox`: Tenant sandbox report via the Tenant API (F2-4). */
+/** `nylo doctor sandbox`: Tenant sandbox report via the Tenant API (F2-4). */
 export declare function doctorSandbox(options: {
     json: boolean;
 }): Promise<void>;
-/** One line for the dev banner, or undefined when no connected agent declares a sandbox. */
-export declare function sandboxBanner(runtimeUrl: string, serverKey: string, manifests: readonly AgentManifest[], tenantId: string): Promise<string | undefined>;

package/dist/doctor.js

@@ -1,18 +1,11 @@
 import { release } from "node:os";
-import { PROTOCOL_HEADER, PROTOCOL_VERSION, TENANT_HEADER, createClient, resolveConnection, } from "@nylorun/agents";
+import { createClient, resolveConnection } from "@nylorun/agents";
 import { CliError } from "./errors.js";
-import { launcher, resolveHome, runtimeInstallCommand } from "./runtime/launcher.js";
-/** Oldest Node the Runtime runs on (it needs node:sqlite). */
-const MIN_NODE_MAJOR = 24;
-const LABEL = {
-    microsandbox: "microsandbox VM",
-    virtual: "virtual shell",
-};
 function platformLine() {
     const os = process.platform === "darwin"
         ? "macOS"
-        : process.platform === "win32"
-            ? "Windows"
+        : process.env.WSL_DISTRO_NAME
+            ? `Linux (WSL: ${process.env.WSL_DISTRO_NAME})`
             : process.platform;
     return `${os} (kernel ${release()}) · ${process.arch}`;
 }
@@ -25,54 +18,7 @@ async function fetchSandboxReport(options) {
     });
     return client.transport.json("/v1/tenant/sandbox", "GET", undefined);
 }
-/**
- * `nylorun doctor runtime`: check the two prerequisites (Node 24+ and an
- * installed `@nylorun/runtime`) and print the fix for each one that fails.
- * Exits 1 when a prerequisite is missing; installs nothing.
- */
-export async function doctorRuntime(options) {
-    const nodeOk = Number(process.versions.node.split(".")[0]) >= MIN_NODE_MAJOR;
-    let runtime;
-    try {
-        const handle = await launcher(resolveHome());
-        runtime = { ok: true, ...handle.runtime };
-    }
-    catch (error) {
-        runtime = {
-            ok: false,
-            problem: error instanceof Error ? error.message : String(error),
-        };
-    }
-    if (options.json) {
-        console.log(JSON.stringify({
-            node: { version: process.versions.node, ok: nodeOk },
-            runtime,
-            install: runtimeInstallCommand(),
-        }, null, 2));
-    }
-    else {
-        const rows = [
-            [
-                "node",
-                nodeOk
-                    ? `✓ ${process.versions.node}`
-                    : `✗ ${process.versions.node}: install Node ${MIN_NODE_MAJOR} or newer`,
-            ],
-            [
-                "runtime",
-                runtime.ok
-                    ? `✓ ${runtime.version} · ${runtime.bin}`
-                    : `✗ ${runtime.problem.split("\n")[0]}\n    ${runtimeInstallCommand()}`,
-            ],
-        ];
-        const width = Math.max(...rows.map(([key]) => key.length)) + 2;
-        for (const [key, value] of rows)
-            console.log(`  ${key.padEnd(width)}${value}`);
-    }
-    if (!nodeOk || !runtime.ok)
-        process.exitCode = 1;
-}
-/** `nylorun doctor sandbox`: Tenant sandbox report via the Tenant API (F2-4). */
+/** `nylo doctor sandbox`: Tenant sandbox report via the Tenant API (F2-4). */
 export async function doctorSandbox(options) {
     let report;
     try {
@@ -96,7 +42,7 @@ export async function doctorSandbox(options) {
     rows.push([
         "preference",
         report.preference === "auto"
-            ? "auto (seed Tenant sandbox.backend via nylorun dev / .env NYLORUN_SANDBOX)"
+            ? "auto (seed Tenant sandbox.backend via nylo tenant create / .env NYLORUN_SANDBOX)"
             : report.preference,
     ]);
     rows.push([
@@ -109,41 +55,5 @@ export async function doctorSandbox(options) {
     for (const [key, value] of rows)
         console.log(`  ${key.padEnd(width)}${value}`);
     if (report.backend === "virtual")
-        console.log("\n  The virtual shell emulates bash in the Runtime process; it is not a VM boundary.\n" +
-            "  For hardware isolation use macOS on Apple Silicon or Linux with KVM.");
-}
-/** One line for the dev banner, or undefined when no connected agent declares a sandbox. */
-export async function sandboxBanner(runtimeUrl, serverKey, manifests, tenantId) {
-    const capability = manifests
-        .flatMap((manifest) => manifest.capabilities)
-        .find((item) => item.sandbox);
-    if (!capability)
-        return undefined;
-    let report;
-    try {
-        const response = await fetch(`${runtimeUrl}/v1/tenant/sandbox`, {
-            headers: {
-                authorization: `Bearer ${serverKey}`,
-                [TENANT_HEADER]: tenantId,
-                [PROTOCOL_HEADER]: String(PROTOCOL_VERSION),
-            },
-            signal: AbortSignal.timeout(10_000),
-        });
-        if (response.ok)
-            report = (await response.json());
-    }
-    catch {
-        /* ignore */
-    }
-    if (!report)
-        return undefined;
-    const doctor = "run `npx nylorun doctor sandbox` for options";
-    if (!report.backend)
-        return `sandbox: unavailable (${report.reason}) · ${doctor}`;
-    const image = capability.sandbox?.image ?? report.defaultImage;
-    const network = capability.sandbox?.network?.preset ?? "dev";
-    const fellBack = report.preference === "auto" && report.backend !== report.probes[0]?.name;
-    return fellBack
-        ? `sandbox: ${LABEL[report.backend] ?? report.backend} (${report.reason}) · ${doctor}`
-        : `sandbox: ${LABEL[report.backend] ?? report.backend}${report.backend === "microsandbox" && image ? ` · image ${image}` : ""} · network: ${network}`;
+        console.log("\n  The virtual shell emulates bash in the Runtime process; it is not a VM boundary.");
 }

package/dist/home.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The Host root: an explicit home, `NYLORUN_HOME`, or `~/.nylorun`. The stack
+ * bind-mounts it into the Runtime and Studio containers, and `@nylorun/admin`
+ * reads `host.json` and the admin key from it.
+ */
+export declare function resolveHome(home?: string, env?: Readonly<Record<string, string | undefined>>): string;

package/dist/home.js

@@ -0,0 +1,15 @@
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+/**
+ * The Host root: an explicit home, `NYLORUN_HOME`, or `~/.nylorun`. The stack
+ * bind-mounts it into the Runtime and Studio containers, and `@nylorun/admin`
+ * reads `host.json` and the admin key from it.
+ */
+export function resolveHome(home, env = process.env) {
+    if (home !== undefined && home.trim() !== "")
+        return resolve(home);
+    const fromEnv = env.NYLORUN_HOME?.trim();
+    if (fromEnv)
+        return resolve(fromEnv);
+    return resolve(join(homedir(), ".nylorun"));
+}

package/dist/model/host-model.js

@@ -69,7 +69,7 @@ export async function ensureHostModel(options) {
         await putHostModel(options.runtimeUrl, options.serverKey, prompted, options.tenantId);
         return;
     }
-    throw new Error("Model provider is not configured. Run nylorun dev in a terminal to set it up, or open Studio.");
+    throw new Error("Model provider is not configured. Run nylo configure in a terminal to set it up, or open Studio.");
 }
 function seedFromEnv(env, root) {
     const provider = env.MODEL_PROVIDER?.trim();