nylorun 0.4.0-beta → 0.6.0-beta

package/dist/stack/commands.js

@@ -1,83 +1,137 @@
 import { existsSync } from "node:fs";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { basename, join, resolve } from "node:path";
+import { mkdir, readFile, rm } from "node:fs/promises";
+import { basename, resolve } from "node:path";
 import { compareVersions, PROTOCOL_HEADER, PROTOCOL_VERSION, } from "@nylorun/core/compatibility";
 import { CliError } from "../errors.js";
 import { deriveTenantKey, PROJECT_PRINCIPAL_ID } from "../project/derived-key.js";
 import { readProjectCredentials, readProjectLink, writeProjectCredentials, writeProjectLink, } from "../project/link.js";
 import { findProjectRoot } from "../project/root.js";
 import { seedTenant } from "../project/seed.js";
-import { dockerPreflight, parseComposePs, } from "./docker.js";
+import { readTelemetry, STUDIO_ANALYTICS_ID, TELEMETRY_NOTICE, telemetryDecision, writeTelemetry, } from "../telemetry.js";
+import { dockerPreflight, formatBytes, parseComposePs, tenantMemory, } from "./docker.js";
 import { readAdminKey, readHostConfig, STACK_CLIENT_HOST } from "./host-files.js";
 import { runtimeImageOverridden, stackImages } from "./images.js";
 import { stackPaths } from "./paths.js";
 import { prepareStack, readStackEnv } from "./prepare.js";
-import { assertStackName, chooseStackName, defaultNylorunRoot, LEGACY_ENTRIES, legacyStack, listStacks, readStackRecord, sanitizeStackName, stackRoot, stacksDir, writeStackRecord, } from "./stacks.js";
+import { disconnectProxy, ensureProxySettings, PROXY_PROJECT, proxyDisabled, proxyOrigin, readProxySettings, readProxyStatus, refreshProxyRoutes, startProxy, stopProxy, } from "./proxy.js";
+import { assertTenantName, chooseTenantName, DEFAULT_TENANT, defaultNylorunRoot, listTenants, moveStackRoots, readTenantRecord, sanitizeTenantName, tenantRoot, tenantsDir, writeTenantRecord, } from "./stacks.js";
 import { mintStudioLogin, studioOrigin } from "./studio-login.js";
-export const STACK_SERVICES = ["postgres", "restate", "s2", "gateway", "runtime", "studio"];
-const CORE_SERVICES = ["postgres", "restate", "s2", "gateway", "runtime"];
-export const stackUsage = `  up|start [--name <stack>] [--no-link] [--no-studio] [--no-open] [--allow-downgrade] [--studio-embed-origin <origin>]... [--studio-embed-origin-reset]
-                                      start the project's stack, creating it, its one Tenant and the Project link
-                                      (.nylorun/link.json, credentials.json) on the first run; print the Runtime and Studio URLs
-                                      and open Studio signed in (in a terminal). --name attaches to (or creates) a named stack;
-                                      --no-link starts a stack without linking the current directory
-  down|stop [--name <stack>]          stop the stack's containers; keep volumes
-  status [--name <stack>] [--json]    the stack, its Tenant, services, endpoints and Runtime health
-  logs [service] [--name <stack>] [-f] [--tail <n>]
-                                      stack logs (${STACK_SERVICES.join(", ")})
-  studio [--name <stack>] [--no-open] sign a browser in to Studio on the stack's Tenant; --no-open prints the login URL; start the stack if it is stopped
-  reset [--name <stack>] [--yes]      delete the stack's volumes and its Tenant directory; the next start creates a new Tenant
-  ls [--json]                         the stacks on this machine
-  delete <stack> --yes                remove a stack: containers, volumes and its Host root, with the vault key (KEK)
-  legacy stop|delete [--yes]          stop or remove the single stack of older releases (Compose project nylorun)`;
+export const STACK_SERVICES = ["postgres", "restate", "s2-lite", "gateway", "runtime", "studio"];
+const CORE_SERVICES = ["postgres", "restate", "s2-lite", "gateway", "runtime"];
+export const stackUsage = `  up|start [--tenant <name>] [--no-link] [--no-studio] [--no-open] [--allow-downgrade] [--studio-embed-origin <origin>]... [--studio-embed-origin-reset]
+                                      start the project's Tenant, creating it and the Project link (.nylorun/link.json,
+                                      credentials.json) on the first run; print the Runtime and Studio URLs and open Studio
+                                      signed in (in a terminal). --tenant attaches to (or creates) a named Tenant; --no-link
+                                      starts the default Tenant (or --tenant's) without linking the current directory
+  down|stop [--tenant <name> | --all] stop the Tenant's containers (--all: every Tenant's, and the Studio proxy); keep volumes
+  status [--tenant <name>] [--json]   the Tenant, its id, services, endpoints and Runtime health
+  logs [service] [--tenant <name>] [-f] [--tail <n>]
+                                      container logs (${STACK_SERVICES.join(", ")})
+  studio [--tenant <name>] [--no-open]
+                                      sign a browser in to Studio on the Tenant; --no-open prints the login URL; start the Tenant if it is stopped
+  reset [--tenant <name>] [--yes]     delete the Tenant's data (volumes, tenant/ and vault key); the next start creates it anew
+  ls [--json]                         the Tenants on this machine, with their memory in use
+  delete <tenant> --yes               remove a Tenant: containers, volumes and its Host root, with the vault key (KEK)`;
 const usageError = (message) => new CliError(message, 2);
-/** The Compose project of stack `name`: `nylorun-<name>`, or `NYLORUN_STACK_PROJECT`. */
+/** The Compose project of Tenant `name`: `nylorun-<name>`, or `NYLORUN_COMPOSE_PROJECT`. */
 export function stackProject(env, name) {
-    const override = env.NYLORUN_STACK_PROJECT?.trim();
+    const override = env.NYLORUN_COMPOSE_PROJECT?.trim();
     if (!override)
         return `nylorun-${name}`;
-    return assertStackName(override, "NYLORUN_STACK_PROJECT");
+    return assertTenantName(override, "NYLORUN_COMPOSE_PROJECT");
 }
 function nylorunRoot(deps) {
     return deps.nylorunRoot ?? defaultNylorunRoot();
 }
