nylorun 0.4.0-beta → 0.5.0-beta

package/dist/stack/compose-file.d.ts

@@ -1,16 +1,16 @@
 /**
- * A local stack's Compose file (Runtime Architecture §14.3), written to
- * `<Host root>/docker/compose.yaml` by `nylorun start`. Each stack is one installation with
- * one Tenant (tenancy.md §6): its own Compose project (`nylorun-<name>`, the file's `name`),
- * volumes, network and ports. Everything else that varies (ports, the Postgres password,
- * UID/GID, the Host root, the images, the stack's name) comes from `docker/.env`.
+ * A local Tenant's Compose file (Runtime Architecture §14.3), written to
+ * `<Host root>/docker/compose.yaml` by `nylorun start`. Each local Tenant is one installation
+ * (tenancy.md §6): its own Compose project (`nylorun-<name>`, the file's `name`), volumes,
+ * network and ports. Everything else that varies (ports, the Postgres password, UID/GID, the
+ * Host root, the images, the Tenant's name) comes from `docker/.env`.
  *
- * The Tenant's state is the stack's Postgres database, executed through Restate, with its
+ * The Tenant's state is its Postgres database, executed through Restate, with its
  * history in s2-lite; the Runtime's /ready checks all three. Postgres initialises the
  * database with C collation (`--locale=C`) and runs with `wal_level=logical`: the stream
  * relay feeds s2-lite from the record over logical replication (Durable Streams), and
  * `max_slot_wal_keep_size` caps the WAL a stuck relay can hold. The Runtime creates the
- * Tenant on its first start, named after the stack (`NYLORUN_TENANT_NAME`), with the derived
+ * Tenant on its first start, with its name (`NYLORUN_TENANT_NAME`) and the derived
  * principals of `NYLORUN_DERIVED_PRINCIPALS` (`project` for the Project link).
  *
  * Restate signs requests to the Worker endpoint with the private key in

package/dist/stack/compose-file.js

@@ -1,17 +1,17 @@
 import { PINNED_IMAGES } from "./images.js";
 /**
- * A local stack's Compose file (Runtime Architecture §14.3), written to
- * `<Host root>/docker/compose.yaml` by `nylorun start`. Each stack is one installation with
- * one Tenant (tenancy.md §6): its own Compose project (`nylorun-<name>`, the file's `name`),
- * volumes, network and ports. Everything else that varies (ports, the Postgres password,
- * UID/GID, the Host root, the images, the stack's name) comes from `docker/.env`.
+ * A local Tenant's Compose file (Runtime Architecture §14.3), written to
+ * `<Host root>/docker/compose.yaml` by `nylorun start`. Each local Tenant is one installation
+ * (tenancy.md §6): its own Compose project (`nylorun-<name>`, the file's `name`), volumes,
+ * network and ports. Everything else that varies (ports, the Postgres password, UID/GID, the
+ * Host root, the images, the Tenant's name) comes from `docker/.env`.
  *
- * The Tenant's state is the stack's Postgres database, executed through Restate, with its
+ * The Tenant's state is its Postgres database, executed through Restate, with its
  * history in s2-lite; the Runtime's /ready checks all three. Postgres initialises the
  * database with C collation (`--locale=C`) and runs with `wal_level=logical`: the stream
  * relay feeds s2-lite from the record over logical replication (Durable Streams), and
  * `max_slot_wal_keep_size` caps the WAL a stuck relay can hold. The Runtime creates the
- * Tenant on its first start, named after the stack (`NYLORUN_TENANT_NAME`), with the derived
+ * Tenant on its first start, with its name (`NYLORUN_TENANT_NAME`) and the derived
  * principals of `NYLORUN_DERIVED_PRINCIPALS` (`project` for the Project link).
  *
  * Restate signs requests to the Worker endpoint with the private key in
@@ -126,7 +126,7 @@ services:
       NYLORUN_HOME: /nylorun
       NYLORUN_PACKING: combined
       # The Tenant the Runtime creates on its first start (later starts open it).
-      NYLORUN_TENANT_NAME: \${NYLORUN_STACK_NAME:?run nylorun start}
+      NYLORUN_TENANT_NAME: \${NYLORUN_TENANT_NAME:?run nylorun start}
       NYLORUN_DERIVED_PRINCIPALS: \${NYLORUN_DERIVED_PRINCIPALS:-project}
       # Model calls, remote MCP calls and deliveries go through the gateway, and vault writes
       # and token signing through its keys service: this container never reads a credential
@@ -136,12 +136,12 @@ services:
       NYLORUN_GATES_TOKEN: \${NYLORUN_GATES_TOKEN:?run nylorun start}
       NYLORUN_LISTEN_HOST: 0.0.0.0
       NYLORUN_LISTEN_PORT: "4000"
-      # Host headers the Runtime accepts: the stack network name, and the
+      # Host headers the Runtime accepts: its name on the Compose network, and the
       # published port as clients on this machine address it.
       NYLORUN_ALLOWED_HOSTS: runtime:4000,localhost:\${NYLORUN_PORT},127.0.0.1:\${NYLORUN_PORT}
       NYLORUN_PUBLIC_URL: http://localhost:\${NYLORUN_PORT} # reported by /v1/admin/status
       # The Admin API on its own listener, published on loopback only; Studio reaches it on
-      # the stack network. Port 4000 serves the Tenant API alone.
+      # the Compose network. Port 4000 serves the Tenant API alone.
       NYLORUN_ADMIN_LISTEN_PORT: "4001"
       NYLORUN_ADMIN_ALLOWED_HOSTS: runtime:4001,localhost:\${NYLORUN_ADMIN_PORT},127.0.0.1:\${NYLORUN_ADMIN_PORT}
       NYLORUN_DATABASE_URL: postgres://nylorun:\${NYLORUN_POSTGRES_PASSWORD}@postgres:5432/nylorun
@@ -158,7 +158,7 @@ services:
       host.docker.internal: host-gateway # the Docker host, also on Linux Docker Engine
     volumes:
       - \${NYLORUN_HOST_ROOT:?run nylorun start}:/nylorun # Host root
-      # Empty and read-only over the vault key (keys/) and the stack's secrets (docker/):
+      # Empty and read-only over the vault key (keys/) and the Compose secrets (docker/):
       # only the gateway reads the key, and only Restate its private key.
       - type: tmpfs
         target: /nylorun/keys
@@ -192,6 +192,8 @@ services:
       NYLORUN_STUDIO_PUBLIC_PORT: \${NYLORUN_STUDIO_PORT}
       # Exact origins that may frame Studio (Babai Desktop); kept in .env.
       NYLORUN_STUDIO_FRAME_ANCESTORS: \${NYLORUN_STUDIO_FRAME_ANCESTORS:-}
+      # Studio's anonymous usage analytics; empty when telemetry is off.
+      NYLORUN_STUDIO_ANALYTICS_ID: \${NYLORUN_STUDIO_ANALYTICS_ID:-}
     volumes:
       - \${NYLORUN_HOST_ROOT}/host-credentials.json:/run/nylorun/host-credentials.json:ro
     ports:

package/dist/stack/docker.js

@@ -45,7 +45,7 @@ export async function checkDocker(docker) {
         return {
             docker: {
                 ok: false,
-                problem: "Docker is required for the Nylorun stack, and the docker command was not found. Install Docker Desktop, OrbStack, Colima or another Docker engine with Compose v2, then retry.",
+                problem: "Docker is required for local Nylorun Tenants, and the docker command was not found. Install Docker Desktop, OrbStack, Colima or another Docker engine with Compose v2, then retry.",
             },
         };
     if (server.code !== 0)

package/dist/stack/env-file.d.ts

@@ -29,8 +29,13 @@ export interface StackEnv {
     studioImage: string;
     /** Exact origins that may frame Studio, separated by spaces (persists). */
     studioFrameAncestors: string;
