nylorun 0.15.1-beta → 0.17.0-beta

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

@@ -68,6 +68,9 @@
  *
  * With `identity` (when `<Host root>/identity.yaml` exists) the runtime reads its trusted issuers
  * from it, through the Host root mount (NYLORUN_IDENTITY_FILE=/nylorun/identity.yaml).
+ *
+ * The healthchecks and Postgres's WAL cap come from the CLI tuning (`NYLORUN_CLI_TUNING`). The
+ * `tmpfs` masks are empty: 4096 bytes is one page, the least a tmpfs takes (Linux's page size).
  */
 export declare function renderComposeFile(project: string, name: string, options?: {
     sandboxes?: true;

package/dist/stack/compose-file.js

@@ -1,4 +1,15 @@
 import { PINNED_IMAGES } from "./images.js";
+import { cliTuning } from "../tuning.js";
+/** A service's healthcheck lines, from the CLI tuning (`compose.healthchecks`). */
+function healthcheck(service) {
+    const { intervalSeconds, timeoutSeconds, retries } = cliTuning().compose.healthchecks[service];
+    return `      interval: ${intervalSeconds}s\n      timeout: ${timeoutSeconds}s\n      retries: ${retries}\n`;
+}
+/** Postgres's `max_slot_wal_keep_size` (`compose.walKeepSizeMb`), in GB when it is whole GB. */
+function walKeepSize() {
+    const mb = cliTuning().compose.walKeepSizeMb;
+    return mb % 1024 === 0 ? `${mb / 1024}GB` : `${mb}MB`;
+}
 /**
  * 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
@@ -69,6 +80,9 @@ import { PINNED_IMAGES } from "./images.js";
  *
  * With `identity` (when `<Host root>/identity.yaml` exists) the runtime reads its trusted issuers
  * from it, through the Host root mount (NYLORUN_IDENTITY_FILE=/nylorun/identity.yaml).
+ *
+ * The healthchecks and Postgres's WAL cap come from the CLI tuning (`NYLORUN_CLI_TUNING`). The
+ * `tmpfs` masks are empty: 4096 bytes is one page, the least a tmpfs takes (Linux's page size).
  */
 export function renderComposeFile(project, name, options = {}) {
     const sandboxes = options.sandboxes === true;
@@ -86,8 +100,8 @@ services:
     image: ${PINNED_IMAGES.postgres}
     container_name: ${project}-postgres
     labels: *tenant
-    # Logical replication feeds the stream relay; a stuck slot is capped at 4 GB of WAL.
-    command: ["postgres", "-c", "wal_level=logical", "-c", "max_slot_wal_keep_size=4GB"]
+    # Logical replication feeds the stream relay; a stuck slot's WAL is capped (compose.walKeepSizeMb).
+    command: ["postgres", "-c", "wal_level=logical", "-c", "max_slot_wal_keep_size=${walKeepSize()}"]
     environment:
       POSTGRES_USER: nylorun
       POSTGRES_PASSWORD: \${NYLORUN_POSTGRES_PASSWORD:?run nylorun start}
@@ -98,10 +112,7 @@ services:
     networks: [store]
     healthcheck:
       test: ["CMD-SHELL", "pg_isready -U nylorun -d nylorun"]
-      interval: 2s
-      timeout: 5s
-      retries: 30
-    restart: unless-stopped
+${healthcheck("postgres")}    restart: unless-stopped
 
   restate: # Durable Session Execution
     image: ${PINNED_IMAGES.restate}
@@ -115,10 +126,7 @@ services:
       - \${NYLORUN_HOST_ROOT:?run nylorun start}/docker/restate-identity.pem:/run/nylorun/restate-identity.pem:ro
 ${restateUi ? RESTATE_UI : RESTATE_CLOSED}    healthcheck:
       test: ["CMD", "curl", "-fsS", "http://localhost:9070/health"]
-      interval: 2s
-      timeout: 5s
-      retries: 30
-    restart: unless-stopped
+${healthcheck("restate")}    restart: unless-stopped
 
   s2-lite: # Durable Streams; not published, only the Runtime reaches it
     image: ${PINNED_IMAGES.s2}
@@ -150,10 +158,7 @@ ${restateUi ? RESTATE_UI : RESTATE_CLOSED}    healthcheck:
     networks: [store]
     healthcheck:
       test: ["CMD", "curl", "-fsS", "http://localhost:9000/health"]
-      interval: 2s
-      timeout: 5s
-      retries: 30
-    restart: unless-stopped
+${healthcheck("rustfs")}    restart: unless-stopped
 
   gateway: # the Model and Tool Gates and keys: the vault key, credentials, signing, outbound calls; not published${sandboxes ? ", but for sandbox pods" : ""}
     image: \${NYLORUN_RUNTIME_IMAGE:?run nylorun start}
@@ -175,7 +180,9 @@ ${restateUi ? RESTATE_UI : RESTATE_CLOSED}    healthcheck:
       NYLORUN_OBJECT_STORE_ACCESS_KEY: nylorun
       NYLORUN_OBJECT_STORE_SECRET_KEY: \${NYLORUN_OBJECT_STORE_SECRET_KEY:?run nylorun start}
       # MCP servers and HTTP tools on this machine: \`localhost\` in their URLs means the Docker host.
-      NYLORUN_ENDPOINT_LOOPBACK: docker-host${sandboxes ? SANDBOXES_GATEWAY_ENV : ""}
+      NYLORUN_ENDPOINT_LOOPBACK: docker-host
+      # Host tuning (timings, retries, internal sizes; JSON): from the shell that runs \`nylorun start\`.
+      NYLORUN_TUNING: \${NYLORUN_TUNING:-}${sandboxes ? SANDBOXES_GATEWAY_ENV : ""}
     extra_hosts:
       host.docker.internal: host-gateway # model servers, MCP servers and HTTP tools on this machine
     volumes:
@@ -186,10 +193,7 @@ ${sandboxes ? SANDBOXES_GATES_PORT : ""}    # Egress and the stores; the harness
     networks: [default, store, harness]
     healthcheck:
       test: ["CMD", "node", "-e", "fetch('http://localhost:4100/ready').then(r=>process.exit(r.ok?0:1),()=>process.exit(1))"]
-      interval: 2s
-      timeout: 5s
-      retries: 60
-    restart: unless-stopped
+${healthcheck("gateway")}    restart: unless-stopped
 
   runtime:
     image: \${NYLORUN_RUNTIME_IMAGE:?run nylorun start}
@@ -247,7 +251,10 @@ ${sandboxes ? SANDBOXES_GATES_PORT : ""}    # Egress and the stores; the harness
       OTEL_SERVICE_NAME: \${OTEL_SERVICE_NAME:-}
       OTEL_RESOURCE_ATTRIBUTES: \${OTEL_RESOURCE_ATTRIBUTES:-}
       OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT: \${OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT:-}
-      NYLORUN_TRACE_CONTENT: \${NYLORUN_TRACE_CONTENT:-}${sandboxes ? SANDBOXES_RUNTIME_ENV : ""}${identity ? IDENTITY_RUNTIME_ENV : ""}
+      NYLORUN_TRACE_CONTENT: \${NYLORUN_TRACE_CONTENT:-}
+      # Host tuning (timings, retries, internal sizes; JSON): from the shell that runs \`nylorun start\`.
+      # Sandbox pods get its harness and engine groups from the runtime.
+      NYLORUN_TUNING: \${NYLORUN_TUNING:-}${sandboxes ? SANDBOXES_RUNTIME_ENV : ""}${identity ? IDENTITY_RUNTIME_ENV : ""}
     extra_hosts:
       host.docker.internal: host-gateway # the Docker host, also on Linux Docker Engine
     volumes:
@@ -268,10 +275,7 @@ ${sandboxes ? SANDBOXES_GATES_PORT : ""}    # Egress and the stores; the harness
       - "127.0.0.1:\${NYLORUN_PORT:?run nylorun start}:4000" # Runtime and Management APIs, SSE, browsers${sandboxes ? SANDBOXES_RUNTIME_PORT : ""}
     healthcheck: # liveness: a Tenant that cannot open is reported by nylorun start (/ready, nylorun-operate status), not by a 300 s wait
       test: ["CMD", "node", "-e", "fetch('http://localhost:4000/health').then(r=>process.exit(r.ok?0:1),()=>process.exit(1))"]
-      interval: 2s
-      timeout: 5s
-      retries: 60
-    restart: unless-stopped
+${healthcheck("runtime")}    restart: unless-stopped
 
   studio: # dashboard + trusted proxy
     image: \${NYLORUN_STUDIO_IMAGE:?run nylorun start}
@@ -303,10 +307,7 @@ ${sandboxes ? SANDBOXES_GATES_PORT : ""}    # Egress and the stores; the harness
       - "127.0.0.1:\${NYLORUN_STUDIO_PORT:?run nylorun start}:3000" # opened as http://localhost:<port>
     healthcheck: # /healthz needs no session; Host studio:3000 is accepted
       test: ["CMD", "node", "-e", "require('http').get({port:3000,path:'/healthz',headers:{host:'studio:3000'}},r=>process.exit(r.statusCode===200?0:1)).on('error',()=>process.exit(1))"]
-      interval: 2s
-      timeout: 5s
-      retries: 30
-    restart: unless-stopped
+${healthcheck("studio")}    restart: unless-stopped
 ${remote ? harnessService(project) : ""}${sandboxes ? sandboxesService(project) : ""}
 networks:
   default:
@@ -357,16 +358,14 @@ function harnessService(project) {
       NYLORUN_HARNESS_TOKEN: \${NYLORUN_HARNESS_TOKEN:?run nylorun start}
       NYLORUN_GATES_URL: http://gateway:4100
       NYLORUN_HARNESS_ROOT: /harness
+      NYLORUN_TUNING: \${NYLORUN_TUNING:-} # Host tuning, as the runtime has it
     volumes:
       # The Tenant's workspaces; nothing else.
       - \${NYLORUN_HOST_ROOT:?run nylorun start}/tenant/sandboxes:/harness/sandboxes
     networks: [harness]
     healthcheck: # healthy once connected to core's Harness API
       test: ["CMD", "node", "-e", "fetch('http://127.0.0.1:4300/health').then(r=>r.json()).then(b=>process.exit(b.connected?0:1),()=>process.exit(1))"]
-      interval: 2s
-      timeout: 5s
-      retries: 90
-    restart: unless-stopped
+${healthcheck("harness")}    restart: unless-stopped
 `;
 }
 /**
@@ -428,9 +427,6 @@ function sandboxesService(project) {
     networks: [default] # the cluster's API server, through host.docker.internal
     healthcheck: # /ready: informers synced and the API server answers
       test: ["CMD", "/sandboxes", "healthcheck"]
-      interval: 5s
-      timeout: 5s
-      retries: 24
-    restart: unless-stopped
+${healthcheck("sandboxes")}    restart: unless-stopped
 `;
 }

package/dist/stack/operator-keys.js

@@ -8,6 +8,7 @@ import { open, rm, stat } from "node:fs/promises";
 import { PROTOCOL_HEADER, PROTOCOL_VERSION } from "@nylorun/core/compatibility";
 import { CliError } from "../errors.js";
 import { readCredentialsFile, writeCredentialsFile, } from "../project/link.js";
+import { cliTuning } from "../tuning.js";
 /** The keys `nylorun start` gives the projects it links (and `-management`). */
 export const PROJECT_KEY_ID = "project";
 /** The keys nylorun commands use outside a linked project (and `-management`). */
@@ -56,7 +57,7 @@ export async function keyAuthenticates(fetch, runtimeUrl, key) {
                 accept: "application/json",
             },
             redirect: "error",
-            signal: AbortSignal.timeout(10_000),
+            signal: AbortSignal.timeout(cliTuning().stack.keyCheckMs),
         });
     }
     catch (error) {
@@ -69,12 +70,12 @@ export async function keyAuthenticates(fetch, runtimeUrl, key) {
         return false;
     throw new CliError(`GET ${runtimeUrl}/v1/me returned ${response.status}.`, 7);
 }
-const LOCK_TIMEOUT_MS = 30_000;
+const lockTimeoutMs = () => cliTuning().stack.lockWaitMs;
 /** A lock older than this was left by a process that died. */
-const LOCK_STALE_MS = 60_000;
+const lockStaleMs = () => cliTuning().stack.lockStaleMs;
 /** Runs `fn` holding the lock file `path` (created exclusively), so one process puts a key. */
 async function withLock(path, fn) {
-    const deadline = Date.now() + LOCK_TIMEOUT_MS;
+    const deadline = Date.now() + lockTimeoutMs();
     for (;;) {
         try {
             const handle = await open(path, "wx", 0o600);
@@ -85,13 +86,13 @@ async function withLock(path, fn) {
             if (error.code !== "EEXIST")
                 throw error;
             const held = await stat(path).catch(() => undefined);
-            if (held && Date.now() - held.mtimeMs > LOCK_STALE_MS) {
+            if (held && Date.now() - held.mtimeMs > lockStaleMs()) {
                 await rm(path, { force: true });
                 continue;
             }
             if (Date.now() > deadline)
                 throw new CliError(`Another nylorun command holds ${path}. Remove it if none runs.`, 1);
-            await new Promise((resolve) => setTimeout(resolve, 100));
+            await new Promise((resolve) => setTimeout(resolve, cliTuning().stack.lockPollMs));
         }
     }
     try {

package/dist/stack/ports.js

@@ -1,4 +1,5 @@
 import { createServer } from "node:net";
+import { cliTuning } from "../tuning.js";
 export const DEFAULT_PORTS = {
     runtime: 8787,
     studio: 4161,
@@ -36,7 +37,7 @@ export async function choosePort(probe, preferred, persisted, taken) {
         return persisted;
     if (!taken.has(preferred) && (await probe.isFree(preferred)))
         return preferred;
-    for (let attempt = 0; attempt < 20; attempt += 1) {
+    for (let attempt = 0; attempt < cliTuning().stack.portAttempts; attempt += 1) {
         const port = await probe.pickFree();
         if (!taken.has(port))
             return port;

package/dist/stack/studio-login.js

@@ -1,4 +1,5 @@
 import { STACK_CLIENT_HOST } from "./host-files.js";
+import { cliTuning } from "../tuning.js";
 /** Studio's published origin: always `localhost` (the cookie's host). */
 export function studioOrigin(port) {
     return `http://${STACK_CLIENT_HOST}:${port}`;
@@ -20,7 +21,7 @@ export async function mintStudioLogin(input) {
         },
         body: "{}",
         redirect: "error",
-        signal: AbortSignal.timeout(input.timeoutMs ?? 5000),
+        signal: AbortSignal.timeout(input.timeoutMs ?? cliTuning().stack.loginRequestMs),
     });
     if (!response.ok)
         throw new Error(`Studio refused a login token (HTTP ${response.status}).`);

package/dist/tuning.d.ts

@@ -0,0 +1,90 @@
+/** A Compose healthcheck: seconds between checks, seconds one check may take, and failures in a row. */
+export interface Healthcheck {
+    readonly intervalSeconds: number;
+    readonly timeoutSeconds: number;
+    readonly retries: number;
+}
+export declare const DEFAULT_CLI_TUNING: {
+    /** `nylorun start` and the commands that reach the local stack. */
+    stack: {
+        /** One `/health` or `/ready` probe of the Runtime. */
+        probeTimeoutMs: number;
+        /** How long `start` waits for the Runtime's `/health`, and then for the Tenant to open. */
+        healthWaitMs: number;
+        tenantWaitMs: number;
+        /** How often `start` polls while it waits. */
+        pollMs: number;
+        /** While the Tenant opens, `nylorun-operate status` is asked every this many polls. */
+        operateEveryPolls: number;
+        /** `docker compose up --wait-timeout` of the core services, and of Studio, in seconds. */
+        composeWaitSeconds: number;
+        studioWaitSeconds: number;
+        /** How long a Studio login is retried, and how long one request for it may take. */
+        loginWaitMs: number;
+        loginRequestMs: number;
+        /** How long a key check against the Runtime (`/v1/me`) may take. */
+        keyCheckMs: number;
+        /** The local key file's lock: how long to wait for it, when a held one is stale, how often to look. */
+        lockWaitMs: number;
+        lockStaleMs: number;
+        lockPollMs: number;
+        /** Tries at picking a free port. */
+        portAttempts: number;
+        /** How long one seed or model call to the Management API may take (`nylorun dev`). */
+        seedRequestMs: number;
+    };
+    /** What `nylorun start` writes into the Compose file. */
+    compose: {
+        /** Postgres's `max_slot_wal_keep_size`: the WAL a stuck replication slot may hold, in MiB. */
+        walKeepSizeMb: number;
+        healthchecks: {
+            postgres: Healthcheck;
+            restate: Healthcheck;
+            rustfs: Healthcheck;
+            gateway: Healthcheck;
+            runtime: Healthcheck;
+            studio: Healthcheck;
+            harness: Healthcheck;
+            sandboxes: Healthcheck;
+        };
+    };
+    /** `nylorun local sandbox` (agent-sandbox on a local Kubernetes cluster). */
+    sandbox: {
+        /** How long a `kubectl` call may run before it is killed, and how much longer than a wait it was told. */
+        kubectlTimeoutMs: number;
+        kubectlMarginMs: number;
+        /** Downloading the agent-sandbox manifest. */
+        manifestDownloadMs: number;
+        /** `kubectl wait` for the CRD, and `rollout status` of the controller, in seconds. */
+        crdWaitSeconds: number;
+        rolloutWaitSeconds: number;
+        /** How long to wait for the service account's token Secret. */
+        tokenWaitMs: number;
+        /** How often install and the network probe poll. */
+        pollMs: number;
+        /** `docker compose up --wait-timeout` of the sandboxes service, in seconds. */
+        composeWaitSeconds: number;
+        /** How long the sandboxes service's `/v1/info`, read from the runtime container, may take. */
+        infoRequestMs: number;
+        /** The reachability probe: `wget -T` in seconds, and the `kubectl exec` around it. */
+        probeWgetSeconds: number;
+        probeExecMs: number;
+        /** How long probe pods may take to be Ready, in seconds, and the NetworkPolicy to apply. */
+        probeReadySeconds: number;
+        policyTimeoutMs: number;
+        /** How long image pre-pulls may take, and how often they are checked. */
+        prepullMs: number;
+        prepullPollMs: number;
+        /** A probe pod's `terminationGracePeriodSeconds`, and its resources (Kubernetes quantities). */
+        probeGraceSeconds: number;
+        probeCpu: string;
+        probeMemory: string;
+    };
+};
+type Widen<T> = T extends number ? number : T extends string ? string : {
+    readonly [K in keyof T]: Widen<T[K]>;
+};
+export type CliTuning = Widen<typeof DEFAULT_CLI_TUNING>;
+/** The CLI's tuning: `NYLORUN_CLI_TUNING` over the defaults, read now. */
+export declare function cliTuning(env?: Readonly<Record<string, string | undefined>>): CliTuning;
+export {};

package/dist/tuning.js

@@ -0,0 +1,143 @@
+/**
+ * The CLI's own timings and sizes (B15): how long `nylorun` waits for the local stack, how often
+ * it polls, the healthchecks it writes into the Compose file, and the waits of `nylorun local
+ * sandbox`. Each has a default, the value the CLI used before it was configuration. Set any part
+ * in `NYLORUN_CLI_TUNING`, a JSON object of the groups below
+ * (`{"stack":{"healthWaitMs":120000}}`), read each time a value is used; an unknown key or a value
+ * that is not a positive whole number stops the command naming it.
+ *
+ * The Runtime's own timings are its Host tuning (`NYLORUN_TUNING`), which `nylorun start` passes
+ * to its containers; Tenant-facing limits are the Runtime limits (`nylorun tenant settings
+ * limits`). Neither is here.
+ */
+import { CliError } from "./errors.js";
+const check = (retries, intervalSeconds = 2, timeoutSeconds = 5) => ({
+    intervalSeconds,
+    timeoutSeconds,
+    retries,
+});
+export const DEFAULT_CLI_TUNING = deepFreeze({
+    /** `nylorun start` and the commands that reach the local stack. */
+    stack: {
+        /** One `/health` or `/ready` probe of the Runtime. */
+        probeTimeoutMs: 3_000,
+        /** How long `start` waits for the Runtime's `/health`, and then for the Tenant to open. */
+        healthWaitMs: 60_000,
+        tenantWaitMs: 60_000,
+        /** How often `start` polls while it waits. */
+        pollMs: 500,
+        /** While the Tenant opens, `nylorun-operate status` is asked every this many polls. */
+        operateEveryPolls: 10,
+        /** `docker compose up --wait-timeout` of the core services, and of Studio, in seconds. */
+        composeWaitSeconds: 300,
+        studioWaitSeconds: 120,
+        /** How long a Studio login is retried, and how long one request for it may take. */
+        loginWaitMs: 15_000,
+        loginRequestMs: 5_000,
+        /** How long a key check against the Runtime (`/v1/me`) may take. */
+        keyCheckMs: 10_000,
+        /** The local key file's lock: how long to wait for it, when a held one is stale, how often to look. */
+        lockWaitMs: 30_000,
+        lockStaleMs: 60_000,
+        lockPollMs: 100,
+        /** Tries at picking a free port. */
+        portAttempts: 20,
+        /** How long one seed or model call to the Management API may take (`nylorun dev`). */
+        seedRequestMs: 15_000,
+    },
+    /** What `nylorun start` writes into the Compose file. */
+    compose: {
+        /** Postgres's `max_slot_wal_keep_size`: the WAL a stuck replication slot may hold, in MiB. */
+        walKeepSizeMb: 4_096,
+        healthchecks: {
+            postgres: check(30),
+            restate: check(30),
+            rustfs: check(30),
+            gateway: check(60),
+            runtime: check(60),
+            studio: check(30),
+            harness: check(90),
+            sandboxes: check(24, 5, 5),
+        },
+    },
+    /** `nylorun local sandbox` (agent-sandbox on a local Kubernetes cluster). */
+    sandbox: {
+        /** How long a `kubectl` call may run before it is killed, and how much longer than a wait it was told. */
+        kubectlTimeoutMs: 300_000,
+        kubectlMarginMs: 20_000,
+        /** Downloading the agent-sandbox manifest. */
+        manifestDownloadMs: 60_000,
+        /** `kubectl wait` for the CRD, and `rollout status` of the controller, in seconds. */
+        crdWaitSeconds: 60,
+        rolloutWaitSeconds: 180,
+        /** How long to wait for the service account's token Secret. */
+        tokenWaitMs: 60_000,
+        /** How often install and the network probe poll. */
+        pollMs: 1_000,
+        /** `docker compose up --wait-timeout` of the sandboxes service, in seconds. */
+        composeWaitSeconds: 120,
+        /** How long the sandboxes service's `/v1/info`, read from the runtime container, may take. */
+        infoRequestMs: 5_000,
+        /** The reachability probe: `wget -T` in seconds, and the `kubectl exec` around it. */
+        probeWgetSeconds: 3,
+        probeExecMs: 20_000,
+        /** How long probe pods may take to be Ready, in seconds, and the NetworkPolicy to apply. */
+        probeReadySeconds: 180,
+        policyTimeoutMs: 30_000,
+        /** How long image pre-pulls may take, and how often they are checked. */
+        prepullMs: 300_000,
+        prepullPollMs: 2_000,
+        /** A probe pod's `terminationGracePeriodSeconds`, and its resources (Kubernetes quantities). */
+        probeGraceSeconds: 1,
+        probeCpu: "200m",
+        probeMemory: "64Mi",
+    },
+});
+function deepFreeze(value) {
+    if (value && typeof value === "object") {
+        for (const item of Object.values(value))
+            deepFreeze(item);
+        Object.freeze(value);
+    }
+    return value;
+}
+function merge(defaults, set, path) {
+    if (set === undefined)
+        return defaults;
+    if (typeof defaults === "number") {
+        // A grace period may be 0; everything else is at least 1.
+        const least = path.endsWith("GraceSeconds") ? 0 : 1;
+        if (typeof set !== "number" || !Number.isSafeInteger(set) || set < least)
+            throw new CliError(`NYLORUN_CLI_TUNING: ${path} must be a whole number of at least ${least}`, 2);
+        return set;
+    }
+    if (typeof defaults === "string") {
+        if (typeof set !== "string" || set.trim() === "")
+            throw new CliError(`NYLORUN_CLI_TUNING: ${path} must be a non-empty string`, 2);
+        return set;
+    }
+    if (!set || typeof set !== "object" || Array.isArray(set))
+        throw new CliError(`NYLORUN_CLI_TUNING: ${path || "(root)"} must be an object`, 2);
+    const out = {};
+    const known = defaults;
+    for (const key of Object.keys(set))
+        if (!(key in known))
+            throw new CliError(`NYLORUN_CLI_TUNING: ${path ? `${path}.` : ""}${key} is not a setting`, 2);
+    for (const [key, value] of Object.entries(known))
+        out[key] = merge(value, set[key], path ? `${path}.${key}` : key);
+    return out;
+}
+/** The CLI's tuning: `NYLORUN_CLI_TUNING` over the defaults, read now. */
+export function cliTuning(env = process.env) {
+    const raw = env.NYLORUN_CLI_TUNING;
+    if (raw === undefined || raw.trim() === "")
+        return DEFAULT_CLI_TUNING;
+    let set;
+    try {
+        set = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new CliError(`NYLORUN_CLI_TUNING must be a JSON object: ${error instanceof Error ? error.message : String(error)}`, 2);
+    }
+    return merge(DEFAULT_CLI_TUNING, set, "");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nylorun",
-  "version": "0.15.1-beta",
+  "version": "0.17.0-beta",
   "type": "module",
   "license": "Apache-2.0",
   "description": "Set up and run local Nylorun Tenants (Runtime and Studio) with Docker Compose, and act on a Tenant through its Runtime and Management APIs",
@@ -30,23 +30,23 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@nylorun/admin": "0.17.1-beta",
-    "@nylorun/agents": "0.22.0-beta",
-    "@nylorun/core": "0.22.0-beta"
+    "@nylorun/admin": "0.19.0-beta",
+    "@nylorun/agents": "0.24.0-beta",
+    "@nylorun/core": "0.24.0-beta"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "0.99.1",
+    "@earendil-works/pi-ai": "1.2.0",
     "@nylorun/agents": "file:../../sdks/agents",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
-    "@types/node": "^26.6.4",
-    "vitest": "^5.0.2"
+    "@types/node": "^26.6.5",
+    "vitest": "^5.0.4"
   },
   "bin": {
     "nylorun": "dist/cli.js",
     "nylo": "dist/nylo.js"
   },
   "nylorun": {
-    "runtime": "0.26.0-beta",
-    "studio": "0.25.1-beta"
+    "runtime": "0.28.0-beta",
+    "studio": "0.27.0-beta"
   }
 }

package/dist/client/environment-manifests.d.ts

@@ -1,10 +0,0 @@
-import { type EnvironmentManifestInput } from "@nylorun/agents";
-import type { StackDeps } from "../stack/commands.js";
-export declare const manifestsUsage = "  manifests list [--json]             each environment manifest's latest version\n  manifests get <name> [--version <n>]\n                                      a manifest's latest version (or version n), as JSON\n  manifests versions <name>           its versions, with the Environments made from each\n  manifests save <manifest.json>... [--if-match <n>] [--dry-run]\n                                      save each manifest's next version (a files entry with\n                                      \"from\": a folder beside the file, uploaded by hash);\n                                      --dry-run prints the plan and saves nothing\n  manifests rm <name>                 delete every version (refused while an Environment\n                                      was made from one)";
-/** The manifest in `path`, its `from` folders hashed: the body to save and the bytes to upload. */
-export declare function manifestFrom(path: string): Promise<{
-    manifest: EnvironmentManifestInput;
-    bytes: Record<string, Uint8Array>;
-}>;
-/** `nylorun environments manifests <command> ...` */
-export declare function manifestsCommand(deps: StackDeps, args: readonly string[], usage: string): Promise<number>;