@nylorun/runtime 0.17.0-beta → 0.19.0-beta

package/dist/host/config-for.js

@@ -1,12 +1,10 @@
 import { tenantPaths } from "../tenant/paths.js";
-import { tenantChildEnvironment } from "./environment.js";
 /**
  * Builds the TenantConfig of the Host's Tenant for `openTenantRuntime`.
  * The sandbox backend here is the Host default; a Tenant's seeded `sandbox.backend`
  * setting overrides it when the Tenant opens (I1, A18).
  */
 export function configForFactory(options) {
-    const { baseline } = options;
     return (id) => {
         const tenant = tenantPaths(options.hostRoot);
         const sandboxBackend = "auto";
@@ -19,7 +17,6 @@ export function configForFactory(options) {
             ...(options.delivery ? { delivery: options.delivery } : {}),
             ...(options.issuers ? { issuers: options.issuers } : {}),
             ...(options.publicUrl ? { publicUrl: options.publicUrl } : {}),
-            childEnv: tenantChildEnvironment(baseline, options.hostConfig, tenant),
             logger: {
                 info: (message, fields) => options.logger.info(message, { tenantId: id, ...fields }),
                 warn: (message, fields) => options.logger.warn(message, { tenantId: id, ...fields }),

package/dist/host/config.d.ts

@@ -4,11 +4,6 @@ export interface HostConfigFile {
     host: string;
     port: number;
     allowNonLoopback?: boolean;
-    /**
-     * The operator listener's port: the Admin API moves there (on `host`, loopback only), and
-     * `port` serves the Tenant API alone. Absent: one port serves both.
-     */
-    adminPort?: number;
     proxy?: {
         httpsProxy?: string;
         noProxy?: string;

package/dist/host/create-host.d.ts

@@ -1,15 +1,14 @@
 import type { Logger, TenantModule } from "../tenant/types.js";
-import type { HostConfigFile, HostCredentialsFile } from "./config.js";
+import type { HostConfigFile } from "./config.js";
 import type { ContainerListen } from "./stack-config.js";
 export interface CreateHostOptions {
     hostRoot: string;
     module: TenantModule;
     config: HostConfigFile;
-    credentials: HostCredentialsFile;
     logger: Logger;
     /** Diagnostic package version of `@nylorun/core` for `/health`. */
     coreVersion: string;
-    /** Process id reported by `/health` and admin host status. Defaults to `process.pid`. */
+    /** Process id reported by `/health`. Defaults to `process.pid`. */
     pid?: number;
     /**
      * Container mode: bind this address and port instead of host.json's, and
@@ -17,19 +16,6 @@ export interface CreateHostOptions {
      * loopback-only rule). host.json then describes the client-facing address.
      */
     listen?: ContainerListen;
-    /**
-     * The client-facing URL `/v1/admin/status` reports as `host.url`
-     * (`NYLORUN_PUBLIC_URL`). Defaults to the bound address, which in container
-     * mode is `http://0.0.0.0:4000`.
-     */
-    publicUrl?: string;
-    /**
-     * The operator listener: the Admin API (and the Tenant API, never to browsers) on
-     * its own address, kept off the network that reaches the Tenant API. When set, the main
-     * listener is public and answers admin routes with the opaque 404. Absent: one listener
-     * serves everything, as before.
-     */
-    operator?: OperatorListen;
     /**
      * Infrastructure readiness (`infra/readiness.ts`). `/ready` adds its checks
      * and answers 503 while it reports not ok. Default: the listener and the
@@ -41,7 +27,7 @@ export interface CreateHostOptions {
     }>;
     /**
      * Shutdown steps around closing the Tenant. `close()` runs them whatever asked for it
-     * (SIGTERM in `host/main.ts`, `POST /v1/admin/host/shutdown`): the listener stops, then
+     * (SIGTERM in `host/main.ts`): the listener stops, then
      * `beforeTenants` (stop the Worker so no advance starts on the closing Tenant), the Tenant
      * closes, then `afterTenants` (end the infrastructure clients). A failing step is logged
      * and shutdown goes on.
@@ -51,27 +37,11 @@ export interface CreateHostOptions {
         afterTenants?(): Promise<void>;
     };
 }
-/** Where the operator listener binds, and the `Host` values it accepts. */
-export interface OperatorListen {
-    host: string;
-    port: number;
-    /** Exact `Host` values (lowercase `name:port`); absent means the loopback forms of the port. */
-    allowedHosts?: readonly string[];
-}
-/**
- * What a listener serves. `combined`: everything (one port). `public`: the Tenant API, to
- * servers and to browsers with a trusted issuer's token; admin routes are the opaque 404. `operator`: the Admin API and
- * the Tenant API, never to browsers.
- */
-export type ListenerRole = "combined" | "public" | "operator";
 export interface HostServer {
     listen(): Promise<void>;
     close(): Promise<void>;
     /** Settles once `close()` has finished, whatever called it. */
     readonly closed: Promise<void>;
     readonly url: string;
-    /** Where the Admin API answers: the operator listener, or `url` when there is one listener. */
-    readonly adminUrl: string;
 }
-export { adminKeyMatches } from "./http.js";
 export declare function createHost(options: CreateHostOptions): HostServer;

package/dist/host/create-host.js

@@ -1,15 +1,9 @@
 import { createServer, } from "node:http";
 import { getRequestListener, RequestError } from "@hono/node-server";
-import { HOST_PROTOCOL } from "@nylorun/core/compatibility";
-import { AdminStatusSchema } from "@nylorun/core/contracts";
-import { adminDocument } from "../api/openapi.js";
-import { createAdminApi } from "./admin-api.js";
 import { createHostApp } from "./app.js";
 import { bindListener as bind, EXIT_NON_LOOPBACK, headerValue, HostListenError, isAllowedRequestHost, isLoopbackHost, pathnameIsLogged, redactRoutePath, rejectedResponse, sendRejected, } from "./http.js";
-import { RUNTIME_VERSION } from "../version.js";
-export { adminKeyMatches } from "./http.js";
 export function createHost(options) {
-    const { hostRoot, module, config, credentials, logger, coreVersion, } = options;
+    const { module, config, logger, coreVersion } = options;
     const pid = options.pid ?? process.pid;
     const containerListen = options.listen;
     const bindHost = containerListen?.host ?? config.host;
@@ -17,55 +11,20 @@ export function createHost(options) {
     let server;
     let url = "";
     let listenPort = bindPort;
-    const operator = options.operator;
-    let operatorServer;
-    let operatorPort = operator?.port ?? 0;
-    let adminUrl = "";
-    const mainRole = operator ? "public" : "combined";
     let closing = false;
     let closePromise;
-    const adminStatusBody = async () => {
-        const aggregate = await module.summarize();
-        return AdminStatusSchema.parse({
-            service: "nylorun-runtime",
-            version: RUNTIME_VERSION,
-            protocol: {
-                min: HOST_PROTOCOL.min,
-                max: HOST_PROTOCOL.max,
-                features: [...HOST_PROTOCOL.features],
-            },
-            tenant: module.tenant(),
-            aggregate,
-            host: {
-                hostId: config.hostId,
-                url: options.publicUrl ?? url,
-                pid,
-            },
-        });
-    };
-    const adminApi = createAdminApi({
-        status: adminStatusBody,
-        shutdown: () => void close(),
-        document: adminDocument,
-        operatorKeys: async () => {
-            const resolved = await module.resolve();
-            return resolved.kind === "open" ? resolved.handle.operatorKeys?.() : undefined;
-        },
-    });
     const app = createHostApp({
         module,
         logger,
         hostId: config.hostId,
-        adminKey: credentials.adminKey,
         coreVersion,
         pid,
         ...(options.readiness ? { readiness: options.readiness } : {}),
-        listening: () => Boolean(server?.listening) && (!operator || Boolean(operatorServer?.listening)),
+        listening: () => Boolean(server?.listening),
         closing: () => closing,
-        admin: async (request, node) => await adminApi.fetch(request, node),
     });
-    /** Where a listener's requests go once their `Host` header checks out. */
-    const pipeline = (role) => getRequestListener(async (request, node) => alreadySent(await app.fetch(request, { ...node, role })), {
+    /** Where requests go once their `Host` header checks out. */
+    const pipeline = () => getRequestListener(async (request, node) => alreadySent(await app.fetch(request, node)), {
         // The Runtime runs inside other processes (`startEphemeralRuntime`): leave their
         // `Request` and `Response` alone.
         overrideGlobalObjects: false,
@@ -79,30 +38,23 @@ export function createHost(options) {
             return rejectedResponse(500, "internal_error", "Internal error");
         },
     });
-    /** The `Host` values a listener accepts. */
-    const hostAllowed = (role, hostHeader) => role === "operator"
-        ? isAllowedRequestHost(hostHeader, {
-            port: operatorPort,
-            host: operator.host,
-            allowNonLoopback: false,
-            ...(operator.allowedHosts ? { allowedHosts: operator.allowedHosts } : {}),
-        })
-        : isAllowedRequestHost(hostHeader, {
-            port: listenPort,
-            host: config.host,
-            allowNonLoopback: config.allowNonLoopback,
-            ...(containerListen ? { allowedHosts: containerListen.allowedHosts } : {}),
-        });
+    /** The `Host` values the listener accepts. */
+    const hostAllowed = (hostHeader) => isAllowedRequestHost(hostHeader, {
+        port: listenPort,
+        host: config.host,
+        allowNonLoopback: config.allowNonLoopback,
+        ...(containerListen ? { allowedHosts: containerListen.allowedHosts } : {}),
+    });
     /** Responses not yet finished; shutdown ends the streams among them. */
     const inFlight = new Set();
-    const serve = (role) => {
-        const next = pipeline(role);
+    const serve = () => {
+        const next = pipeline();
         return (req, res) => {
             const started = Date.now();
             inFlight.add(res);
             res.once("close", () => inFlight.delete(res));
             // D§11: `Host` first, before anything reads the request.
-            if (hostAllowed(role, headerValue(req, "host")))
+            if (hostAllowed(headerValue(req, "host")))
                 return void next(req, res);
             sendRejected(res, 421, "host_rejected", "Host header is not an allowed loopback or configured address");
             if (pathnameIsLogged(req.url))
@@ -126,39 +78,15 @@ export function createHost(options) {
             !isLoopbackHost(config.host)) {
             throw new HostListenError(`Refusing to bind non-loopback host ${config.host} without allowNonLoopback`, EXIT_NON_LOOPBACK);
         }
-        if (operator && !containerListen && !isLoopbackHost(operator.host))
-            throw new HostListenError(`Refusing to bind the operator listener on non-loopback host ${operator.host}`, EXIT_NON_LOOPBACK);
-        server = createServer(serve(mainRole));
+        server = createServer(serve());
         await bindListener(server, bindPort, bindHost);
         const address = server.address();
         listenPort =
             typeof address === "object" && address ? address.port : bindPort;
         url = `http://${bindHost}:${listenPort}`;
-        adminUrl = url;
-        if (operator) {
-            operatorServer = createServer(serve("operator"));
-            await bindListener(operatorServer, operator.port, operator.host).catch(async (error) => {
-                // Leave nothing half-open: the main listener closes too.
-                await new Promise((resolve) => server.close(() => resolve()));
-                server = undefined;
-                throw error;
-            });
-            const operatorAddress = operatorServer.address();
-            operatorPort =
-                typeof operatorAddress === "object" && operatorAddress
-                    ? operatorAddress.port
-                    : operator.port;
-            adminUrl = `http://${operator.host}:${operatorPort}`;
-        }
-        // The Tenant opens once the listener is bound: `/ready` and `/v1/admin/status` answer
-        // while it opens, and say why when it cannot.
+        // The Tenant opens once the listener is bound: `/ready` answers while it opens.
         await module.start();
-        logger.info("host_listening", {
-            hostId: config.hostId,
-            url,
-            ...(operator ? { adminUrl } : {}),
-            pid,
-        });
+        logger.info("host_listening", { hostId: config.hostId, url, pid });
     }
     const step = async (name, run) => {
         try {
@@ -181,7 +109,7 @@ export function createHost(options) {
         closePromise = (async () => {
             closing = true;
             logger.info("host_shutdown", { hostId: config.hostId });
-            const listeners = [server, operatorServer].filter((listening) => listening !== undefined);
+            const listeners = server ? [server] : [];
             const stopped = Promise.all(listeners.map((listening) => new Promise((resolve) => {
                 listening.close(() => resolve());
                 listening.closeIdleConnections();
@@ -214,7 +142,6 @@ export function createHost(options) {
                 await stopped;
             }
             server = undefined;
-            operatorServer = undefined;
             await step("beforeTenants", options.shutdown?.beforeTenants);
             await step("tenants", () => module.close());
             await step("afterTenants", options.shutdown?.afterTenants);
@@ -228,9 +155,6 @@ export function createHost(options) {
         get url() {
             return url;
         },
-        get adminUrl() {
-            return adminUrl;
-        },
     };
 }
 /**

package/dist/host/environment.d.ts

@@ -1,6 +1,5 @@
 import type { HostConfigFile } from "./config.js";
 import type { HostPaths } from "../tenant/paths.js";
-import type { TenantPaths } from "../tenant/types.js";
 /**
  * Allowlisted ambient keys for Host and Tenant child processes.
  * `NODE_OPTIONS` is never copied.
@@ -9,5 +8,3 @@ export declare function baselineEnvironment(env: NodeJS.ProcessEnv | Readonly<Re
 export type HostProcessPathInputs = Pick<HostPaths, "root" | "home" | "tmp">;
 /** Environment for the Runtime Host process itself (CLI spawn / `runtime run`). */
 export declare function hostProcessEnvironment(baseline: Readonly<Record<string, string>>, hostConfig: HostConfigFile, paths: HostProcessPathInputs): Record<string, string>;
-/** Environment for Tenant-owned children (MCP stdio, sandboxes). */
-export declare function tenantChildEnvironment(baseline: Readonly<Record<string, string>>, hostConfig: HostConfigFile, tenantPaths: TenantPaths): Record<string, string>;

package/dist/host/environment.js

@@ -42,12 +42,3 @@ export function hostProcessEnvironment(baseline, hostConfig, paths) {
         NYLORUN_HOME: paths.root,
     };
 }
-/** Environment for Tenant-owned children (MCP stdio, sandboxes). */
-export function tenantChildEnvironment(baseline, hostConfig, tenantPaths) {
-    return {
-        ...baseline,
-        ...proxyEnv(hostConfig),
-        HOME: tenantPaths.home,
-        TMPDIR: tenantPaths.tmp,
-    };
-}

package/dist/host/gates.d.ts

@@ -40,7 +40,10 @@ export interface StartGatesOptions {
     readonly drainMs?: number;
     /** How long keyed outcomes are kept, and how many (tests). */
     readonly inflight?: InflightCallsOptions;
-    /** How the gate may call Action endpoints (`NYLORUN_ENDPOINT_*`). Default: no limits. */
+    /**
+     * How the gate may call MCP servers and HTTP tools (`NYLORUN_ENDPOINT_*`).
+     * Default: no limits.
+     */
     readonly delivery?: OutboundPolicy;
     /** How long an MCP connection may sit unused. Default `GATE_MCP_IDLE_MS`. */
     readonly mcpIdleMs?: number;

package/dist/host/gates.js

@@ -17,6 +17,7 @@ import { createModelCallHandler } from "../gates/handler.js";
 import { createInflightCalls } from "../gates/inflight.js";
 import { createMcpHandler, GATE_MCP_IDLE_MS } from "../gates/mcp-handler.js";
 import { createToolCalls } from "../gates/tool-calls.js";
+import { gateHttpTools } from "../gates/http-tool.js";
 import { existsSync } from "node:fs";
 import { tenantPaths } from "../tenant/paths.js";
 import { staleRun, verifyRunToken } from "../tenant/run-token.js";
@@ -52,10 +53,10 @@ export async function startGates(options) {
         logger,
         idleMs: mcpIdleMs,
         ...(options.openMcp ? { open: options.openMcp } : {}),
+        ...(options.delivery ? { delivery: options.delivery } : {}),
     });
     const toolCalls = createToolCalls({
         vaults,
-        mcp,
         logger,
         ...(options.inflight ? { inflight: options.inflight } : {}),
     });
@@ -98,8 +99,8 @@ export async function startGates(options) {
         },
         ...(options.maxBodyBytes !== undefined ? { maxBodyBytes: options.maxBodyBytes } : {}),
         mcp,
+        http: gateHttpTools(vaults, options.delivery ?? {}, logger),
         toolCalls,
-        delivery: options.delivery ?? {},
         logger,
         ...(options.keys ? { keys: async () => (await vaults.open()).keys() } : {}),
     });

package/dist/host/http.d.ts

@@ -48,11 +48,10 @@ export declare function pathnameIsLogged(rawUrl: string | undefined): boolean;
  * (a credential) after `/v1/artifact-links/`.
  */
 export declare function redactRoutePath(pathname: string): string;
-/** Constant-time comparison of SHA-256 digests of the presented and stored admin keys. */
+/** Constant-time comparison of SHA-256 digests of a presented and a stored secret. */
 export declare function adminKeyMatches(presented: string | undefined, adminKey: string): boolean;
 /** A request header's first value. */
 export declare function headerValue(incoming: IncomingMessage, name: string): string | undefined;
-export declare function readBearer(authorization: string | undefined): string | undefined;
 /** A JSON request body, capped at `limit` bytes (413); `undefined` when there is none. */
 export declare function readJsonBody(request: Request, limit?: number): Promise<unknown>;
 export declare function isLoopbackHost(host: string): boolean;

package/dist/host/http.js

@@ -149,7 +149,7 @@ export function redactRoutePath(pathname) {
         return "/v1/artifact-links/:token";
     return pathname;
 }
-/** Constant-time comparison of SHA-256 digests of the presented and stored admin keys. */
+/** Constant-time comparison of SHA-256 digests of a presented and a stored secret. */
 export function adminKeyMatches(presented, adminKey) {
     if (presented === undefined)
         return false;
@@ -164,12 +164,6 @@ export function headerValue(incoming, name) {
         return raw[0];
     return raw;
 }
-export function readBearer(authorization) {
-    if (!authorization)
-        return undefined;
-    const match = /^Bearer\s+(\S+)/i.exec(authorization.trim());
-    return match?.[1];
-}
 /** A JSON request body, capped at `limit` bytes (413); `undefined` when there is none. */
 export async function readJsonBody(request, limit = 1024 * 1024) {
     if (request.body === null)

package/dist/host/index.d.ts

@@ -1,6 +1,6 @@
 export type { HostConfigFile, HostCredentialsFile, } from "./config.js";
-export { baselineEnvironment, hostProcessEnvironment, tenantChildEnvironment, } from "./environment.js";
-export { createHost, adminKeyMatches, type CreateHostOptions, type HostServer } from "./create-host.js";
+export { baselineEnvironment, hostProcessEnvironment, } from "./environment.js";
+export { createHost, type CreateHostOptions, type HostServer } from "./create-host.js";
 export { createHostLogger } from "./logger.js";
 export { configForFactory } from "./config-for.js";
 export { createHostExecution, type CreateHostExecutionOptions, type HostExecution, } from "./execution.js";

package/dist/host/index.js

@@ -1,5 +1,5 @@
-export { baselineEnvironment, hostProcessEnvironment, tenantChildEnvironment, } from "./environment.js";
-export { createHost, adminKeyMatches } from "./create-host.js";
+export { baselineEnvironment, hostProcessEnvironment, } from "./environment.js";
+export { createHost } from "./create-host.js";
 export { createHostLogger } from "./logger.js";
 export { configForFactory } from "./config-for.js";
 export { createHostExecution, } from "./execution.js";

package/dist/host/main.js

@@ -83,6 +83,20 @@ function loadIssuers(path) {
     }
     return createTrustedIssuers(parseIdentityFile(text, path));
 }
+/** The bootstrap management key: 64 hex characters, surrounding whitespace ignored. */
+function loadManagementKey(path) {
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        throw new Error(`NYLORUN_MANAGEMENT_KEY_FILE names ${path}, which cannot be read: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const key = text.trim();
+    if (!/^[0-9a-f]{64}$/.test(key))
+        throw new Error(`NYLORUN_MANAGEMENT_KEY_FILE (${path}) must hold one key of 64 lowercase hex characters, such as \`openssl rand -hex 32\``);
+    return key;
+}
 function resolveHostRoot() {
     const fromEnv = process.env.NYLORUN_HOME;
     const root = fromEnv && fromEnv.length > 0 ? fromEnv : resolve(homedir(), ".nylorun");
@@ -122,11 +136,6 @@ async function ensureBucket(store, bucket, logger) {
         }
     }
 }
-/** The slot's lag in WAL bytes, when the source can tell. */
-async function lagOf(source) {
-    const lagBytes = await source.lag?.().catch(() => undefined);
-    return lagBytes === undefined ? {} : { lagBytes };
-}
 /**
  * The gateway's services: the Model Gate's listener (gates, keys) and egress-gate's (egress), over
  * the Postgres pool and the Host's tenant directory. Writes nothing to the Host root (the local
@@ -242,14 +251,11 @@ export async function main() {
     const database = infra.database;
     if (!database)
         throw new Error("NYLORUN_DATABASE_URL did not yield a Postgres pool");
-    const baseline = baselineEnvironment(process.env);
     // A Tenant that should answer with the fixture model carries the Tenant
     // setting (`tenant/model-setting.ts`); the Host has no fixture mode.
     const configFor = configForFactory({
         hostRoot,
-        hostConfig: config,
         logger,
-        baseline,
         ...(stack.delivery ? { delivery: stack.delivery } : {}),
         ...(issuers ? { issuers } : {}),
         ...(stack.publicUrl ? { publicUrl: stack.publicUrl } : {}),
@@ -270,7 +276,6 @@ export async function main() {
     // running core runs one, once the Tenant is open (the relay reads its id); the replication
     // slot lets exactly one be active. Without S2, the Tenant relays its own commits.
     let relay;
-    let relayLag;
     if (streams && stack.services.has("core"))
         await assertLogicalReplication(database);
     const startRelay = (tenantId) => {
@@ -287,14 +292,12 @@ export async function main() {
             streams,
             log: (message, fields) => logger.info(message, fields),
         });
-        const status = relay.status;
-        relayLag = async () => ({ ...status(), ...(await lagOf(source)) });
         relay.start();
     };
-    // With the gates service the Tenant's vault-backed model calls, remote MCP calls and Action
-    // deliveries cross it, and this process never reads a model or MCP credential.
-    // Their credentials (F5): each advance's run token for its session's model and MCP calls,
-    // core's credential (NYLORUN_GATES_TOKEN) for deliveries and MCP requests outside a run.
+    // With the gates service the Tenant's vault-backed model calls, remote MCP calls and HTTP
+    // tool calls cross it, and this process never reads a model or MCP credential.
+    // Their credentials (F5): each advance's run token for its session's model and tool calls,
+    // core's credential (NYLORUN_GATES_TOKEN) for MCP requests outside a run.
     const runGrants = stack.modelGate ? createRunGrants() : undefined;
     const modelGate = stack.modelGate && runGrants
         ? httpModelGate({ url: stack.modelGate.url, runTokens: runGrants })
@@ -326,7 +329,12 @@ export async function main() {
             create: {
                 ...(tenantSettings.id ? { tenantId: tenantSettings.id } : {}),
                 name: tenantSettings.name,
-                principals: hostPrincipals({ adminKey: credentials.adminKey }),
+                principals: hostPrincipals({
+                    adminKey: credentials.adminKey,
+                    ...(stack.tenant?.managementKeyFile
+                        ? { bootstrapKey: loadManagementKey(stack.tenant.managementKeyFile) }
+                        : {}),
+                }),
             },
             configFor,
             logger,
@@ -345,31 +353,16 @@ export async function main() {
         }),
         logger,
         onOpen: (handle) => startRelay(handle.envelope.id),
-        relayStatus: async () => {
-            if (!relayLag)
-                throw new Error("no relay");
-            return relayLag();
-        },
     });
     const options = {
         hostRoot,
         module,
         config,
-        credentials,
         logger,
         coreVersion: coreVersion(),
         ...(stack.listen ? { listen: stack.listen } : {}),
-        ...(stack.publicUrl ? { publicUrl: stack.publicUrl } : {}),
-        // The Admin API on its own listener: from the container environment, or from host.json
-        // (loopback, on the same host) when the Host runs outside a container.
-        ...(stack.operator
-            ? { operator: stack.operator }
-            : !stack.listen && typeof config.adminPort === "number"
-                ? { operator: { host: config.host, port: config.adminPort } }
-                : {}),
         ...(infra.readiness ? { readiness: infra.readiness } : {}),
-        // SIGTERM and POST /v1/admin/host/shutdown both close the Host this way:
-        // stop the Worker and the relay, close the Tenant, then end the infrastructure clients.
+        // SIGTERM closes the Host this way: stop the Worker and the relay, close the Tenant, then end the infrastructure clients.
         shutdown: {
             beforeTenants: async () => {
                 await hostExecution.stop();
@@ -392,8 +385,8 @@ export async function main() {
     // listener starts and opens the Tenant (migrating its database, creating it on
     // first start); opening arms its sweep, which recovers wakes lost with
     // Restate's state (§14.8), and starts the stream relay. A Tenant that cannot
-    // be opened leaves the Host listening but not ready, with the cause in
-    // `/v1/admin/status`.
+    // be opened leaves the Host listening but not ready; `nylorun-operate status` names the
+    // cause.
     // The Harness API listener (NYLORUN_HARNESS=remote): only harnesses connect here, with the
     // harness credential, and only while the Tenant is open.
     let harnessListener;

package/dist/host/operate.d.ts

@@ -0,0 +1,29 @@
+import type { TenantCause } from "@nylorun/core/contracts";
+export declare const EXIT_REFUSED = 1;
+export declare const EXIT_TENANT = 2;
+export declare const EXIT_USAGE = 64;
+export interface OperateIo {
+    env: Readonly<Record<string, string | undefined>>;
+    out(line: string): void;
+    err(line: string): void;
+    /** For the Host's `/ready`. Default: the global `fetch`. */
+    fetch?: typeof fetch;
+}
+/** `nylorun-operate status --json`. */
+export interface OperateStatus {
+    version: string;
+    protocol: {
+        min: number;
+        max: number;
+        features: string[];
+    };
+    tenant: {
+        id: string | null;
+        name: string | null;
+        state: "open" | "unavailable";
+        cause?: TenantCause["code"];
+        message?: string;
+    };
+}
+/** Runs one command; resolves to the exit code. */
+export declare function runOperate(argv: readonly string[], io: OperateIo): Promise<number>;