-    /** The stack's name: the name of the Tenant its Runtime creates. */
-    stackName: string;
+    /**
+     * The Google Analytics measurement id Studio reports page views to, or empty
+     * when telemetry is off. Decided again on every start.
+     */
+    studioAnalyticsId: string;
+    /** The Tenant's name, which the Runtime gives the Tenant it creates. */
+    tenantName: string;
     /**
      * Derived principals the Runtime registers on its Tenant, comma-separated (persists);
      * always includes `project`, the Project link's principal.

package/dist/stack/env-file.js

@@ -23,7 +23,8 @@ const KEYS = {
     runtimeImage: "NYLORUN_RUNTIME_IMAGE",
     studioImage: "NYLORUN_STUDIO_IMAGE",
     studioFrameAncestors: "NYLORUN_STUDIO_FRAME_ANCESTORS",
-    stackName: "NYLORUN_STACK_NAME",
+    studioAnalyticsId: "NYLORUN_STUDIO_ANALYTICS_ID",
+    tenantName: "NYLORUN_TENANT_NAME",
     derivedPrincipals: "NYLORUN_DERIVED_PRINCIPALS",
 };
 /** Compose .env values: single quotes keep a value literal (no interpolation). */
@@ -76,10 +77,14 @@ export function renderEnvFile(env) {
         "# starts; change with nylorun start --studio-embed-origin <origin>.",
         line("studioFrameAncestors"),
         "",
-        "# The stack's name, which its Runtime gives the Tenant it creates on the first",
+        "# Studio's anonymous usage analytics; empty when off. Set on every start: turn",
+        "# it off with nylorun telemetry disable or NYLORUN_TELEMETRY_DISABLED=1.",
+        line("studioAnalyticsId"),
+        "",
+        "# The Tenant's name, which the Runtime gives the Tenant it creates on the first",
         "# start, and the derived principals it registers on that Tenant (keys derived",
         "# from the admin key; `project` is the Project link's).",
-        line("stackName"),
+        line("tenantName"),
         line("derivedPrincipals"),
         "",
     ].join("\n");