-async function stackNames(deps) {
-    const names = (await listStacks(nylorunRoot(deps))).map((stack) => stack.name);
-    return names.length ? ` Stacks on this machine: ${names.join(", ")}.` : "";
+/**
+ * The Studio proxy serves the machine's Tenants (`~/.nylorun/tenants`), unless
+ * NYLORUN_PROXY_DISABLED=1; a Host root or Compose project of its own (NYLORUN_HOME,
+ * NYLORUN_COMPOSE_PROJECT, as the repository's smokes use) is outside it.
+ */
+function proxied(ctx) {
+    const { env } = ctx.deps;
+    return !proxyDisabled(env) && !env.NYLORUN_HOME?.trim() && !env.NYLORUN_COMPOSE_PROJECT?.trim();
+}
+/** Studio's URL for browsers: through the proxy when it serves the Tenant, else its own port. */
+async function studioUrl(ctx, studioPort) {
+    const settings = proxied(ctx) ? await readProxySettings(nylorunRoot(ctx.deps)) : undefined;
+    return settings ? proxyOrigin(ctx.name, settings.port) : studioOrigin(studioPort);
+}
+/** The proxy's routes: every Tenant on this machine. */
+async function proxyRoutes(deps) {
+    return (await listTenants(nylorunRoot(deps))).map((tenant) => ({
+        name: tenant.name,
+        project: stackProject(deps.env, tenant.name),
+    }));
+}
+/**
+ * Compose's names for a 0.5 Tenant's volumes (`<project>_postgres`, …) that exist on this
+ * engine, and whether this release's `<project>-postgres` does.
+ */
+async function oldVolumes(docker, project) {
+    const result = await docker.run(["volume", "ls", "--quiet", "--filter", `name=${project}`]);
+    const names = new Set(result.code === 0 ? result.stdout.split(/\s+/) : []);
+    return {
+        old: ["postgres", "restate", "s2", "workspaces"]
+            .map((volume) => `${project}_${volume}`)
+            .filter((name) => names.has(name)),
+        current: names.has(`${project}-postgres`),
+    };
+}
+/**
+ * Before `docker compose down` (`reset`, `delete`): detach the proxy from the Tenant's network
+ * so Compose can remove it. After it: drop a 0.5 Tenant's volumes and network.
+ */
+async function composeDown(ctx, args) {
+    const { docker } = ctx.deps;
+    await disconnectProxy(docker, ctx.project);
+    const code = await docker.stream(args);
+    if (code !== 0)
+        throw new CliError(`docker compose down failed (exit ${code}).`, 1);
+    const { old } = await oldVolumes(docker, ctx.project);
+    if (old.length) {
+        await docker.run(["volume", "rm", ...old]);
+        await docker.run(["network", "rm", `${ctx.project}_default`]);
+    }
+}
+async function tenantNames(deps) {
+    const names = (await listTenants(nylorunRoot(deps))).map((tenant) => tenant.name);
+    return names.length ? ` Tenants on this machine: ${names.join(", ")}.` : "";
 }
 /**
- * Which stack a command acts on: `--name`, then `NYLORUN_STACK`, then the stack of the
- * project's link (format 2); for `start` in a project, then a name from the project
- * directory (`chooseStackName`). `NYLORUN_HOME` sets the Host root whatever the name; its
- * name otherwise comes from its `stack.json`, the project directory or the Host root's own.
+ * Which Tenant a command acts on: `--tenant`, then `NYLORUN_TENANT`, then the Tenant of the
+ * project's link (format 3; `start` replaces an older one); for `start` in a project, then a
+ * name from the project directory (`chooseTenantName`); outside a project (or with
+ * --no-link), `default`. `NYLORUN_HOME` sets the Host root whatever the name; its name
+ * otherwise comes from its `tenant.json`, the project directory or the Host root's own.
  */
 async function selectStack(deps, options = {}) {
     const { env } = deps;
     const base = nylorunRoot(deps);
     const projectDir = options.noLink ? undefined : findProjectRoot(deps.cwd ?? process.cwd());
     const link = projectDir ? await readProjectLink(projectDir) : undefined;
-    const explicit = options.name ?? (env.NYLORUN_STACK?.trim() || undefined);
+    const explicit = options.name ?? (env.NYLORUN_TENANT?.trim() || undefined);
     if (explicit !== undefined)
-        assertStackName(explicit, options.name !== undefined ? "--name" : "NYLORUN_STACK");
-    let name = explicit ?? (link?.format === 2 ? link.stack : undefined);
+        assertTenantName(explicit, options.name !== undefined ? "--tenant" : "NYLORUN_TENANT");
+    let name = explicit ?? link?.tenant;
     let root;
     const home = env.NYLORUN_HOME?.trim();
     if (home) {
         root = resolve(home);
         name ??=
-            (await readStackRecord(root))?.name ??
-                sanitizeStackName(basename(projectDir ?? root));
+            (await readTenantRecord(root))?.name ??
+                sanitizeTenantName(basename(projectDir ?? root));
     }
     else {
         if (name === undefined && options.start && projectDir)
-            name = await chooseStackName(base, projectDir);
+            name = await chooseTenantName(base, projectDir);
+        if (name === undefined && !projectDir)
+            name = DEFAULT_TENANT;
         if (name === undefined)
-            throw usageError(options.start
-                ? `Not in a project: name the stack with "nylorun start --name <stack>" (or NYLORUN_STACK).${await stackNames(deps)}`
-                : `No stack selected: run this in a project "nylorun start" linked, pass --name <stack>, or set NYLORUN_STACK.${await stackNames(deps)}`);
-        root = stackRoot(base, name);
+            throw usageError(`No Tenant selected: run "nylorun start" in this project, pass --tenant <name>, or set NYLORUN_TENANT.${await tenantNames(deps)}`);
+        root = tenantRoot(base, name);
     }
-    assertStackName(name, "The stack name");
+    assertTenantName(name, "The Tenant name");
     return {
         deps,
         name,
@@ -101,7 +155,7 @@ function composeArgs(ctx, ...args) {
 }
 function requireStackFiles(ctx) {
     if (!existsSync(ctx.paths.compose) || !existsSync(ctx.paths.env))
-        throw new CliError(`No Nylorun stack ${ctx.name} under ${ctx.paths.root}. Run "nylorun start" first.`, 3);
+        throw new CliError(`No Tenant ${ctx.name} under ${ctx.paths.root}. Run "nylorun start" first.`, 3);
 }
 export function parseStackFlags(args, allowed, usage) {
     const booleans = new Set();
@@ -137,9 +191,9 @@ export function parseStackFlags(args, allowed, usage) {
     }
     return { rest, booleans, values, lists };
 }
-/** `--name` when given. */
+/** `--tenant` when given. */
 function nameOption(flags) {
-    const name = flags.values.get("--name");
+    const name = flags.values.get("--tenant");
     return name === undefined ? {} : { name };
 }
 async function sleep(ms) {
@@ -203,16 +257,16 @@ async function fetchTenant(deps, adminUrl, adminKey) {
         return undefined;
     }
 }
-/** Why the stack's Tenant is unavailable, with the repair the Runtime names. */
+/** Why the Tenant is unavailable, with the repair the Runtime names. */
 function tenantCauseMessage(ctx, tenant) {
     const cause = tenant.cause;
     const hint = cause.code === "schema-too-new"
-        ? ` This nylorun pins Runtime ${ctx.deps.runtimeVersion}, older than the stack's database: update nylorun (npx nylorun@latest start).`
+        ? ` This nylorun pins Runtime ${ctx.deps.runtimeVersion}, older than the Tenant's database: update nylorun (npx nylorun@latest start).`
         : "";
-    return `The Tenant of stack ${ctx.name} is unavailable (${cause.code}): ${cause.message} ${cause.repair}${hint} See "nylorun logs runtime".`;
+    return `Tenant ${ctx.name} is unavailable (${cause.code}): ${cause.message} ${cause.repair}${hint} See "nylorun logs runtime".`;
 }
 /**
- * Wait until the stack's Tenant is open: the Runtime creates it on the first start and opens
+ * Wait until the Tenant is open: the Runtime creates it on the first start and opens
  * it on later ones. A Tenant that could not be opened has a cause; report it.
  */
 async function waitForTenant(ctx, adminUrl, adminKey) {
@@ -224,7 +278,7 @@ async function waitForTenant(ctx, adminUrl, adminKey) {
         if (tenant?.cause)
             throw new CliError(tenantCauseMessage(ctx, tenant), 7);
         if (Date.now() > deadline)
-            throw new CliError(`The Tenant of stack ${ctx.name} did not open (${adminUrl}/v1/admin/status: ${tenant ? tenant.state : "no answer"}). See "nylorun status" and "nylorun logs runtime".`, 7);
+            throw new CliError(`Tenant ${ctx.name} did not open (${adminUrl}/v1/admin/status: ${tenant ? tenant.state : "no answer"}). See "nylorun status" and "nylorun logs runtime".`, 7);
         await sleep(ctx.deps.pollMs ?? 500);
     }
 }
@@ -267,7 +321,7 @@ function isOlder(version, than) {
         compareVersions(version, than) < 0);
 }
 /**
- * Refuse a Runtime older than the stack's database: the Runtime that last ran the stack
+ * Refuse a Runtime older than the Tenant's database: the Runtime that last ran the Tenant
  * (host.json `runtimeVersion`) migrated it, and an older one cannot open its Tenant
  * (`schema-too-new`). Checked before Compose replaces anything. Skipped when
  * `NYLORUN_RUNTIME_IMAGE` names the image.
@@ -278,21 +332,16 @@ async function refuseDowngrade(ctx, allowDowngrade) {
     if (!isOlder(pinned, host?.runtimeVersion))
         return;
     if (allowDowngrade) {
-        ctx.deps.err(`Warning: starting Runtime ${pinned} on stack ${ctx.name}, which Runtime ${host.runtimeVersion} last ran. If that Runtime migrated the database, the Tenant stays unavailable (schema-too-new).`);
+        ctx.deps.err(`Warning: starting Runtime ${pinned} on Tenant ${ctx.name}, which Runtime ${host.runtimeVersion} last ran. If that Runtime migrated the database, the Tenant stays unavailable (schema-too-new).`);
         return;
     }
-    throw new CliError(`Refusing to start Runtime ${pinned} on stack ${ctx.name}: Runtime ${host.runtimeVersion} last ran it (${ctx.paths.config}), and a Runtime older than the stack's database cannot open its Tenant. Update nylorun (npx nylorun@latest start), or run "nylorun start --allow-downgrade" when both Runtimes use the same database schema.`, 5);
+    throw new CliError(`Refusing to start Runtime ${pinned} on Tenant ${ctx.name}: Runtime ${host.runtimeVersion} last ran it (${ctx.paths.config}), and a Runtime older than the Tenant's database cannot open its Tenant. Update nylorun (npx nylorun@latest start), or run "nylorun start --allow-downgrade" when both Runtimes use the same database schema.`, 5);
 }
-/** Ports other stacks (and the legacy stack) keep in their `.env`, so a new stack avoids them. */
-async function reservedPorts(ctx) {
-    const base = nylorunRoot(ctx.deps);
-    const others = (await listStacks(base))
-        .filter((stack) => resolve(stack.root) !== ctx.paths.root)
-        .map((stack) => stackPaths(stack.root));
-    // The legacy stack keeps its .env in stack/, not docker/.
-    const legacy = legacyStack(base);
-    if (legacy && resolve(base) !== ctx.paths.root)
-        others.push(legacy);
+/** Ports the Tenants on this machine keep in their `.env` (but the one under `except`). */
+async function tenantPorts(base, except) {
+    const others = (await listTenants(base))
+        .filter((tenant) => resolve(tenant.root) !== except)
+        .map((tenant) => stackPaths(tenant.root));
     const reserved = new Set();
     for (const paths of others) {
         const persisted = await readStackEnv(paths);
@@ -307,12 +356,31 @@ async function reservedPorts(ctx) {
     }
     return reserved;
 }
+/** Ports other Tenants and the proxy keep, so a new Tenant avoids them. */
+async function reservedPorts(ctx) {
+    const base = nylorunRoot(ctx.deps);
+    const reserved = await tenantPorts(base, ctx.paths.root);
+    const proxy = await readProxySettings(base);
+    if (proxy)
+        reserved.add(proxy.port);
+    return reserved;
+}
 async function bringUp(ctx, options) {
     const { deps } = ctx;
     await refuseLauncherRuntime(ctx);
     const overridden = runtimeImageOverridden(deps.env);
     if (!overridden)
         await refuseDowngrade(ctx, options.allowDowngrade ?? false);
+    const legacy = await oldVolumes(deps.docker, ctx.project);
+    if (legacy.old.length && !legacy.current)
+        throw new CliError(`Tenant ${ctx.name} was created by nylorun 0.5; its data is in the old volumes ${legacy.old.join(", ")}. Run "nylorun reset --tenant ${ctx.name}" to start it fresh; that also removes the old volumes (or drop them yourself with "docker volume rm ${legacy.old.join(" ")}").`, 3);
+    const base = nylorunRoot(deps);
+    const telemetry = await readTelemetry(base);
+    const analytics = telemetryDecision(deps.env, telemetry).enabled;
+    // The proxy's port avoids every Tenant's; a new Tenant's ports then avoid the proxy's.
+    const proxy = proxied(ctx)
+        ? await ensureProxySettings(base, deps.ports, await tenantPorts(base))
+        : undefined;
     const prepared = await prepareStack({
         paths: ctx.paths,
         name: ctx.name,
@@ -331,13 +399,19 @@ async function bringUp(ctx, options) {
             ? { derivedPrincipals: deps.env.NYLORUN_DERIVED_PRINCIPALS }
             : {}),
         ...(options.studioEmbedOrigins ? { studioEmbedOrigins: options.studioEmbedOrigins } : {}),
+        ...(analytics ? { studioAnalyticsId: STUDIO_ANALYTICS_ID } : {}),
+        ...(proxy ? { studioPublicOrigin: proxyOrigin(ctx.name, proxy.port) } : {}),
     });
-    const record = await readStackRecord(ctx.paths.root);
+    if (analytics && options.studio && telemetry.noticeShown === undefined) {
+        deps.err(TELEMETRY_NOTICE);
+        await writeTelemetry(nylorunRoot(deps), { ...telemetry, noticeShown: new Date().toISOString() });
+    }
+    const record = await readTenantRecord(ctx.paths.root);
     const project = record?.project ?? ctx.projectDir;
     if (record?.name !== ctx.name || record.project !== project)
-        await writeStackRecord(ctx.paths.root, { name: ctx.name, ...(project ? { project } : {}) });
+        await writeTenantRecord(ctx.paths.root, { name: ctx.name, ...(project ? { project } : {}) });
     if (prepared.firstRun)
-        deps.err(`Created stack ${ctx.name} under ${ctx.paths.root} (Runtime port ${prepared.env.runtimePort}, Studio port ${prepared.env.studioPort}).`);
+        deps.err(`Created Tenant ${ctx.name} under ${ctx.paths.root} (Runtime port ${prepared.env.runtimePort}, Studio port ${prepared.env.studioPort}).`);
     const runtimeUrl = `http://${STACK_CLIENT_HOST}:${prepared.env.runtimePort}`;
     const adminUrl = `http://${STACK_CLIENT_HOST}:${prepared.env.adminPort}`;
     const up = await deps.docker.stream(composeArgs(ctx, "up", "--detach", "--wait", "--wait-timeout", "300", ...CORE_SERVICES));
@@ -356,30 +430,59 @@ async function bringUp(ctx, options) {
         if (!studioStarted)
             deps.err(`Warning: Studio did not start (image ${prepared.env.studioImage}). The Runtime is up; see "nylorun logs studio".`);
     }
+    let studioUrl = studioOrigin(prepared.env.studioPort);
+    if (studioStarted && proxy) {
+        const up = await startProxy({
+            docker: deps.docker,
+            base,
+            settings: proxy,
+            routes: await proxyRoutes(deps),
+            err: deps.err,
+            ...(deps.pollMs !== undefined ? { pollMs: deps.pollMs } : {}),
+        });
+        if (up)
+            studioUrl = proxyOrigin(ctx.name, proxy.port);
+    }
     return {
         runtimeUrl,
         adminUrl,
         hostId: prepared.host.hostId,
         studioPort: prepared.env.studioPort,
+        studioUrl,
         studioStarted,
         adminKey: prepared.adminKey,
     };
 }
-async function tryStudioLogin(ctx, studioPort, adminKey) {
-    const deadline = Date.now() + (ctx.deps.loginTimeoutMs ?? 15_000);
+const errorText = (error) => (error instanceof Error ? error.message : String(error));
+/**
+ * A login URL on Studio's URL: through the proxy when it serves the Tenant (once; a proxy that
+ * does not answer falls back, saying so), else on Studio's own port, retried while it starts.
+ */
+async function tryStudioLogin(ctx, studio, adminKey) {
+    const { deps } = ctx;
+    const origin = studioOrigin(studio.port);
+    if (studio.url !== origin) {
+        try {
+            return await mintStudioLogin({ fetch: deps.fetch, origin: studio.url, adminKey });
+        }
+        catch (error) {
+            deps.err(`Studio did not answer through the proxy at ${studio.url} (${errorText(error)}); signing in at ${origin} instead.`);
+        }
+    }
+    const deadline = Date.now() + (deps.loginTimeoutMs ?? 15_000);
     let lastError = "";
     for (;;) {
         try {
-            return await mintStudioLogin({ fetch: ctx.deps.fetch, studioPort, adminKey });
+            return await mintStudioLogin({ fetch: deps.fetch, origin, adminKey });
         }
         catch (error) {
-            lastError = error instanceof Error ? error.message : String(error);
+            lastError = errorText(error);
         }
         if (Date.now() > deadline)
             break;
-        await sleep(ctx.deps.pollMs ?? 500);
+        await sleep(deps.pollMs ?? 500);
     }
-    ctx.deps.err(`Warning: Studio at ${studioOrigin(studioPort)} is not reachable for a login (${lastError}).`);
+    deps.err(`Warning: Studio at ${origin} is not reachable for a login (${lastError}).`);
     return undefined;
 }
 /** Printed by `start` when it does not open Studio itself. */
@@ -396,36 +499,23 @@ async function openLogin(ctx, login) {
     if (!(await ctx.deps.openBrowser(login)))
         ctx.deps.out(`Sign in   ${login}`);
 }
-/** The legacy stack is mentioned once per machine (a marker under `stacks/`). */
-async function noteLegacy(deps) {
-    const base = nylorunRoot(deps);
-    const legacy = legacyStack(base);
-    const marker = join(stacksDir(base), ".legacy-noted");
-    if (!legacy || existsSync(marker))
-        return;
-    deps.err(`Note: the single stack of an older release is still on this machine (Compose project nylorun, Host root ${legacy.root}). Stacks are now one per project, and the old one is left as it is: stop it with "npx nylorun legacy stop", or remove it and its Tenants with "npx nylorun legacy delete --yes".`);
-    await mkdir(stacksDir(base), { recursive: true, mode: 0o700 });
-    await writeFile(marker, "", { mode: 0o600 });
-}
 /**
- * Link the project to the stack: `.nylorun/link.json` (format 2) and
+ * Link the project to the Tenant: `.nylorun/link.json` (format 3) and
  * `.nylorun/credentials.json` with the key of the derived principal `project`. The link is
- * rewritten only when the stack, its URL, Host or Tenant changed; a new link seeds the
- * Tenant from the project's `.env`.
+ * rewritten only when it is older, or the Tenant's name, URL, Host or id changed; a new link
+ * seeds the Tenant from the project's `.env`.
  */
 async function linkProject(ctx, started, tenantId) {
     const { deps, projectDir, link } = ctx;
-    if (link && link.format < 2)
-        deps.err(`This project was linked to a Tenant on ${link.hostUrl}, a stack of an older Runtime. It gets its own stack, ${ctx.name}, and a new link; model credentials come from .env (or Studio), and agents register again (npm run dev).`);
     const applicationKey = deriveTenantKey(started.adminKey, tenantId, PROJECT_PRINCIPAL_ID);
-    const fresh = link?.format !== 2 ||
-        link.stack !== ctx.name ||
+    const fresh = link?.format !== 3 ||
+        link.tenant !== ctx.name ||
         link.hostUrl !== started.runtimeUrl ||
         link.hostId !== started.hostId ||
         link.tenantId !== tenantId;
     if (fresh)
         await writeProjectLink(projectDir, {
-            stack: ctx.name,
+            tenant: ctx.name,
             hostUrl: started.runtimeUrl,
             hostId: started.hostId,
             tenantId,
@@ -440,7 +530,7 @@ async function linkProject(ctx, started, tenantId) {
         });
     if (!fresh)
         return;
-    deps.err(`Linked ${projectDir} to stack ${ctx.name} (.nylorun/link.json, .nylorun/credentials.json).`);
+    deps.err(`Linked ${projectDir} to Tenant ${ctx.name} (.nylorun/link.json, .nylorun/credentials.json).`);
     try {
         const seeded = await seedTenant({
             fetch: deps.fetch,
@@ -456,7 +546,7 @@ async function linkProject(ctx, started, tenantId) {
         deps.err(`Warning: could not seed the Tenant from .env (${error instanceof Error ? error.message : String(error)}). Set the model in Studio or with "npx @nylorun/cli configure".`);
     }
 }
-const START_USAGE = "nylorun start [--name <stack>] [--no-link] [--no-studio] [--no-open] [--allow-downgrade] [--studio-embed-origin <origin>]... [--studio-embed-origin-reset]";
+const START_USAGE = "nylorun start [--tenant <name>] [--no-link] [--no-studio] [--no-open] [--allow-downgrade] [--studio-embed-origin <origin>]... [--studio-embed-origin-reset]";
 async function start(deps, args) {
     const flags = parseStackFlags(args, {
         booleans: [
@@ -466,7 +556,7 @@ async function start(deps, args) {
             "--allow-downgrade",
             "--studio-embed-origin-reset",
         ],
-        values: ["--name"],
+        values: ["--tenant"],
         lists: ["--studio-embed-origin"],
     }, START_USAGE);
     if (flags.rest.length)
@@ -477,7 +567,6 @@ async function start(deps, args) {
         noLink: flags.booleans.has("--no-link"),
     });
     await dockerPreflight(deps.docker);
-    await noteLegacy(deps);
     const embedOrigins = flags.lists.get("--studio-embed-origin") ?? [];
     const resetEmbed = flags.booleans.has("--studio-embed-origin-reset");
     const started = await bringUp(ctx, {
@@ -490,35 +579,86 @@ async function start(deps, args) {
     const tenant = await waitForTenant(ctx, started.adminUrl, started.adminKey);
     if (ctx.projectDir)
         await linkProject({ ...ctx, projectDir: ctx.projectDir }, started, tenant.id);
-    deps.out(`Stack     ${ctx.name}  (${ctx.paths.root})`);
-    deps.out(`Tenant    ${tenant.id}${tenant.name ? `  (${tenant.name})` : ""}`);
+    deps.out(`Tenant    ${ctx.name}  (${tenant.id})`);
     deps.out(`Runtime   ${started.runtimeUrl}`);
     if (started.studioStarted) {
-        deps.out(`Studio    ${studioOrigin(started.studioPort)}`);
+        deps.out(`Studio    ${started.studioUrl}`);
         if (opensBrowser(deps, flags)) {
-            const login = await tryStudioLogin(ctx, started.studioPort, started.adminKey);
+            const login = await tryStudioLogin(ctx, { port: started.studioPort, url: started.studioUrl }, started.adminKey);
             if (login)
                 await openLogin(ctx, withNext(login, tenantStudioPath(tenant.id)));
         }
         else
             deps.err(STUDIO_SIGN_IN_HINT);
     }
+    await alsoRunning(ctx);
     return 0;
 }
+/** After `start`: the machine's other running Tenants and their memory, on stderr. */
+async function alsoRunning(ctx) {
+    const { deps } = ctx;
+    const projects = await composeProjects(deps.docker);
+    if (!projects)
+        return;
+    const others = (await listTenants(nylorunRoot(deps)))
+        .map((tenant) => tenant.name)
+        .filter((name) => name !== ctx.name && projects.get(`nylorun-${name}`) === "running");
+    if (others.length === 0)
+        return;
+    const memory = await tenantMemory(deps.docker);
+    const sizes = others.map((name) => memory?.get(name));
+    const total = sizes.every((size) => size !== undefined)
+        ? sizes.reduce((sum, size) => sum + size, 0)
+        : undefined;
+    deps.err(`Also running: ${others.join(", ")}${total === undefined ? "" : ` (about ${formatBytes(total)})`}. "nylorun stop --all" stops them all.`);
+}
 async function stop(deps, args) {
-    const usage = "nylorun stop [--name <stack>]";
-    const flags = parseStackFlags(args, { values: ["--name"] }, usage);
+    const usage = "nylorun stop [--tenant <name> | --all]";
+    const flags = parseStackFlags(args, { booleans: ["--all"], values: ["--tenant"] }, usage);
     if (flags.rest.length)
         throw usageError(`Usage: ${usage}`);
+    if (flags.booleans.has("--all")) {
+        if (flags.values.has("--tenant"))
+            throw usageError(`--all and --tenant are exclusive. Usage: ${usage}`);
+        return await stopAll(deps);
+    }
     const ctx = await selectStack(deps, nameOption(flags));
     requireStackFiles(ctx);
     await dockerPreflight(deps.docker);
     const code = await deps.docker.stream(composeArgs(ctx, "stop"));
     if (code !== 0)
         throw new CliError(`docker compose stop failed (exit ${code}).`, 1);
-    deps.out(`Stopped stack ${ctx.name}; volumes are kept.`);
+    deps.out(`Stopped Tenant ${ctx.name}; its data is kept.`);
     return 0;
 }
+/** `stop --all`: every running Tenant on this machine, then the Studio proxy; volumes are kept. */
+async function stopAll(deps) {
+    await dockerPreflight(deps.docker);
+    const projects = (await composeProjects(deps.docker)) ?? new Map();
+    const stopped = [];
+    for (const tenant of await listTenants(nylorunRoot(deps))) {
+        const project = `nylorun-${tenant.name}`;
+        if (projects.get(project) !== "running")
+            continue;
+        const paths = stackPaths(tenant.root);
+        const code = await deps.docker.stream(existsSync(paths.compose) && existsSync(paths.env)
+            ? composeArgs({ project, paths }, "stop")
+            : ["compose", "--project-name", project, "stop"]);
+        if (code !== 0)
+            throw new CliError(`docker compose stop failed for Tenant ${tenant.name} (exit ${code}).`, 1);
+        stopped.push(tenant.name);
+    }
+    const proxy = projects.get(PROXY_PROJECT) === "running" && (await stopProxy(deps.docker));
+    deps.out(stopped.length
+        ? `Stopped Tenants ${stopped.join(", ")}${proxy ? " and the Studio proxy" : ""}; their data is kept.`
+        : `No Tenant was running${proxy ? "; stopped the Studio proxy" : ""}.`);
+    return 0;
+}
+async function studioUrls(ctx, port) {
+    const url = await studioUrl(ctx, port);
+    const direct = studioOrigin(port);
+    return url === direct ? { url } : { url: direct, proxyUrl: url };
+}
 async function stackStatus(ctx) {
     const base = {
         name: ctx.name,
@@ -542,7 +682,7 @@ async function stackStatus(ctx) {
     const health = runtimeUrl ? await fetchHealth(ctx.deps, runtimeUrl) : undefined;
     const host = await readHostConfig(ctx.paths);
     const healthy = health?.status === "ok" && (host === undefined || health.hostId === host.hostId);
-    // The Admin API answers on the operator port; an older stack has only the Runtime port.
+    // The Admin API answers on the operator port; an older Host root has only the Runtime port.
     const adminUrl = persisted.adminPort
         ? `http://${STACK_CLIENT_HOST}:${persisted.adminPort}`
         : runtimeUrl;
@@ -563,7 +703,7 @@ async function stackStatus(ctx) {
         },
         ...(tenant ? { tenant } : {}),
         studio: {
-            ...(persisted.studioPort ? { url: studioOrigin(persisted.studioPort) } : {}),
+            ...(persisted.studioPort ? await studioUrls(ctx, persisted.studioPort) : {}),
             state: studio ? [studio.state, studio.health].filter(Boolean).join(", ") : "absent",
             ...(persisted.studioFrameAncestors
                 ? { embedOrigins: persisted.studioFrameAncestors }
@@ -579,8 +719,13 @@ async function stackStatus(ctx) {
         services,
     };
 }
+/** The Studio proxy, as data (`nylorun doctor`). */
+export async function readProxyReport(deps) {
+    return await readProxyStatus(deps.docker, nylorunRoot(deps), deps.env);
+}
 /** What `nylorun status` reports, as data (`nylorun doctor`). */
 export async function readStackStatus(deps, options = {}) {
+    await moveStackRoots(nylorunRoot(deps), deps.err);
     return await stackStatus(await selectStack(deps, options));
 }
 function describeTenant(tenant) {
@@ -592,8 +737,8 @@ function describeTenant(tenant) {
         : `${who}  unavailable (opening)`;
 }
 async function status(deps, args) {
-    const usage = "nylorun status [--name <stack>] [--json]";
-    const flags = parseStackFlags(args, { booleans: ["--json"], values: ["--name"] }, usage);
+    const usage = "nylorun status [--tenant <name>] [--json]";
+    const flags = parseStackFlags(args, { booleans: ["--json"], values: ["--tenant"] }, usage);
     if (flags.rest.length)
         throw usageError(`Usage: ${usage}`);
     const result = await stackStatus(await selectStack(deps, nameOption(flags)));
@@ -602,20 +747,21 @@ async function status(deps, args) {
         out(JSON.stringify(result, null, 2));
     }
     else if (result.state === "absent") {
-        out(`Stack       ${result.name} absent (nothing under ${result.home}; run "nylorun start")`);
+        out(`Tenant      ${result.name} absent (nothing under ${result.home}; run "nylorun start")`);
     }
     else {
-        out(`Stack       ${result.name} ${result.state} (Compose project ${result.project})`);
+        out(`Tenant      ${result.name}  ${result.state} (Compose project ${result.project})`);
         out(`Host root   ${result.home} (admin key in host-credentials.json, mode 0600)`);
         if (result.tenant)
-            out(`Tenant      ${describeTenant(result.tenant)}`);
+            out(`Tenant id   ${describeTenant(result.tenant)}`);
         const runtimeDetail = result.runtime.healthy
             ? `healthy, ${result.runtime.version ?? "?"}, ${result.runtime.hostId ?? "?"}`
             : "not answering";
         out(`Runtime     ${result.runtime.url ?? "?"}  ${runtimeDetail}`);
         if (result.runtime.adminUrl)
             out(`Admin API   ${result.runtime.adminUrl}  (operators only, never proxied)`);
-        out(`Studio      ${result.studio.url ?? "?"}  ${result.studio.state} (log in with "nylorun studio")`);
+        const also = result.studio.proxyUrl ? `also ${result.studio.url}; ` : "";
+        out(`Studio      ${result.studio.proxyUrl ?? result.studio.url ?? "?"}  ${result.studio.state} (${also}log in with "nylorun studio")`);
         if (result.studio.embedOrigins?.length)
             out(`Embeds      ${result.studio.embedOrigins.join(" ")}  (may show Studio in a frame)`);
         out(`Gateway     ${result.gateway.state} (the Model Gate; model calls fail while it is down)`);
@@ -632,8 +778,8 @@ async function status(deps, args) {
     return result.runtime.healthy ? 0 : 3;
 }
 async function logs(deps, args) {
-    const usage = `nylorun logs [${STACK_SERVICES.join("|")}] [--name <stack>] [-f] [--tail <n>]`;
-    const flags = parseStackFlags(args, { booleans: ["--follow"], values: ["--tail", "--name"], aliases: { "-f": "--follow" } }, usage);
+    const usage = `nylorun logs [${STACK_SERVICES.join("|")}] [--tenant <name>] [-f] [--tail <n>]`;
+    const flags = parseStackFlags(args, { booleans: ["--follow"], values: ["--tail", "--tenant"], aliases: { "-f": "--follow" } }, usage);
     if (flags.rest.length > 1)
         throw usageError(`Usage: ${usage}`);
     const service = flags.rest[0];
@@ -648,16 +794,16 @@ async function logs(deps, args) {
     return await deps.docker.stream(composeArgs(ctx, "logs", ...(flags.booleans.has("--follow") ? ["--follow"] : []), ...(tail !== undefined ? ["--tail", tail] : []), ...(service ? [service] : [])));
 }
 async function reset(deps, args) {
-    const usage = "nylorun reset [--name <stack>] [--yes]";
-    const flags = parseStackFlags(args, { booleans: ["--yes"], values: ["--name"], aliases: { "-y": "--yes" } }, usage);
+    const usage = "nylorun reset [--tenant <name>] [--yes]";
+    const flags = parseStackFlags(args, { booleans: ["--yes"], values: ["--tenant"], aliases: { "-y": "--yes" } }, usage);
     if (flags.rest.length)
         throw usageError(`Usage: ${usage}`);
     const ctx = await selectStack(deps, nameOption(flags));
     const { paths } = ctx;
     if (!flags.booleans.has("--yes")) {
-        const question = `Delete stack ${ctx.name}'s volumes (Compose project ${ctx.project}) and its Tenant directory ${paths.tenant} and vault key ${paths.vaultKey}? Its Tenant's data is lost and the next start creates a new Tenant. [y/N] `;
+        const question = `Delete Tenant ${ctx.name}'s volumes (Compose project ${ctx.project}), its Tenant directory ${paths.tenant} and its vault key ${paths.vaultKey}? Its data is lost, and the next start creates the Tenant anew, with a new id. [y/N] `;
         if (!deps.confirm)
-            throw usageError(`nylorun reset deletes stack ${ctx.name}'s Tenant and all its data; pass --yes to confirm when not in a terminal.`);
+            throw usageError(`nylorun reset deletes all of Tenant ${ctx.name}'s data; pass --yes to confirm when not in a terminal.`);
         if (!(await deps.confirm(question))) {
             deps.err("Reset cancelled.");
             return 1;
@@ -665,15 +811,13 @@ async function reset(deps, args) {
     }
     if (existsSync(paths.compose) && existsSync(paths.env)) {
         await dockerPreflight(deps.docker);
-        const code = await deps.docker.stream(composeArgs(ctx, "down", "--volumes", "--remove-orphans"));
-        if (code !== 0)
-            throw new CliError(`docker compose down failed (exit ${code}).`, 1);
+        await composeDown(ctx, composeArgs(ctx, "down", "--volumes", "--remove-orphans"));
     }
     await rm(paths.tenant, { recursive: true, force: true });
     await mkdir(paths.tenant, { recursive: true, mode: 0o700 });
     // The vault key goes with the Tenant's data; the next start writes a new one.
     await rm(paths.keys, { recursive: true, force: true });
-    deps.out(`Reset stack ${ctx.name}: volumes and the Tenant directory deleted. Run "nylorun start" to start again with a new Tenant (it relinks the project).`);
+    deps.out(`Reset Tenant ${ctx.name}: its volumes, Tenant directory and vault key deleted. Run "nylorun start" to create it anew (it relinks the project).`);
     return 0;
 }
 /** Compose projects on this Docker engine and whether any container runs; undefined without Docker. */
@@ -701,18 +845,30 @@ async function ls(deps, args) {
     const base = nylorunRoot(deps);
     const projects = await composeProjects(deps.docker);
     const state = (project) => (projects ? (projects.get(project) ?? "stopped") : "unknown");
-    const stacks = [];
-    for (const entry of await listStacks(base)) {
+    const memory = [...(projects?.values() ?? [])].includes("running")
+        ? await tenantMemory(deps.docker)
+        : undefined;
+    const proxy = proxyDisabled(deps.env) ? undefined : await readProxySettings(base);
+    const tenants = [];
+    for (const entry of await listTenants(base)) {
         const persisted = (await readStackEnv(stackPaths(entry.root))) ?? {};
-        stacks.push({
+        const tenantState = state(`nylorun-${entry.name}`);
+        tenants.push({
             name: entry.name,
             root: entry.root,
-            ...(entry.record?.project ? { project: entry.record.project } : {}),
-            state: state(`nylorun-${entry.name}`),
+            ...(entry.record.project ? { project: entry.record.project } : {}),
+            state: tenantState,
+            memoryBytes: (tenantState === "running" && memory?.get(entry.name)) || null,
             ...(persisted.runtimePort
                 ? { runtimeUrl: `http://${STACK_CLIENT_HOST}:${persisted.runtimePort}` }
                 : {}),
-            ...(persisted.studioPort ? { studioUrl: studioOrigin(persisted.studioPort) } : {}),
+            ...(persisted.studioPort
+                ? {
+                    studioUrl: proxy
+                        ? proxyOrigin(entry.name, proxy.port)
+                        : studioOrigin(persisted.studioPort),
+                }
+                : {}),
             ports: {
                 ...(persisted.runtimePort ? { runtime: persisted.runtimePort } : {}),
                 ...(persisted.adminPort ? { admin: persisted.adminPort } : {}),
@@ -721,96 +877,54 @@ async function ls(deps, args) {
             },
         });
     }
-    const legacy = legacyStack(base);
-    const legacyView = legacy
-        ? { root: legacy.root, project: legacy.project, state: state(legacy.project) }
-        : undefined;
     if (flags.booleans.has("--json")) {
-        deps.out(JSON.stringify({ stacks, ...(legacyView ? { legacy: legacyView } : {}) }, null, 2));
+        deps.out(JSON.stringify({ tenants }, null, 2));
         return 0;
     }
-    if (stacks.length === 0)
-        deps.out(`No stacks under ${stacksDir(base)}. Run "npx nylorun start" in a project.`);
-    else {
-        const width = Math.max(4, ...stacks.map((stack) => stack.name.length)) + 2;
-        deps.out(`${"NAME".padEnd(width)}${"STATE".padEnd(9)}${"RUNTIME".padEnd(24)}${"STUDIO".padEnd(24)}PROJECT`);
-        for (const stack of stacks)
-            deps.out(`${stack.name.padEnd(width)}${stack.state.padEnd(9)}${(stack.runtimeUrl ?? "-").padEnd(24)}${(stack.studioUrl ?? "-").padEnd(24)}${stack.project ?? "-"}`);
+    if (tenants.length === 0) {
+        deps.out('No Tenants on this machine. Run "npx nylorun start" in a project (or anywhere, for the default Tenant).');
+        return 0;
     }
-    if (legacyView)
-        deps.out(`Legacy stack: Compose project nylorun, Host root ${legacyView.root} (${legacyView.state}); "nylorun legacy stop|delete" handles it.`);
+    const rows = [
+        ["TENANT", "STATE", "MEMORY", "RUNTIME", "STUDIO", "PROJECT"],
+        ...tenants.map((tenant) => [
+            tenant.name,
+            tenant.state,
+            tenant.memoryBytes === null ? "-" : formatBytes(tenant.memoryBytes),
+            tenant.runtimeUrl ?? "-",
+            tenant.studioUrl ?? "-",
+            tenant.project ?? "-",
+        ]),
+    ];
+    const widths = rows[0].map((_, column) => Math.max(...rows.map((row) => row[column].length)) + 2);
+    for (const row of rows)
+        deps.out(row.map((cell, column) => (column < row.length - 1 ? cell.padEnd(widths[column]) : cell)).join(""));
     return 0;
 }
 async function deleteStack(deps, args) {
-    const usage = "nylorun delete <stack> --yes";
+    const usage = "nylorun delete <tenant> --yes";
     const flags = parseStackFlags(args, { booleans: ["--yes"], aliases: { "-y": "--yes" } }, usage);
     const [name, ...extra] = flags.rest;
     if (name === undefined || extra.length)
         throw usageError(`Usage: ${usage}`);
-    assertStackName(name, "The stack name");
+    assertTenantName(name, "The Tenant name");
     const base = nylorunRoot(deps);
-    const ctx = { deps, project: stackProject(deps.env, name), paths: stackPaths(stackRoot(base, name)) };
+    const ctx = { deps, project: stackProject(deps.env, name), paths: stackPaths(tenantRoot(base, name)) };
     if (!existsSync(ctx.paths.root))
-        throw new CliError(`No stack ${name} under ${stacksDir(base)}. See "nylorun ls".`, 3);
+        throw new CliError(`No Tenant ${name} under ${tenantsDir(base)}. See "nylorun ls".`, 3);
     if (!flags.booleans.has("--yes"))
-        throw usageError(`nylorun delete removes stack ${name}: its containers, volumes and Host root ${ctx.paths.root}, with the Tenant's vault key (KEK) and all its data. This cannot be undone; pass --yes to confirm.`);
+        throw usageError(`nylorun delete removes Tenant ${name}: its containers, volumes and Host root ${ctx.paths.root}, with its vault key (KEK) and all its data. This cannot be undone; pass --yes to confirm.`);
     await dockerPreflight(deps.docker);
     const files = existsSync(ctx.paths.compose) && existsSync(ctx.paths.env);
-    const code = await deps.docker.stream(files
+    await composeDown(ctx, files
         ? composeArgs(ctx, "down", "--volumes", "--remove-orphans")
         : ["compose", "--project-name", ctx.project, "down", "--volumes", "--remove-orphans"]);
-    if (code !== 0)
-        throw new CliError(`docker compose down failed (exit ${code}).`, 1);
     await rm(ctx.paths.root, { recursive: true, force: true });
-    deps.out(`Deleted stack ${name}: its containers, volumes and Host root (vault key included).`);
-    return 0;
-}
-function legacyCompose(legacy, ...args) {
-    return [
-        "compose",
-        "--project-name",
-        legacy.project,
-        "--file",
-        legacy.compose,
-        "--env-file",
-        legacy.env,
-        ...args,
-    ];
-}
-async function legacy(deps, args) {
-    const usage = "nylorun legacy stop|delete [--yes]";
-    const flags = parseStackFlags(args, { booleans: ["--yes"], aliases: { "-y": "--yes" } }, usage);
-    const [action, ...extra] = flags.rest;
-    if ((action !== "stop" && action !== "delete") || extra.length)
-        throw usageError(`Usage: ${usage}`);
-    if (action === "stop" && flags.booleans.has("--yes"))
-        throw usageError(`Usage: ${usage}`);
-    const base = nylorunRoot(deps);
-    const stack = legacyStack(base);
-    if (!stack) {
-        deps.out(`No legacy stack under ${base} (no stack/compose.yaml).`);
-        return 0;
-    }
-    if (action === "stop") {
-        await dockerPreflight(deps.docker);
-        const code = await deps.docker.stream(legacyCompose(stack, "stop"));
-        if (code !== 0)
-            throw new CliError(`docker compose stop failed (exit ${code}).`, 1);
-        deps.out("Stopped the legacy stack (Compose project nylorun); its volumes are kept.");
-        return 0;
-    }
-    if (!flags.booleans.has("--yes"))
-        throw usageError(`nylorun legacy delete removes the legacy stack (Compose project nylorun): its containers, volumes, every Tenant on it with their vault keys, and its files under ${base} (${LEGACY_ENTRIES.join(", ")}). ${stacksDir(base)} is kept. Pass --yes to confirm.`);
-    await dockerPreflight(deps.docker);
-    const code = await deps.docker.stream(legacyCompose(stack, "down", "--volumes", "--remove-orphans"));
-    if (code !== 0)
-        throw new CliError(`docker compose down failed (exit ${code}).`, 1);
-    for (const entry of LEGACY_ENTRIES)
-        await rm(join(base, entry), { recursive: true, force: true });
-    deps.out(`Deleted the legacy stack: its containers, volumes and files under ${base}; ${stacksDir(base)} is kept.`);
+    await refreshProxyRoutes(deps.docker, base, await proxyRoutes(deps));
+    deps.out(`Deleted Tenant ${name}: its containers, volumes and Host root (vault key included).`);
     return 0;
 }
-/** The stack when the Runtime (and Studio, if wanted) already answer; otherwise undefined. */
+/** The Tenant when the Runtime (and Studio, if wanted) already answer; otherwise undefined. */
 async function runningStack(ctx, options) {
     if (!existsSync(ctx.paths.compose) || !existsSync(ctx.paths.env))
         return undefined;
@@ -841,6 +955,7 @@ async function runningStack(ctx, options) {
         hostId: host.hostId,
         adminKey,
         studioPort: persisted.studioPort,
+        studioUrl: await studioUrl(ctx, persisted.studioPort),
         studioUp,
         started: false,
     };
@@ -860,12 +975,13 @@ async function ensureSelected(ctx, options) {
         hostId: started.hostId,
         adminKey: started.adminKey,
         studioPort: started.studioPort,
+        studioUrl: started.studioUrl,
         studioUp: started.studioStarted,
         started: !runtimeWasUp,
     };
 }
 /**
- * Start the selected stack unless it is already running (`nylorun studio`): the
+ * Start the selected Tenant unless it is already running (`nylorun studio`): the
  * `start` code path without its output, its Tenant wait or the Project link. Compose
  * progress still streams, since the first run pulls images.
  */
@@ -880,52 +996,54 @@ export function withNext(loginUrl, next) {
     url.searchParams.set("next", next);
     return url.toString();
 }
-/** The Studio page of the stack's Tenant, as a login `next` path. */
+/** The Tenant's Studio page, as a login `next` path. */
 export function tenantStudioPath(tenantId) {
     return `/tenants/${encodeURIComponent(tenantId)}`;
 }
 /**
- * Mint a fresh Studio login URL on a running stack, landing on `next`.
+ * Mint a fresh Studio login URL on a running Tenant, landing on `next`.
  * Undefined (after a warning) when Studio does not answer.
  */
-export async function studioLoginUrl(deps, stack, next) {
-    const login = await tryStudioLogin({ deps }, stack.studioPort, stack.adminKey);
+export async function studioLoginUrl(deps, running, next) {
+    const login = await tryStudioLogin({ deps }, { port: running.studioPort, url: running.studioUrl }, running.adminKey);
     return login === undefined ? undefined : withNext(login, next);
 }
 async function studio(deps, args, options = {}) {
-    const usage = "nylorun studio [--name <stack>] [--no-open]";
-    const flags = parseStackFlags(args, { booleans: ["--no-open"], values: ["--name"] }, usage);
+    const usage = "nylorun studio [--tenant <name>] [--no-open]";
+    const flags = parseStackFlags(args, { booleans: ["--no-open"], values: ["--tenant"] }, usage);
     if (flags.rest.length)
         throw usageError(`Usage: ${usage}`);
     const ctx = await selectStack(deps, nameOption(flags));
-    const stack = await ensureSelected(ctx, { studio: true });
-    if (stack.started)
-        deps.out(`Runtime   ${stack.runtimeUrl}`);
-    if (!stack.studioUp)
+    const running = await ensureSelected(ctx, { studio: true });
+    if (running.started)
+        deps.out(`Runtime   ${running.runtimeUrl}`);
+    if (!running.studioUp)
         throw new CliError(`Studio did not start. See "nylorun logs studio".`, 7);
-    // Studio serves the stack's one Tenant; the link's Tenant id stands in while it is opening.
+    // Studio serves the one Tenant; the link's Tenant id stands in while it is opening.
     let next = options.next;
     if (next === undefined) {
-        const tenant = await fetchTenant(deps, stack.adminUrl, stack.adminKey);
-        const linked = ctx.link?.format === 2 && ctx.link.stack === ctx.name ? ctx.link.tenantId : undefined;
+        const tenant = await fetchTenant(deps, running.adminUrl, running.adminKey);
+        const linked = ctx.link?.tenant === ctx.name ? ctx.link.tenantId : undefined;
         const tenantId = tenant?.id ?? linked;
         if (tenantId)
             next = tenantStudioPath(tenantId);
     }
-    const login = await studioLoginUrl(deps, stack, next);
+    const login = await studioLoginUrl(deps, running, next);
     if (!login)
         return 1;
     if (flags.booleans.has("--no-open")) {
         deps.out(`Studio    ${login}`);
         return 0;
     }
-    const origin = studioOrigin(stack.studioPort);
+    // The login's origin: the proxy's, or Studio's own port when the proxy did not answer.
+    const origin = new URL(login).origin;
     deps.out(`Studio    ${next ? new URL(next, origin).toString() : origin}`);
     await openLogin({ deps }, login);
     return 0;
 }
-/** `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 runStudioCommand(args, deps, options = {}) {
+    await moveStackRoots(nylorunRoot(deps), deps.err);
     return await studio(deps, args, options);
 }
 const COMMANDS = {
@@ -940,15 +1058,15 @@ const COMMANDS = {
     studio: (deps, args) => studio(deps, args),
     ls,
     delete: deleteStack,
-    legacy,
 };
 export function isStackCommand(name) {
     return name !== undefined && Object.hasOwn(COMMANDS, name);
 }
-/** Run one stack command (`up`/`start`, `down`/`stop`, `status`, `logs`, `reset`, `studio`, `ls`, `delete`, `legacy`). */
+/** Run one Tenant command (`up`/`start`, `down`/`stop`, `status`, `logs`, `reset`, `studio`, `ls`, `delete`). */
 export async function runStackCommand(name, args, deps) {
     const command = COMMANDS[name];
     if (!command)
-        throw usageError(`Unknown stack command ${name}.\n${stackUsage}`);
+        throw usageError(`Unknown command ${name}.\n${stackUsage}`);
+    await moveStackRoots(nylorunRoot(deps), deps.err);
     return await command(deps, args);
 }