package/dist/stack/host-files.d.ts

@@ -3,17 +3,17 @@ import type { StackPaths } from "./paths.js";
  * host.json and host-credentials.json (format 1), which `@nylorun/admin`,
  * Studio and the Runtime container all read.
  *
- * For the stack, host.json names the client-facing address: `localhost` and
+ * For a local Tenant, host.json names the client-facing address: `localhost` and
  * the published port. The container binds 0.0.0.0:4000 on its own.
  */
-/** Host name clients use for the stack. Studio's cookie is set on this name too. */
+/** Host name clients use for a local Tenant. Studio's cookie is set on this name too. */
 export declare const STACK_CLIENT_HOST = "localhost";
 export interface HostConfigFile {
     format: 1;
     hostId: string;
     host: string;
     port: number;
-    /** The operator listener's published port (the Admin API); absent on older stacks. */
+    /** The operator listener's published port (the Admin API); absent on older Host roots. */
     adminPort?: number;
     runtimeVersion?: string;
     [field: string]: unknown;
@@ -36,7 +36,7 @@ export declare function readAdminKey(paths: StackPaths): Promise<string | undefi
 /**
  * The Tenant's vault key in `keys/vault-kek` (32 random bytes, base64, mode 0600), which only the
  * gateway container mounts (F4.2): created if missing, or moved from `tenant/vault-kek`, where a
- * stack before F4.2 kept it. The gateway never creates it.
+ * Host root before F4.2 kept it. The gateway never creates it.
  */
 export declare function ensureVaultKey(paths: StackPaths): Promise<{
     created: boolean;

package/dist/stack/host-files.js

@@ -8,10 +8,10 @@ import { CliError } from "../errors.js";
  * host.json and host-credentials.json (format 1), which `@nylorun/admin`,
  * Studio and the Runtime container all read.
  *
- * For the stack, host.json names the client-facing address: `localhost` and
+ * For a local Tenant, host.json names the client-facing address: `localhost` and
  * the published port. The container binds 0.0.0.0:4000 on its own.
  */
-/** Host name clients use for the stack. Studio's cookie is set on this name too. */
+/** Host name clients use for a local Tenant. Studio's cookie is set on this name too. */
 export const STACK_CLIENT_HOST = "localhost";
 const KNOWN_FORMAT = 1;
 const ADMIN_KEY_PATTERN = /^[0-9a-f]{64}$/;
@@ -87,7 +87,7 @@ export async function readAdminKey(paths) {
 /**
  * The Tenant's vault key in `keys/vault-kek` (32 random bytes, base64, mode 0600), which only the
  * gateway container mounts (F4.2): created if missing, or moved from `tenant/vault-kek`, where a
- * stack before F4.2 kept it. The gateway never creates it.
+ * Host root before F4.2 kept it. The gateway never creates it.
  */
 export async function ensureVaultKey(paths) {
     await mkdir(paths.keys, { recursive: true, mode: 0o700 });

package/dist/stack/images.d.ts

@@ -1,5 +1,5 @@
 /**
- * Images the local stack runs. The Runtime and Studio tags are pinned by this
+ * Images a local Tenant runs. The Runtime and Studio tags are pinned by this
  * CLI release; `NYLORUN_RUNTIME_IMAGE` and `NYLORUN_STUDIO_IMAGE` override them
  * (local builds, CI images). Postgres, Restate and s2-lite are the official
  * images, pinned here.

package/dist/stack/images.js

@@ -1,6 +1,6 @@
 import { pinnedVersion } from "./versions.js";
 /**
- * Images the local stack runs. The Runtime and Studio tags are pinned by this
+ * Images a local Tenant runs. The Runtime and Studio tags are pinned by this
  * CLI release; `NYLORUN_RUNTIME_IMAGE` and `NYLORUN_STUDIO_IMAGE` override them
  * (local builds, CI images). Postgres, Restate and s2-lite are the official
  * images, pinned here.

package/dist/stack/index.d.ts

@@ -5,9 +5,9 @@ export { checkDocker } from "./docker.js";
 export type { Check, DockerChecks } from "./docker.js";
 /** Real dependencies: docker on PATH, global fetch, the terminal. */
 export declare function defaultStackDeps(env: Readonly<Record<string, string | undefined>>): StackDeps;
-/** Entry for `nylorun start|stop|status|logs|reset|studio|ls|delete|legacy`. */
+/** Entry for `nylorun start|stop|status|logs|reset|studio|ls|delete`. */
 export declare function stackCommand(name: string, args: readonly string[], env: Readonly<Record<string, string | undefined>>): Promise<number>;
-/** `nylorun studio`, landing on `next` when given, else on the stack's Tenant. */
+/** `nylorun studio`, landing on `next` when given, else on the Tenant's page. */
 export declare function studioCommand(args: readonly string[], env: Readonly<Record<string, string | undefined>>, options?: {
     next?: string;
 }): Promise<number>;

package/dist/stack/index.js

@@ -17,7 +17,11 @@ function browserCommand(env) {
  * Variables `docker/.env` sets for Compose: `nylorun start` writes them there, so the
  * environment must not override them when Compose interpolates the file.
  */
-const STACK_ENV_OWNED = ["NYLORUN_STACK_NAME", "NYLORUN_DERIVED_PRINCIPALS"];
+const STACK_ENV_OWNED = [
+    "NYLORUN_TENANT_NAME",
+    "NYLORUN_DERIVED_PRINCIPALS",
+    "NYLORUN_STUDIO_ANALYTICS_ID",
+];
 /** Real dependencies: docker on PATH, global fetch, the terminal. */
 export function defaultStackDeps(env) {
     const interactive = Boolean(process.stdin.isTTY && process.stderr.isTTY);
@@ -71,11 +75,11 @@ export function defaultStackDeps(env) {
         },
     };
 }
-/** Entry for `nylorun start|stop|status|logs|reset|studio|ls|delete|legacy`. */
+/** Entry for `nylorun start|stop|status|logs|reset|studio|ls|delete`. */
 export async function stackCommand(name, args, env) {
     return await runStackCommand(name, args, defaultStackDeps(env));
 }
-/** `nylorun studio`, landing on `next` when given, else on the stack's Tenant. */
+/** `nylorun studio`, landing on `next` when given, else on the Tenant's page. */
 export async function studioCommand(args, env, options = {}) {
     return await runStudioCommand(args, defaultStackDeps(env), options);
 }

package/dist/stack/paths.d.ts

@@ -1,6 +1,6 @@
-/** Files under the Host root that the stack commands read and write. */
+/** Files under the Host root that the nylorun commands read and write. */
 export interface StackPaths {
-    /** The Host root (`~/.nylorun/stacks/<name>` or `NYLORUN_HOME`), bind-mounted at /nylorun. */
+    /** The Host root (`~/.nylorun/tenants/<name>` or `NYLORUN_HOME`), bind-mounted at /nylorun. */
     root: string;
     /** host.json: client-facing host and published port, no secrets. */
     config: string;
@@ -8,7 +8,7 @@ export interface StackPaths {
     credentials: string;
     /** host-state.json: written only by a launcher-managed Runtime. */
     state: string;
-    /** stack.json: the stack's name and the project it was created for. */
+    /** tenant.json: the Tenant's name and the project it was created for. */
     record: string;
     /** The Tenant directory: homes, sandboxes, plugin data, logs. */
     tenant: string;

package/dist/stack/paths.js

@@ -7,7 +7,7 @@ export function stackPaths(hostRoot) {
         config: join(root, "host.json"),
         credentials: join(root, "host-credentials.json"),
         state: join(root, "host-state.json"),
-        record: join(root, "stack.json"),
+        record: join(root, "tenant.json"),
         tenant: join(root, "tenant"),
         keys: join(root, "keys"),
         vaultKey: join(root, "keys", "vault-kek"),

package/dist/stack/ports.d.ts

@@ -5,7 +5,7 @@ export declare const DEFAULT_PORTS: {
     readonly studio: 4161;
     readonly restate: 9070;
 };
-/** How the stack finds ports on 127.0.0.1; injectable for tests. */
+/** How `nylorun start` finds ports on 127.0.0.1; injectable for tests. */
 export interface PortProbe {
     isFree(port: number): Promise<boolean>;
     /** A port the OS reports free right now. */
@@ -14,7 +14,7 @@ export interface PortProbe {
 export declare const loopbackPorts: PortProbe;
 /**
  * Choose a port: the persisted one if any (kept even when busy, because the
- * running stack may hold it), else the default when free, else a free one.
+ * running Tenant may hold it), else the default when free, else a free one.
  * Never returns a port in `taken`.
  */
 export declare function choosePort(probe: PortProbe, preferred: number, persisted: number | undefined, taken: ReadonlySet<number>): Promise<number>;

package/dist/stack/ports.js

@@ -30,7 +30,7 @@ export const loopbackPorts = {
 };
 /**
  * Choose a port: the persisted one if any (kept even when busy, because the
- * running stack may hold it), else the default when free, else a free one.
+ * running Tenant may hold it), else the default when free, else a free one.
  * Never returns a port in `taken`.
  */
 export async function choosePort(probe, preferred, persisted, taken) {

package/dist/stack/prepare.d.ts

@@ -10,7 +10,7 @@ export interface PreparedStack {
     /** True when this run chose the ports (first start). */
     firstRun: boolean;
 }
-/** Read the persisted stack settings without writing anything. */
+/** Read the persisted Compose settings without writing anything. */
 export declare function readStackEnv(paths: Pick<StackPaths, "env">): Promise<import("./env-file.js").PersistedStackEnv | undefined>;
 /**
  * Write everything `docker compose up` needs under the Host root:
@@ -20,7 +20,7 @@ export declare function readStackEnv(paths: Pick<StackPaths, "env">): Promise<im
  */
 export declare function prepareStack(input: {
     paths: StackPaths;
-    /** The stack's name (its Tenant's name) and its Compose project. */
+    /** The Tenant's name and its Compose project. */
     name: string;
     project: string;
     images: StackImages;
@@ -29,7 +29,7 @@ export declare function prepareStack(input: {
     /** Recorded in host.json; undefined keeps the recorded version. */
     runtimeVersion: string | undefined;
     ports: PortProbe;
-    /** Ports other stacks keep in their `.env`: never chosen for a port not chosen yet. */
+    /** Ports other Tenants keep in their `.env`: never chosen for a port not chosen yet. */
     reserved?: ReadonlySet<number>;
     /** `NYLORUN_DERIVED_PRINCIPALS` from the environment of `nylorun start`; else kept. */
     derivedPrincipals?: string;
@@ -41,4 +41,6 @@ export declare function prepareStack(input: {
         add?: readonly string[];
         reset?: boolean;
     };
+    /** The measurement id Studio reports page views to; absent when telemetry is off. */
+    studioAnalyticsId?: string;
 }): Promise<PreparedStack>;

package/dist/stack/prepare.js

@@ -21,7 +21,7 @@ async function readText(path) {
         return undefined;
     }
 }
-/** Read the persisted stack settings without writing anything. */
+/** Read the persisted Compose settings without writing anything. */
 export async function readStackEnv(paths) {
     const text = await readText(paths.env);
     return text === undefined ? undefined : parsePersisted(text);
@@ -76,7 +76,8 @@ export async function prepareStack(input) {
         runtimeImage: input.images.runtime,
         studioImage: input.images.studio,
         studioFrameAncestors,
-        stackName: input.name,
+        studioAnalyticsId: input.studioAnalyticsId ?? "",
+        tenantName: input.name,
         derivedPrincipals: (input.derivedPrincipals?.trim()
             ? parseDerivedPrincipals(input.derivedPrincipals, "NYLORUN_DERIVED_PRINCIPALS")
             : (persisted.derivedPrincipals ?? ["project"])).join(","),

package/dist/stack/stacks.d.ts

@@ -1,47 +1,50 @@
 /**
- * The machine's local stacks (tenancy.md §6): one installation per stack, each with its own
- * Host root `~/.nylorun/stacks/<name>/`, Compose project `nylorun-<name>`, ports and volumes.
- * `~/.nylorun` itself held the single stack of older releases (the legacy stack).
+ * The machine's local Tenants (tenancy.md §6): one installation per Tenant, each with its own
+ * Host root `~/.nylorun/tenants/<name>/`, Compose project `nylorun-<name>`, ports and volumes.
  */
-/** A stack name: also part of its Compose project, so Compose's rules apply. */
-export declare const STACK_NAME: RegExp;
-/** `~/.nylorun`: the stacks, and the legacy stack's files. Tests pass another directory. */
+/** The Tenant a command acts on outside a project when nothing names one. */
+export declare const DEFAULT_TENANT = "default";
+/** A Tenant name: also part of its Compose project, so Compose's rules apply. */
+export declare const TENANT_NAME: RegExp;
+/** `~/.nylorun`: the Tenants and the machine's settings. Tests pass another directory. */
 export declare function defaultNylorunRoot(): string;
-export declare function stacksDir(base: string): string;
-export declare function stackRoot(base: string, name: string): string;
-export declare function assertStackName(name: string, source: string): string;
-/** A directory name as a stack name: lowercased, other characters as `-`, trimmed. */
-export declare function sanitizeStackName(raw: string): string;
-/** `stack.json` in a Host root: the stack's name and the project it was created for. */
-export interface StackRecord {
+export declare function tenantsDir(base: string): string;
+export declare function tenantRoot(base: string, name: string): string;
+export declare function assertTenantName(name: string, source: string): string;
+/** A directory name as a Tenant name: lowercased, other characters as `-`, trimmed. */
+export declare function sanitizeTenantName(raw: string): string;
+/** `tenant.json` in a Host root: the Tenant's name and the project it was created for. */
+export interface TenantRecord {
     format: 1;
     name: string;
-    /** The project directory `nylorun start` created the stack in; absent outside a project. */
+    /** The project directory `nylorun start` created the Tenant in; absent outside a project. */
     project?: string;
 }
-export declare function stackRecordPath(root: string): string;
-export declare function readStackRecord(root: string): Promise<StackRecord | undefined>;
-export declare function writeStackRecord(root: string, record: Omit<StackRecord, "format">): Promise<void>;
-export interface StackEntry {
+export declare function tenantRecordPath(root: string): string;
+export declare function readTenantRecord(root: string): Promise<TenantRecord | undefined>;
+export declare function writeTenantRecord(root: string, record: Omit<TenantRecord, "format">): Promise<void>;
+export interface TenantEntry {
     name: string;
     root: string;
-    record?: StackRecord;
+    record: TenantRecord;
 }
-/** The stacks under `<base>/stacks`, by name. */
-export declare function listStacks(base: string): Promise<StackEntry[]>;
 /**
- * The stack name for a project without a link: the directory's name, or the first `-2`,
- * `-3`, … suffix that no stack of another project directory holds. A stack this project
+ * The Tenants under `<base>/tenants`, by name: directories with a `tenant.json` (releases
+ * before 0.4 kept other directories there).
+ */
+export declare function listTenants(base: string): Promise<TenantEntry[]>;
+/**
+ * The Tenant name for a project without a link: the directory's name, or the first `-2`,
+ * `-3`, … suffix that no Tenant of another project directory holds. A Tenant this project
  * directory created keeps its name.
  */
-export declare function chooseStackName(base: string, projectDir: string): Promise<string>;
-/** The single stack of older releases: Compose project `nylorun`, Host root `~/.nylorun`. */
-export interface LegacyStack {
-    root: string;
-    project: "nylorun";
-    compose: string;
-    env: string;
-}
-export declare function legacyStack(base: string): LegacyStack | undefined;
-/** What `nylorun legacy delete` removes from `~/.nylorun`: the old layout only, never `stacks/`. */
-export declare const LEGACY_ENTRIES: readonly ["host.json", "host-credentials.json", "host-state.json", "stack", "tenants", "home", "tmp", "trash"];
+export declare function chooseTenantName(base: string, projectDir: string): Promise<string>;
+/**
+ * Move the Host roots of nylorun 0.4 (`~/.nylorun/stacks/<name>/`) to `tenants/<name>/`, when
+ * that is free: `stack.json` becomes `tenant.json`, and `NYLORUN_STACK_NAME` becomes
+ * `NYLORUN_TENANT_NAME` in `docker/.env` (and `docker/compose.yaml`, until the next start
+ * rewrites it). `stacks/` goes when empty. They move rather than start fresh because Compose
+ * project names do not change: a fresh Host root under the same name would reuse the old
+ * volumes with new keys.
+ */
+export declare function moveStackRoots(base: string, err: (line: string) => void): Promise<void>;