nylorun 0.15.1-beta → 0.16.0-beta

package/CHANGELOG.md

@@ -1,5 +1,98 @@
 # nylorun
 
+## 0.16.0-beta
+
+### Minor Changes
+
+- 0a2fbc5: **Artifacts reach the harness through the Harness API; `read_artifact` and `save_artifact` run in the harness (protocol 15, Harness API 4).** The first step of the harness boundary: model-facing work belongs to the harness, and the Runtime offers primitives and holds limits and access. A fresh start for agent sessions: the Runtime speaks protocol 15 only. See MIGRATION.md.
+
+  - **The artifact seam.** A harness reads and writes the artifacts of the run it holds: `artifact.read {artifactId, version?, offset?, length?}` answers the version's metadata (`ArtifactMetaSchema`) and its bytes from `offset`, at most `turn.start.limits.chunkBytes`; `artifact.write` (`begin`, `chunk`, `commit`, `abort`) makes a file artifact of the session or a new version of one of its own, streamed with backpressure into the Object store and committed in Postgres within the Tenant's and the Environment's artifact limits. The scope is always the run's session: its own artifacts, and the Tenant-wide ones its messages named; anything else is the new error code `not_found`, alike. A write's `key` makes it idempotent within the session (`artifact_versions.write_key`, migration 0028), and its `effectId` links the artifact to a tool call of the turn, whose call id `artifact.created` carries. An upload the run leaves open commits nothing. Client helpers: `readArtifact`, `openArtifactWrite`, `writeArtifactBytes`, `toBase64` and `fromBase64` in `@nylorun/core/harness-api`.
+  - **Our harness runs the artifact tools.** `read_artifact` (every agent) and `save_artifact` (with a sandbox) are our engine's tools, defined in `@nylorun/harness` (`artifactToolsFor`, `runArtifactTool`) and run over the seam and the run's sandbox files (`HarnessExecutors.files`, `SandboxManager.writeBytes`); their calls are kind `harness`. `save_artifact` keys its write by its effect id. `read_artifact` takes `path` with a sandbox, which copies the whole artifact into it, and hands a file of any other type to the model as a file of the result (the Model Gate writes the note for one the model does not read; `artifact.unsupported` is gone). Its page is harness configuration, `createHarness({ artifactPageBytes })` (32 KiB by default), and now always ends on a whole character. `runDurable` takes `engineTools`; `apiHost` takes the engine's configuration.
+  - **The Runtime pins no artifact tools.** `runtimeManifestFor` has no `save` or `read`; `RUNTIME_TOOL_NAMES` no longer holds the two names, so an author tool may take one (our harness then refuses the turn). A session without a sandbox or skills pins its definition unchanged. Core no longer runs either tool (`tenant/artifact-tool.ts` is gone). Migration 0029 closes every agent session that pinned them (`closedReason: "protocol_15"`, `409 session_closed`); workflow sessions carry over.
+  - **Media types are core's.** `contentTypeFor`, `essence`, `normalizeContentType`, `isText`, `isModelImage`, `modelInputOf`, `inputLabel`, `extensionFor`, `unreadableReason`, `MODEL_IMAGE_TYPES` and `DEFAULT_CONTENT_TYPE` are exported from `@nylorun/core/contracts`, for the Runtime and harnesses alike.
+  - `PROTOCOL_VERSION` 15 with required feature `harness-boundary`; `HARNESS_API_VERSION` 4. The SDKs and the CLI send protocol 15.
+
+- b1e815d: **Runtime limits are a Tenant setting, and harnesses get them in `turn.start.limits`.**
+
+  - What one record entry, model call, model file, tool answer, custom harness state and Harness API chunk may hold is the new Management API setting `GET`/`PUT /v1/tenant/limits` (`{ limits: { recordEntryBytes, modelCallBytes, modelFileBytes, toolAnswerBytes, harnessStateBytes, chunkBytes } }`), also `admin.settings.limits` and `nylorun tenant settings limits [get | put <file|->]`.
+    - The defaults are today's sizes (`RUNTIME_LIMIT_DEFAULTS`): 960 KiB, 32 MiB, 8 MiB, 8 MiB, 256 KiB and 16 MiB. A limit left out of a `PUT` takes its default.
+    - Each limit has a ceiling a dependency sets (`RUNTIME_LIMIT_CEILINGS`): S2's 1 MiB record less 64 KiB for the event's envelope, the 64 MiB Harness API frame, the longest JavaScript string. A limit above its ceiling is `400`, naming the ceiling.
+    - Each is read from the Tenant's database where it is checked; nothing keeps it.
+  - **The record holds every write to `recordEntryBytes`.** An event whose payload, or an effect outcome whose value, is larger, whoever wrote it, is refused with `limit_exceeded`: `413` (`details.limit: "recordEntryBytes"`) to an API client, the new Harness API error code `limit_exceeded` to a harness. A harness's claimed event past it is refused rather than dropped. Before, such an event reached a record S2 could not take.
+  - **The gates read the setting.** The Model Gate refuses a body past `modelCallBytes` and a file past `modelFileBytes`; the Tool Gate keeps no MCP or HTTP answer past `toolAnswerBytes` (`mcp.too-large`, `http.too-large`) and reads no tool body past it. A custom harness's state past `harnessStateBytes` fails its turn with `limit_exceeded` (it was `invalid`), and a `definition.file` range longer than `chunkBytes` is `limit_exceeded`. Core's step budget for tool results is unchanged (256 KiB), or half `recordEntryBytes` when that is less.
+  - **`turn.start` carries `limits`** (`RuntimeLimitsSchema`), the limits in force when the segment started. Harness API 3 and protocol 14 are unchanged, but `TurnStartSchema` is strict: a harness built against an older `@nylorun/core` refuses a `turn.start` with `limits`, so upgrade a custom harness with the Runtime. Our harness asks for skill files `limits.chunkBytes` at a time, and holds MCP answers on its own connections to `limits.toolAnswerBytes`. `createHarness` takes `onStart(grant, start)`.
+  - **Removed exports:** `MAX_MODEL_CALL_BYTES`, `MAX_TOOL_BODY_BYTES`, `MAX_HARNESS_STATE_BYTES` and `DEFINITION_FILE_CHUNK_BYTES` from `@nylorun/core`. Added: `RuntimeLimitsSchema`, `RUNTIME_LIMIT_DEFAULTS`, `RUNTIME_LIMIT_CEILINGS`, `runtimeLimitsOf`, `runtimeLimitIssues`, `limitExceededMessage`, `S2_RECORD_MAX_BYTES`, `RECORD_ENVELOPE_RESERVE_BYTES`, `JS_STRING_MAX_LENGTH` and the `TenantLimits*` schemas.
+
+- f2e9b0a: **Skill and artifact limits are set per Tenant and per Environment manifest; a skill holds up to 2 GiB by default, with no limit per file or on the number of files.**
+
+  - The 10 MiB limit per skill file and the 500-file limit are gone. A skill's files may hold up to the Tenant's skill limit together: 2 GiB by default (`SKILL_TOTAL_BYTES_DEFAULT`). A file at two paths counts twice, since a sandbox holds both copies. `SKILL_FILES_MAX` and `DEFINITION_FILE_MAX_BYTES` are no longer exported.
+  - The Tenant's skill limit is the new Management API setting `GET`/`PUT /v1/tenant/skills` (`{ limits: { totalBytes } }`), also available as `admin.settings.skills` and `nylorun tenant settings skills [get | put <file|->]`.
+    - `PUT /v1/files/sha256:<hex>` takes a file up to that limit.
+    - `PUT /v1/agents/{id}` refuses a skill over it, an agent used as a tool included: `413 limit_exceeded`, with `details.skills` listing each skill and its size.
+  - An environment manifest, or the inline fields of `PUT /v1/environments/{id}`, may set `limits`: `artifacts.fileBytes`, `artifacts.totalBytes` and `skills.totalBytes`. Like the manifest's other fields, they are fixed for the Environment's life.
+    - Each limit must be at most the Tenant's. A higher one is refused with `400` when the Environment is made or the manifest is saved.
+    - A limit left out is the Tenant's at the time it is checked. A Tenant that lowers a limit lowers it for every Environment.
+    - The Environment view's new `limits` field gives the limits in force.
+  - An Environment's artifacts are its sessions' artifacts and its disk versions. Uploads, `save_artifact`, turn-end exports and disk snapshots hold them to the Environment's per-file limit and to its own total, as well as to the Tenant's total. A turn-end export past the Environment's total is skipped with the new reason `environment_total`, and a disk snapshot past it is `413` with `details.limit: "environment_total"`.
+  - A session opens on an Environment only when its agent's skills fit the Environment's skill limit; otherwise it is `409 environment_unsuitable`, with `details.skills`.
+  - `PUT /v1/files` streams the body to the Object store instead of holding it in memory. Only bytes that match the named hash reach the file's key. Environment files named by hash are held to the same per-file maximum.
+  - `@nylorun/agents`: loading a skills folder no longer checks a size, since the limit is the Tenant's; the Runtime refuses an oversized skill. The `skills.file-too-large` and `skills.too-many-files` errors are gone. Files are hashed and read a chunk at a time.
+  - Sandboxes get skill files as a stream. A harness fetches them from core 16 MiB at a time: `definition.file` takes optional `offset` and `length` (at most the Runtime limit `chunkBytes`).
+  - `load_skill` and `read_skill_resource` read files of up to 10 MiB into the model's context. A larger file fails with `skill.resource_too_large`, and the error names the file's path in the sandbox when there is one.
+
+### Patch Changes
+
+- cf425c6: **The harness mounts skills and saves outputs; the in-process harness uses the gates; compaction is a transcript edit (protocol 15).** The fifth step of the harness boundary, still protocol 15 and Harness API 4. See MIGRATION.md.
+
+  - **Skill folders are our engine's.** Before each sandbox call our engine mounts each skill version of the turn's tree at `/skills/<name>@<hash>/` with `executors.files.mount`, reading the bytes over `definition.file`; the SandboxManager only writes them (`mountFolder`), once per open sandbox (`present` after). `SandboxManager.mountSkills`, its `definitionFile` port and `SandboxSessionRef.manifest` are gone, and the operator sandbox route mounts nothing.
+  - **The outputs folder is our engine's (Q5).** At a completed turn's end in a sandbox our engine saves `/workspace/outputs` as the session's `outputs` folder before `turn.completed`, over the new folder mode of `artifact.write` (`kind: "folder"`, `file`, chunks named by hash, `unchanged`, `refused`). Core takes every byte, checks each file's hash before content is stored under it, dedupes, and keeps the content epoch and quotas. Versions say `source: "engine"`; `artifact.export.skipped` and `artifact.export.failed` are harness claims. Core's export (`artifacts/export.ts`, the `WorkspaceReader`, `workspace.read` listing and bytes calls) is removed.
+  - **No limit literals.** The new Runtime limit `folderEntries` (10,000; a count, its ceiling from the manifest's one string) replaces `EXPORT_MAX_FILES`, and `createHarness({ outputs: { dir, maxBytes } })` (`/workspace/outputs`, 1 GiB) replaces `EXPORT_MAX_BYTES`. `RUNTIME_LIMIT_CEILINGS` entries are `{value, unit, why}`.
+  - **In-process parity.** Every model call goes through the Model Gate: a scripted model is served by `providerModelGate`, metered like any. The MCP pool opens every server through the Tool Gate (`openRemote` is required; the in-process gate's `openMcp` finds the server in the session's pinned manifest and authorizes it with the vault). `ModelRoute` is `{tenantId, modelGate}`; `TenantContext.modelProvider`, `useVaultModel` and `workspaces` are gone.
+  - **Compaction is a transcript edit (Q4).** Summary calls say `purpose: "summary"` (no `message.assistant`), and the segment's edit that replaced the history says `kind: "compaction"` with its facts and summary calls (`CompactionFactsSchema`, `transcriptUpdates(..., compaction)`). Core checks the calls and writes one `context.compacted`, which loses `partial`.
+
+- dc75e58: **Host timings, retries and engine settings are configuration with defaults (B15).** Still protocol 15 and Harness API 4. See MIGRATION.md and DEPLOYMENT.md ("Host tuning").
+
+  - **Host tuning.** The Runtime processes' timeouts, retries, poll intervals and internal sizes are one typed schema with a default each (`HostTuningSchema`, `runtime/server/src/tuning.ts`): keys, the Harness API, the API's streams, the Host, the Object store, the Tenant, its sweep, Durable Session Execution, Restate, Postgres, Durable Streams and the relay, the gates, egress-gate, sandbox pods, harnesses and traces. An operator sets any part in `NYLORUN_TUNING` (JSON), parsed with the stack configuration and read once at start; every default is the value before. An unknown key or a value past its ceiling (Node's longest timer, S3's part sizes, S2's batch, the sandboxes service's wait) stops the process naming the key. Core hands a sandbox pod's engine the `harness` and `engine` groups the operator set. `nylorun start` passes `NYLORUN_TUNING` to the runtime, gateway and harness containers.
+  - **Our engine's loop is configuration.** `createHarness` takes `compaction` (`CompactionConfig`, `DEFAULT_COMPACTION_CONFIG`: the kept tail, the reply's reserve, the estimate), `partialOutputChars` (a failed agent-as-tool's output its parent sees), `resendDelaysMs` and `leaseRetryMs`; `runDurable` takes `loop` (`LoopConfig`), which an invocation hands its agents used as tools. `EngineToolConfig` is `EngineConfig`. The Runtime's harness host passes the tuning's `engine` group to `createHarness`.
+  - **Kept as constants**, each justified where it is defined: Node's longest timer, S3's part sizes and object key, S2's batch, the sandboxes service's longest wait and pod variable, the `environment.egress` event's 16 running turns, W3C's 512-character `tracestate`, and the 24-hour floor of a wake's dedupe key.
+
+- 23774c4: **The last hard-coded limits are configuration (harness boundary B15c).** Still protocol 15 and Harness API 4. Every default is the value before. See MIGRATION.md, and DEPLOYMENT.md's Runtime limits and Host tuning.
+
+  - **21 more Runtime limits** (`GET`/`PUT /v1/tenant/limits`): a message's parts (`messageParts`), page sizes (`pageItems`, `exportPageItems`, `environmentEventItems`; a page asked larger holds that many), labels (`artifactLabels`, `labelKeyChars`, `labelValueChars`), a manifest's setup command, descriptions and secret hosts (`setupCommandChars`, `manifestDescriptionChars`, `secretDescriptionChars`, `secretHosts`), a failed pod's reason (`setupReasonChars`, `setupCommandExcerptChars`), secret values (`secretValueChars`), the tool policy and budgets (`toolRules`, `toolRuleFieldChars`, `toolRuleTextChars`, `modelBudgets`) and flows (`flowConcurrency`, `flowMapItems`, `flowLoopIterations`, replacing the `NYLORUN_FLOW_*` variables no Host read). Request schemas lose these maxima; the Runtime checks the Tenant's.
+  - **More Host tuning** (`NYLORUN_TUNING`): token lifetimes and clock tolerance (`keys.*`), the advance deadline and grace (`execution.*`), `nylorun-operate`'s waits, the credential store's lock, sweep arming, Postgres batches and the replication pool, a basin repair's log cadence, egress sockets, the engine poll and sandbox memory floor, MCP listing pages and diagnostics, sandbox helper commands, the scrub threshold, exec event and local stream sizes; and in the engine, `flowValueChars` and `toolResults.minPreviewBytes`.
+  - **The CLI's own waits are `NYLORUN_CLI_TUNING`**: `nylorun start`'s waits and polls, the Compose healthchecks and WAL cap, and `nylorun local sandbox`'s waits.
+  - **Studio follows the Runtime's limits**: no upload cap of its own, the Tenant's `requestBodyBytes` read for a write it parses past the default (`@nylorun/agents` exports `RUNTIME_LIMIT_DEFAULTS`), no CPU cap in its form.
+  - **Kept, each justified where it is defined**: Linux's `MAX_ARG_STRLEN` (a setup command's ceiling) and `PATH_MAX` (a link target), a model-facing tool name's 64 characters, RFC 6838's media type length, Postgres's 65,535 bind parameters, a tmpfs page, and identifier grammars (the protocol's).
+
+- 6772612: **The remaining request, upload, token and sandbox limits are Tenant settings (harness boundary B15).** Still protocol 15 and Harness API 4. See MIGRATION.md and DEPLOYMENT.md's Runtime limits.
+
+  - **27 more Runtime limits** in `GET`/`PUT /v1/tenant/limits`, each with today's value as its default and a ceiling from a dependency (a JavaScript string or timer, a request read as one string, a Harness API frame, a JavaScript number): request bodies and inline files (`requestBodyBytes`, `inlineFileBytes`), `a2aWaitMs`, `errorExcerptChars`, `traceContentBytes`, an Environment's labels, setup and input files (`environmentLabels`, `environmentSetupCommands`, `environmentFiles`, `environmentFilesPerEntry`, `environmentSecretSlots`, `setupCommandMs`, `setupOutputChars`), disk versions (`diskVersionEntries`, `diskVersionBytes`, `diskLeaseMs`, `diskPodWaitMs`; an Environment's manifest may lower the first two with `limits.disk`), model calls (`modelRequestMs`, `modelIdleMs`, `modelAttempts`, `modelRetryDelayMs`, `modelProviderRetries`, `modelRetryDelayMaxMs`, read by the gates for each call) and tools (`toolAttempts`, `httpToolTimeoutMs`, `mcpPreviewMs`, `mcpMetadataBytes`, and the new `mcpSnapshotBytes`: what a session pins of its MCP servers' tools and instructions, past which a server is left out with a diagnostic).
+  - **Schema maxima are checked against the Tenant's limits**: an Environment's labels, setup commands, input files, files per entry, secret slots and setup timeout, and an HTTP tool's `timeoutMs` (at deploy and at each call). `limits.environments` and `lifecycle.stopGrace` lose their arbitrary caps; an identity file's issuer takes any number of grants and `jwksFetch` settings.
+  - **`turn.start.limits` carries only a harness's limits** (`HarnessLimitsSchema`, `harnessLimitsOf`), and a harness drops one it does not know. `transcriptUpdates` takes `recordEntryBytes` and fills each event up to it; `CHUNK_BYTES` is gone.
+  - **Constants a dependency or a standard fixes stay, named for it**: a token is read up to Node's `http.maxHeaderSize`; artifact names and folder paths keep `FILE_NAME_MAX` (255) and `FILE_PATH_MAX` (1,024); a skill file's path is what `FILE_PATH_MAX` leaves under its mount folder; `tracestate` keeps W3C's 512.
+  - **Removed**: `ENVIRONMENT_LABELS_MAX`, `ENVIRONMENT_SETUP_MAX`, `ENVIRONMENT_SETUP_TIMEOUT_MAX_MS` (now `ENVIRONMENT_SETUP_TIMEOUT_DEFAULT`), `ENVIRONMENT_FILES_MAX`, `ENVIRONMENT_SECRET_SLOTS_MAX`, `TOKEN_ENVIRONMENT_GRANTS_MAX`, `HTTP_TOOL_MAX_TIMEOUT_MS`, `READ_ARTIFACT_MAX_BYTES` and `CHUNK_BYTES` from `@nylorun/core`; the image checks (`decodeImageBase64`, `validateImageBytes`, `IMAGE_MEDIA_TYPES`, `MAX_IMAGE_BYTES`), the Tenant configuration's `modelCall` and `TrustedIssuersOptions`' `refetchMs`/`maxAgeMs` from `@nylorun/runtime`. Studio's Environment form no longer caps setup commands and input files at 16: the Runtime checks the Tenant's limit.
+
+- Pin core to the tested release.
+- Pin agents to the tested release.
+- Pin admin to the tested release.
+- Pin runtime to the tested release.
+- Pin studio to the tested release.
+- Updated dependencies [0a2fbc5]
+- Updated dependencies [ebe7348]
+- Updated dependencies [ff6470e]
+- Updated dependencies [f443475]
+- Updated dependencies [cf425c6]
+- Updated dependencies [23774c4]
+- Updated dependencies [b1e815d]
+- Updated dependencies [2459430]
+- Updated dependencies [f2e9b0a]
+- Updated dependencies [6772612]
+- Updated dependencies
+- Updated dependencies
+  - @nylorun/core@0.23.0-beta
+  - @nylorun/agents@0.23.0-beta
+  - @nylorun/admin@0.18.0-beta
+
 ## 0.15.1-beta
 
 ### Patch Changes

package/README.md

@@ -96,7 +96,7 @@ nylorun tenant usage [--scope tenant|agent|turn] [--id <id>] [--period day|month
 nylorun tenant calls [--after <cursor>] [--limit <n>] [--tenant <name>]   # every recorded model call as NDJSON, until caught up
 nylorun tenant budgets [get | put <file|->] [--tenant <name>]       # the model spend caps
 nylorun tenant tool-policy [get | put <file|->] [--tenant <name>]   # the Tool Gate's rules
-nylorun tenant settings sandbox|artifacts [get | put <file|->] [--tenant <name>]   # Environment and artifact store settings
+nylorun tenant settings sandbox|artifacts|skills|limits [get | put <file|->] [--tenant <name>]   # Environment, artifact store and skill settings, Runtime limits
 nylorun tenant coverage --agent <id> [--environment <id>] [--tenant <name>] [--json]   # which secret each MCP server and HTTP tool would get
 nylorun tenant mcp inspect <url> [--server <name>] [--environment <id>] [--sse] [--tenant <name>] [--json]
 
@@ -510,13 +510,14 @@ already has a credential, keeping its model (or `--model`) and endpoint.
 
 ### Files in, files out
 
-`budgets`, `tool-policy`, `settings sandbox` and `settings artifacts` are
-documents: `get` (the default) prints one as JSON, and `put <file>` (or `put -`
-for stdin) replaces the whole document with the JSON body in the file, the
-Management API's request body (`PUT /v1/tenant/budgets`, `/tool-policy`,
-`/sandbox`, `/artifacts`). The body is checked against its schema before
-anything is sent; one that does not parse exits 2. What `budgets`, `tool-policy`
-and `settings artifacts` print, `put` takes back (their `updatedAt` and
+`budgets`, `tool-policy`, `settings sandbox`, `settings artifacts`,
+`settings skills` and `settings limits` are documents: `get` (the default)
+prints one as JSON, and `put <file>` (or `put -` for stdin) replaces the whole
+document with the JSON body in the file, the Management API's request body
+(`PUT /v1/tenant/budgets`, `/tool-policy`, `/sandbox`, `/artifacts`, `/skills`,
+`/limits`). The body is checked against its schema before anything is sent; one
+that does not parse exits 2. What `budgets`, `tool-policy`, `settings artifacts`,
+`settings skills` and `settings limits` print, `put` takes back (their `updatedAt` and
 `usedBytes` are dropped), so they can be kept in a repository and applied from
 CI:
 
@@ -528,11 +529,28 @@ nylorun tenant tool-policy put tool-policy.json
 `settings sandbox get` prints the effective settings and what the Host offers;
 its `put` takes the settings alone (`limits`, `lifecycle`, `placement`).
 
+`settings limits` is the Tenant's Runtime limits: the sizes, counts and
+deadlines the Runtime holds what crosses it to, such as `recordEntryBytes`,
+`requestBodyBytes`, `environmentLabels`, `pageItems`, `modelRequestMs` and
+`httpToolTimeoutMs` (each one, with its default and ceiling, in DEPLOYMENT.md's
+Runtime limits). A
+limit left out of a `put` takes its default; one above its ceiling (S2's 1 MiB
+record, the Harness API's 64 MiB frame, a JavaScript timer) is refused, and the
+error names the ceiling.
+
 `nylorun tenant calls` prints each recorded model call as one JSON line, page
 after page, until it is caught up, then the cursor on stderr: pass it as
 `--after` to read only the newer calls. A call may come twice across runs;
 deduplicate by `id`.
 
+### The CLI's own waits
+
+How long `nylorun start` waits for the stack, how often it polls, the healthchecks
+it writes into the Compose file and the waits of `nylorun local sandbox` are the
+CLI's tuning: a JSON object in `NYLORUN_CLI_TUNING`, each value left out keeping
+its default (`{"stack":{"healthWaitMs":120000}}`). DEPLOYMENT.md ("The CLI") lists
+them. The Runtime's own are `NYLORUN_TUNING`, which `nylorun start` passes on.
+
 ## Exit codes
 
 | Code | Meaning |

package/dist/client/mcp.js

@@ -22,8 +22,6 @@ const SECRET_HINT = "write it as a bearer or headers secret of an Environment (n
 export const MCP_VAULT_REMOVED = "--vault was removed in protocol 11: a credential is a secret of an Environment, in its own vault. Pass --environment <id> to send that Environment's credential for the URL.";
 /** What the removed `connect` subcommand says since protocol 10. */
 export const MCP_CONNECT_REMOVED = `The connect subcommand of nylorun mcp was removed with MCP OAuth (protocol 10): ${SECRET_HINT.replace("write it", "write the server's key")}, or reach a server that needs a person's sign-in through a gateway (a secret with via). See its tools with nylorun tenant mcp inspect <url> --environment <id>.`;
-/** The preview takes up to 15 s in the Runtime; the hop gets a margin. */
-const PREVIEW_TIMEOUT_MS = 30_000;
 const DESCRIPTION_CHARS = 60;
 const usageError = (message) => new CliError(message, 2);
 async function inspect(deps, args) {
@@ -53,8 +51,8 @@ async function inspect(deps, args) {
             ...(name === undefined ? {} : { name }),
             ...(environmentId === undefined ? {} : { environmentId }),
         }),
+        // The Runtime bounds the preview (its Runtime limit mcpPreviewMs, each step); the CLI waits.
         redirect: "error",
-        signal: AbortSignal.timeout(PREVIEW_TIMEOUT_MS),
     });
     const body = (await response.json().catch(() => ({})));
     if (response.status === 404 && body.code === "not_found")

package/dist/client/models.js

@@ -185,8 +185,9 @@ export async function callsCommand(deps, args) {
     const after = flags.values.get("--after");
     const limitFlag = flags.values.get("--limit");
     const limit = limitFlag === undefined ? undefined : Number(limitFlag);
-    if (limit !== undefined && !(Number.isInteger(limit) && limit >= 1 && limit <= 1000))
-        throw usageError("--limit is a whole number from 1 to 1000.");
+    // A page holds at most the Runtime limit exportPageItems; a larger --limit gets that many.
+    if (limit !== undefined && !(Number.isInteger(limit) && limit >= 1))
+        throw usageError("--limit is a whole number of at least 1.");
     const admin = await client(deps, flags.values.get("--tenant"));
     let next = null;
     for await (const page of admin.models.exportCalls({

package/dist/client/settings.d.ts

@@ -1,8 +1,8 @@
 import { type StackDeps } from "../stack/commands.js";
-export declare const settingsUsage = "  budgets [get | put <file|->] [--tenant <name>]\n                                      the model spend caps; put replaces them all\n  tool-policy [get | put <file|->] [--tenant <name>]\n                                      the Tool Gate's rules; put replaces them all\n  settings sandbox [get | put <file|->] [--tenant <name>]\n                                      the Environment settings: limits, stop grace, placement\n  settings artifacts [get | put <file|->] [--tenant <name>]\n                                      the artifact store's limits\n  coverage --agent <id> [--environment <id>] [--tenant <name>] [--json]\n                                      which secret of the Environment each of the agent's MCP\n                                      servers and HTTP tools would get";
+export declare const settingsUsage = "  budgets [get | put <file|->] [--tenant <name>]\n                                      the model spend caps; put replaces them all\n  tool-policy [get | put <file|->] [--tenant <name>]\n                                      the Tool Gate's rules; put replaces them all\n  settings sandbox [get | put <file|->] [--tenant <name>]\n                                      the Environment settings: limits, stop grace, placement\n  settings artifacts [get | put <file|->] [--tenant <name>]\n                                      the artifact store's limits\n  settings skills [get | put <file|->] [--tenant <name>]\n                                      the most bytes one skill may hold\n  settings limits [get | put <file|->] [--tenant <name>]\n                                      the Runtime limits: sizes, counts and deadlines (record\n                                      entries, request bodies, Environments, model calls, tools)\n  coverage --agent <id> [--environment <id>] [--tenant <name>] [--json]\n                                      which secret of the Environment each of the agent's MCP\n                                      servers and HTTP tools would get";
 export declare const budgetsCommand: (deps: StackDeps, args: readonly string[]) => Promise<number>;
 export declare const toolPolicyCommand: (deps: StackDeps, args: readonly string[]) => Promise<number>;
-/** `nylorun tenant settings sandbox | artifacts ...` */
+/** `nylorun tenant settings sandbox | artifacts | skills | limits ...` */
 export declare function settingsCommand(deps: StackDeps, args: readonly string[]): Promise<number>;
 /**
  * `nylorun tenant coverage`: which secret of `--environment` each remote MCP server and HTTP tool

package/dist/client/settings.js

@@ -1,4 +1,4 @@
-import { PutModelBudgetsRequestSchema, PutTenantArtifactsRequestSchema, PutTenantEnvironmentsRequestSchema, PutToolPolicyRequestSchema, } from "@nylorun/core/contracts";
+import { PutModelBudgetsRequestSchema, PutTenantArtifactsRequestSchema, PutTenantEnvironmentsRequestSchema, PutTenantLimitsRequestSchema, PutTenantSkillsRequestSchema, PutToolPolicyRequestSchema, } from "@nylorun/core/contracts";
 import { CliError } from "../errors.js";
 import { parseStackFlags } from "../stack/commands.js";
 import { printJson, printTable, readBody } from "./io.js";
@@ -11,6 +11,11 @@ export const settingsUsage = `  budgets [get | put <file|->] [--tenant <name>]
                                       the Environment settings: limits, stop grace, placement
   settings artifacts [get | put <file|->] [--tenant <name>]
                                       the artifact store's limits
+  settings skills [get | put <file|->] [--tenant <name>]
+                                      the most bytes one skill may hold
+  settings limits [get | put <file|->] [--tenant <name>]
+                                      the Runtime limits: sizes, counts and deadlines (record
+                                      entries, request bodies, Environments, model calls, tools)
   coverage --agent <id> [--environment <id>] [--tenant <name>] [--json]
                                       which secret of the Environment each of the agent's MCP
                                       servers and HTTP tools would get`;
@@ -42,6 +47,18 @@ const artifacts = {
     get: (admin) => admin.settings.artifacts.get(),
     put: (admin, body) => admin.settings.artifacts.put(body),
 };
+const skillSettings = {
+    name: "settings skills",
+    schema: PutTenantSkillsRequestSchema,
+    get: (admin) => admin.settings.skills.get(),
+    put: (admin, body) => admin.settings.skills.put(body),
+};
+const limitSettings = {
+    name: "settings limits",
+    schema: PutTenantLimitsRequestSchema,
+    get: (admin) => admin.settings.limits.get(),
+    put: (admin, body) => admin.settings.limits.put(body),
+};
 /** `<document> [get | put <file|->]`: `get` when no verb is given. */
 async function documentCommand(deps, document, args) {
     const usage = `nylorun tenant ${document.name} [get | put <file|->] [--tenant <name>]`;
@@ -56,13 +73,17 @@ async function documentCommand(deps, document, args) {
 }
 export const budgetsCommand = (deps, args) => documentCommand(deps, budgets, args);
 export const toolPolicyCommand = (deps, args) => documentCommand(deps, toolPolicy, args);
-/** `nylorun tenant settings sandbox | artifacts ...` */
+/** `nylorun tenant settings sandbox | artifacts | skills | limits ...` */
 export async function settingsCommand(deps, args) {
     const [which, ...rest] = args;
     if (which === "sandbox")
         return documentCommand(deps, sandbox, rest);
     if (which === "artifacts")
         return documentCommand(deps, artifacts, rest);
+    if (which === "skills")
+        return documentCommand(deps, skillSettings, rest);
+    if (which === "limits")
+        return documentCommand(deps, limitSettings, rest);
     throw usageError();
 }
 const COVERAGE_USAGE = "nylorun tenant coverage --agent <id> [--environment <id>] [--tenant <name>] [--json]";

package/dist/client/tenant.d.ts

@@ -6,7 +6,7 @@
 import type { ManagementClient } from "@nylorun/admin";
 import { type StackDeps } from "../stack/commands.js";
 import { type Connection } from "./target.js";
-export declare const tenantUsage = "nylorun tenant <command>\n\nThe Management API of the installation's one Tenant, with a management key: the local Tenant\n--tenant names (else the linked project's, else the default one), or the installation that\nNYLORUN_RUNTIME_URL and NYLORUN_MANAGEMENT_KEY name.\n\n  reset [--sessions|--environments|--all] [--yes] [--tenant <name>]\n                                      clear the Tenant's sessions, Environments or all its data\n                                      (the Project link and keys stay)\n  keys put <id> [--management] [--tenant <name>]\n                                      create the Tenant's application key <id> (--management: a\n                                      management key, on the Runtime's machine only), or rotate it\n                                      (the old key stops working); prints the key once\n  keys list [--tenant <name>] [--json]\n                                      the Tenant's keys: id, role, when issued (never the keys)\n  keys rm <id> [--tenant <name>]      delete key <id>: it stops working at once\n  signing-keys list [--tenant <name>]\n                                      the Tenant's token signing keys\n  signing-keys rotate [--force] [--tenant <name>]\n                                      rotate; --force ends outstanding links and run tokens\n  signing-keys revoke <kid> [--tenant <name>]\n                                      revoke a previous or standby key\n  models catalog [--tenant <name>] [--json]\n                                      every provider and model the Runtime knows\n  models providers [--tenant <name>] [--json]\n                                      the providers with a credential, and the one in use\n  models get [--tenant <name>] [--json]\n                                      the Tenant's model\n  models set [--tenant <name>]        sign in to a model provider and set the Tenant's model\n  models set --provider <id> --model <id> [--base-url <url>] [--tenant <name>]\n                                      the same with an API key piped in on stdin (CI)\n  models select <provider> [--model <id>] [--tenant <name>]\n                                      use a provider that has a credential (default: its model)\n  usage [--scope tenant|agent|turn] [--id <id>] [--period day|month|total] [--tenant <name>]\n                                      what the model calls used and cost (JSON)\n  calls [--after <cursor>] [--limit <n>] [--tenant <name>]\n                                      every recorded model call, one JSON line each, until\n                                      caught up; prints the cursor to resume from on stderr\n  budgets [get | put <file|->] [--tenant <name>]\n                                      the model spend caps; put replaces them all\n  tool-policy [get | put <file|->] [--tenant <name>]\n                                      the Tool Gate's rules; put replaces them all\n  settings sandbox [get | put <file|->] [--tenant <name>]\n                                      the Environment settings: limits, stop grace, placement\n  settings artifacts [get | put <file|->] [--tenant <name>]\n                                      the artifact store's limits\n  coverage --agent <id> [--environment <id>] [--tenant <name>] [--json]\n                                      which secret of the Environment each of the agent's MCP\n                                      servers and HTTP tools would get\n  mcp inspect <url> [--server <name>] [--environment <id>] [--sse] [--tenant <name>] [--json]\n                                      list a remote MCP server's tools, with Environment <id>'s\n                                      credential for <url> (none without it): model names, schema\n                                      sizes, renames, or that it needs a person's sign-in (the\n                                      Runtime calls no tool)\n\nA put reads a JSON body from a file, or from stdin for -, and replaces the whole document; what\nbudgets, tool-policy and settings artifacts get print, put takes back. An API key is read from\nstdin, never from the arguments.";
+export declare const tenantUsage = "nylorun tenant <command>\n\nThe Management API of the installation's one Tenant, with a management key: the local Tenant\n--tenant names (else the linked project's, else the default one), or the installation that\nNYLORUN_RUNTIME_URL and NYLORUN_MANAGEMENT_KEY name.\n\n  reset [--sessions|--environments|--all] [--yes] [--tenant <name>]\n                                      clear the Tenant's sessions, Environments or all its data\n                                      (the Project link and keys stay)\n  keys put <id> [--management] [--tenant <name>]\n                                      create the Tenant's application key <id> (--management: a\n                                      management key, on the Runtime's machine only), or rotate it\n                                      (the old key stops working); prints the key once\n  keys list [--tenant <name>] [--json]\n                                      the Tenant's keys: id, role, when issued (never the keys)\n  keys rm <id> [--tenant <name>]      delete key <id>: it stops working at once\n  signing-keys list [--tenant <name>]\n                                      the Tenant's token signing keys\n  signing-keys rotate [--force] [--tenant <name>]\n                                      rotate; --force ends outstanding links and run tokens\n  signing-keys revoke <kid> [--tenant <name>]\n                                      revoke a previous or standby key\n  models catalog [--tenant <name>] [--json]\n                                      every provider and model the Runtime knows\n  models providers [--tenant <name>] [--json]\n                                      the providers with a credential, and the one in use\n  models get [--tenant <name>] [--json]\n                                      the Tenant's model\n  models set [--tenant <name>]        sign in to a model provider and set the Tenant's model\n  models set --provider <id> --model <id> [--base-url <url>] [--tenant <name>]\n                                      the same with an API key piped in on stdin (CI)\n  models select <provider> [--model <id>] [--tenant <name>]\n                                      use a provider that has a credential (default: its model)\n  usage [--scope tenant|agent|turn] [--id <id>] [--period day|month|total] [--tenant <name>]\n                                      what the model calls used and cost (JSON)\n  calls [--after <cursor>] [--limit <n>] [--tenant <name>]\n                                      every recorded model call, one JSON line each, until\n                                      caught up; prints the cursor to resume from on stderr\n  budgets [get | put <file|->] [--tenant <name>]\n                                      the model spend caps; put replaces them all\n  tool-policy [get | put <file|->] [--tenant <name>]\n                                      the Tool Gate's rules; put replaces them all\n  settings sandbox [get | put <file|->] [--tenant <name>]\n                                      the Environment settings: limits, stop grace, placement\n  settings artifacts [get | put <file|->] [--tenant <name>]\n                                      the artifact store's limits\n  settings skills [get | put <file|->] [--tenant <name>]\n                                      the most bytes one skill may hold\n  settings limits [get | put <file|->] [--tenant <name>]\n                                      the Runtime limits: sizes, counts and deadlines (record\n                                      entries, request bodies, Environments, model calls, tools)\n  coverage --agent <id> [--environment <id>] [--tenant <name>] [--json]\n                                      which secret of the Environment each of the agent's MCP\n                                      servers and HTTP tools would get\n  mcp inspect <url> [--server <name>] [--environment <id>] [--sse] [--tenant <name>] [--json]\n                                      list a remote MCP server's tools, with Environment <id>'s\n                                      credential for <url> (none without it): model names, schema\n                                      sizes, renames, or that it needs a person's sign-in (the\n                                      Runtime calls no tool)\n\nA put reads a JSON body from a file, or from stdin for -, and replaces the whole document; what\nbudgets, tool-policy, settings artifacts, settings skills and settings limits get print, put takes back. An API key is read from\nstdin, never from the arguments.";
 /** The Management API client of the installation `--tenant` (or the environment) names. */
 export declare function tenantClient(deps: StackDeps, tenant: string | undefined): Promise<{
     connection: Connection;

package/dist/client/tenant.js

@@ -24,7 +24,7 @@ ${settingsUsage}
 ${mcpUsage}
 
 A put reads a JSON body from a file, or from stdin for -, and replaces the whole document; what
-budgets, tool-policy and settings artifacts get print, put takes back. An API key is read from
+budgets, tool-policy, settings artifacts, settings skills and settings limits get print, put takes back. An API key is read from
 stdin, never from the arguments.`;
 const usageError = (message) => new CliError(message, 2);
 /** The Management API client of the installation `--tenant` (or the environment) names. */

package/dist/project/seed.js

@@ -3,6 +3,7 @@ import { readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { parseEnv } from "node:util";
 import { PROTOCOL_HEADER, PROTOCOL_VERSION } from "@nylorun/core/compatibility";
+import { cliTuning } from "../tuning.js";
 /**
  * The Project's `.env` as a value map. It is never applied to this process or written back:
  * a Project's `.env` never configures the Host.
@@ -56,7 +57,7 @@ async function call(fetch, url, managementKey, init = {}) {
         },
         ...(init.body === undefined ? {} : { body: JSON.stringify(init.body) }),
         redirect: "error",
-        signal: AbortSignal.timeout(15_000),
+        signal: AbortSignal.timeout(cliTuning().stack.seedRequestMs),
     });
     const body = (await response.json().catch(() => ({})));
     if (!response.ok)

package/dist/sandbox/commands.js

@@ -10,6 +10,7 @@ import { apiRoute, readClusterFile, removeClusterFiles, writeClusterFiles, } fro
 import { contexts, kube } from "./kubectl.js";
 import { CONTROLLER_DEPLOYMENT, CONTROLLER_NAMESPACE, CONTROLLER_SHA256, CONTROLLER_URL, CONTROLLER_VERSION, networkPolicy, SANDBOX_API_VERSION, SANDBOX_CRD, tenantLabel, tenantManifests, tenantNamespace, TOKEN_SECRET, } from "./manifests.js";
 import { assertIPv4, runProbe } from "./probe.js";
+import { cliTuning } from "../tuning.js";
 export const sandboxUsage = `  sandbox enable --context <name> [--tenant <name>] [--host-address <ip>] [--bind-address <ip>] [--no-pull]
                                       run the Tenant's sandboxes as pods on that kubeconfig context (agent-sandbox ${CONTROLLER_VERSION})
   sandbox disable [--tenant <name>] [--delete-namespace]
@@ -52,7 +53,7 @@ async function ensureController(k, fetch, err) {
         return;
     }
     err(`Installing agent-sandbox ${CONTROLLER_VERSION} into ${k.context}.`);
-    const response = await fetch(CONTROLLER_URL, { signal: AbortSignal.timeout(60_000) });
+    const response = await fetch(CONTROLLER_URL, { signal: AbortSignal.timeout(cliTuning().sandbox.manifestDownloadMs) });
     if (!response.ok)
         throw new CliError(`Downloading ${CONTROLLER_URL} failed (HTTP ${response.status}).`, 1);
     const manifest = await response.text();
@@ -60,12 +61,13 @@ async function ensureController(k, fetch, err) {
     if (digest !== CONTROLLER_SHA256)
         throw new CliError(`${CONTROLLER_URL} has sha256 ${digest}, not the pinned ${CONTROLLER_SHA256}; not applying it.`, 1);
     await k.check("Installing agent-sandbox", ["apply", "--server-side", "-f", "-"], { input: manifest });
-    await k.check("Waiting for the Sandbox CRD", ["wait", "--for=condition=Established", `crd/${SANDBOX_CRD}`, "--timeout=60s"]);
-    await k.check("Waiting for the agent-sandbox controller", ["rollout", "status", `deployment/${CONTROLLER_DEPLOYMENT}`, "-n", CONTROLLER_NAMESPACE, "--timeout=180s"], { timeoutMs: 200_000 });
+    await k.check("Waiting for the Sandbox CRD", ["wait", "--for=condition=Established", `crd/${SANDBOX_CRD}`, `--timeout=${cliTuning().sandbox.crdWaitSeconds}s`]);
+    const tuning = cliTuning().sandbox;
+    await k.check("Waiting for the agent-sandbox controller", ["rollout", "status", `deployment/${CONTROLLER_DEPLOYMENT}`, "-n", CONTROLLER_NAMESPACE, `--timeout=${tuning.rolloutWaitSeconds}s`], { timeoutMs: tuning.rolloutWaitSeconds * 1000 + tuning.kubectlMarginMs });
 }
 /** The ServiceAccount token the token controller writes into the Secret. */
 async function serviceAccountToken(k, namespace, pollMs) {
-    const deadline = Date.now() + 60_000;
+    const deadline = Date.now() + cliTuning().sandbox.tokenWaitMs;
     for (;;) {
         const secret = await k.getJson(["secret", TOKEN_SECRET, "-n", namespace]);
         if (secret?.data?.token)
@@ -82,7 +84,7 @@ async function serviceAccountToken(k, namespace, pollMs) {
 export async function installCluster(deps, input) {
     const { stack } = deps;
     const k = kube(deps.kubectl, input.context);
-    const pollMs = deps.pollMs ?? 1000;
+    const pollMs = deps.pollMs ?? cliTuning().sandbox.pollMs;
     const { server, caData } = await readKubeconfig(k);
     let route;
     try {
@@ -189,7 +191,7 @@ async function enable(deps, args) {
         bind: installed.cluster.bindAddress,
     };
     await restartTenant(stack, { name: tenant.name, sandboxes: settings });
-    const ready = await stack.docker.stream(tenant.compose("up", "--detach", "--wait", "--wait-timeout", "120", "sandboxes"));
+    const ready = await stack.docker.stream(tenant.compose("up", "--detach", "--wait", "--wait-timeout", String(cliTuning().sandbox.composeWaitSeconds), "sandboxes"));
     if (ready !== 0)
         throw new CliError(`The sandboxes service did not become ready (image ${images.sandboxes}). See "nylorun local logs sandboxes" and "nylorun local sandbox status".`, 7);
     const c = installed.cluster;
@@ -226,7 +228,7 @@ async function disable(deps, args) {
     return 0;
 }
 /** Asks the sandboxes service from inside the runtime container, which holds the token. */
-const INFO_SCRIPT = "fetch(process.env.NYLORUN_SANDBOXES_URL+'/v1/info',{headers:{authorization:'Bearer '+process.env.NYLORUN_SANDBOXES_TOKEN},signal:AbortSignal.timeout(5000)}).then(async r=>{process.stdout.write(await r.text());process.exit(r.ok?0:1)},()=>process.exit(1))";
+const infoScript = (timeoutMs) => `fetch(process.env.NYLORUN_SANDBOXES_URL+'/v1/info',{headers:{authorization:'Bearer '+process.env.NYLORUN_SANDBOXES_TOKEN},signal:AbortSignal.timeout(${timeoutMs})}).then(async r=>{process.stdout.write(await r.text());process.exit(r.ok?0:1)},()=>process.exit(1))`;
 async function status(deps, args) {
     const { stack } = deps;
     const usage = "nylorun local sandbox status [--tenant <name>] [--json]";
@@ -245,7 +247,7 @@ async function status(deps, args) {
     }
     await dockerPreflight(stack.docker);
     const ready = (await stack.docker.run(tenant.compose("exec", "-T", "sandboxes", "/sandboxes", "healthcheck"))).code === 0;
-    const answer = await stack.docker.run(tenant.compose("exec", "-T", "runtime", "node", "-e", INFO_SCRIPT));
+    const answer = await stack.docker.run(tenant.compose("exec", "-T", "runtime", "node", "-e", infoScript(cliTuning().sandbox.infoRequestMs)));
     let info;
     try {
         info = answer.code === 0 ? JSON.parse(answer.stdout) : undefined;

package/dist/sandbox/kubectl.js

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
 import { CliError } from "../errors.js";
+import { cliTuning } from "../tuning.js";
 /** The real `kubectl` on PATH. */
 export function spawnKubectl(env, binary = "kubectl") {
     const childEnv = Object.fromEntries(Object.entries(env).filter((entry) => entry[1] !== undefined));
@@ -9,7 +10,7 @@ export function spawnKubectl(env, binary = "kubectl") {
                 let stdout = "";
                 let stderr = "";
                 const child = spawn(binary, [...args], { env: childEnv, stdio: ["pipe", "pipe", "pipe"] });
-                const timer = setTimeout(() => child.kill("SIGKILL"), options.timeoutMs ?? 300_000);
+                const timer = setTimeout(() => child.kill("SIGKILL"), options.timeoutMs ?? cliTuning().sandbox.kubectlTimeoutMs);
                 child.stdout.on("data", (chunk) => (stdout += chunk));
                 child.stderr.on("data", (chunk) => (stderr += chunk));
                 child.once("error", (error) => {

package/dist/sandbox/manifests.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { cliTuning } from "../tuning.js";
 /**
  * What `nylorun local sandbox enable` installs into a cluster. The agent-sandbox controller is
  * pinned (D32, Experiment 2): v1.0.5, API agents.x-k8s.io/v1beta1, its release manifest
@@ -119,7 +120,7 @@ export function probePod(namespace, name, options) {
         spec: {
             automountServiceAccountToken: false,
             enableServiceLinks: false,
-            terminationGracePeriodSeconds: 1,
+            terminationGracePeriodSeconds: cliTuning().sandbox.probeGraceSeconds,
             restartPolicy: options.command ? "Never" : "Always",
             ...(options.nodeName ? { nodeName: options.nodeName } : {}),
             securityContext: { runAsNonRoot: true, runAsUser: 1000, seccompProfile: { type: "RuntimeDefault" } },
@@ -130,7 +131,7 @@ export function probePod(namespace, name, options) {
                     imagePullPolicy: "IfNotPresent",
                     command,
                     securityContext: { allowPrivilegeEscalation: false, capabilities: { drop: ["ALL"] } },
-                    resources: { limits: { cpu: "200m", memory: "64Mi" } },
+                    resources: { limits: { cpu: cliTuning().sandbox.probeCpu, memory: cliTuning().sandbox.probeMemory } },
                 },
             ],
         },

package/dist/sandbox/probe.js

@@ -1,6 +1,7 @@
 import { randomBytes } from "node:crypto";
 import { CliError } from "../errors.js";
 import { networkPolicy, PROBE_IMAGE, probePod } from "./manifests.js";
+import { cliTuning } from "../tuning.js";
 const DOCKER_DESKTOP_HOST = "192.168.65.254";
 /** Docker Desktop and OrbStack forward the host address to this machine's loopback. */
 export function defaultBind(context, hostAddress) {
@@ -27,7 +28,7 @@ async function sleep(ms) {
 }
 /** `wget` from a probe pod; true when the connection succeeds. */
 async function reaches(kube, namespace, pod, address, port) {
-    const result = await kube.run(["exec", "-n", namespace, pod, "--", "wget", "-q", "-O", "-", "-T", "3", `http://${address}:${port}/`], { timeoutMs: 20_000 });
+    const result = await kube.run(["exec", "-n", namespace, pod, "--", "wget", "-q", "-O", "-", "-T", String(cliTuning().sandbox.probeWgetSeconds), `http://${address}:${port}/`], { timeoutMs: cliTuning().sandbox.probeExecMs });
     return result.code === 0;
 }
 export async function runProbe(deps, options) {
@@ -35,7 +36,8 @@ export async function runProbe(deps, options) {
     const suffix = randomBytes(3).toString("hex");
     const namespace = `nylorun-sbx-probe-${suffix}`;
     const listener = namespace;
-    const poll = deps.pollMs ?? 1000;
+    const tuning = cliTuning().sandbox;
+    const poll = deps.pollMs ?? tuning.pollMs;
     let listenerStarted = false;
     const fail = (message) => new CliError(`Refusing context ${kube.context}: ${message}`, 6);
     try {
@@ -46,8 +48,8 @@ export async function runProbe(deps, options) {
             probePod(namespace, "restricted", { role: "restricted" }),
         ]);
         await kube.check("Waiting for the probe pods", [
-            "wait", "--for=condition=Ready", "pod", "--all", "-n", namespace, "--timeout=180s",
-        ], { timeoutMs: 200_000 });
+            "wait", "--for=condition=Ready", "pod", "--all", "-n", namespace, `--timeout=${tuning.probeReadySeconds}s`,
+        ], { timeoutMs: tuning.probeReadySeconds * 1000 + tuning.kubectlMarginMs });
         let hostAddress = options.hostAddress;
         if (!hostAddress) {
             const lookup = await kube.run(["exec", "-n", namespace, "control", "--", "nslookup", "host.docker.internal"]);
@@ -80,7 +82,7 @@ export async function runProbe(deps, options) {
         await kube.apply("Applying the probe NetworkPolicy", [
             networkPolicy(namespace, hostAddress, [allowed], { name: "probe", podSelector: { "nylorun.dev/probe": "restricted" } }),
         ]);
-        const deadline = Date.now() + (deps.policyTimeoutMs ?? 30_000);
+        const deadline = Date.now() + (deps.policyTimeoutMs ?? tuning.policyTimeoutMs);
         while (await reaches(kube, namespace, "restricted", peer, 8080)) {
             if (Date.now() > deadline)
                 throw fail("NetworkPolicy is not enforced: a pod under a deny policy still reached another pod. Sandboxes need a CNI that enforces NetworkPolicy (kindnet with policy support, Calico, Cilium).");
@@ -117,7 +119,7 @@ async function prePull(deps, namespace, images) {
     await kube.apply("Pre-pulling images", pods.map((pod) => pod.manifest));
     const failed = new Set();
     const done = new Set();
-    const deadline = Date.now() + 300_000;
+    const deadline = Date.now() + cliTuning().sandbox.prepullMs;
     while (done.size + failed.size < pods.length && Date.now() < deadline) {
         const list = await kube.getJson(["pods", "-n", namespace, "-l", "nylorun.dev/probe=pull"]);
         for (const item of list?.items ?? []) {
@@ -131,7 +133,7 @@ async function prePull(deps, namespace, images) {
                 done.add(pod.name);
         }
         if (done.size + failed.size < pods.length)
-            await sleep(deps.pollMs ?? 2000);
+            await sleep(deps.pollMs ?? cliTuning().sandbox.prepullPollMs);
     }
     return images.filter((image) => pods.some((pod) => pod.image === image && !done.has(pod.name)));
 }

package/dist/stack/commands.js

@@ -15,6 +15,7 @@ import { prepareStack, readStackEnv } from "./prepare.js";
 import { assertTenantName, chooseTenantName, DEFAULT_TENANT, defaultNylorunRoot, listTenants, moveStackRoots, readTenantRecord, removeOldProxy, sanitizeTenantName, tenantRoot, tenantsDir, writeTenantRecord, } from "./stacks.js";
 import { mintStudioLogin, studioOrigin } from "./studio-login.js";
 import { CLI_KEY_ID, hostKey, keyAuthenticates, PROJECT_KEY_ID, } from "./operator-keys.js";
+import { cliTuning } from "../tuning.js";
 export const STACK_SERVICES = [
     "postgres",
     "restate",
@@ -199,7 +200,7 @@ async function sleep(ms) {
 async function fetchHealth(deps, runtimeUrl) {
     try {
         const response = await deps.fetch(`${runtimeUrl}/health`, {
-            signal: AbortSignal.timeout(3000),
+            signal: AbortSignal.timeout(cliTuning().stack.probeTimeoutMs),
             redirect: "error",
         });
         if (!response.ok)
@@ -211,7 +212,7 @@ async function fetchHealth(deps, runtimeUrl) {
     }
 }
 async function waitForHealth(ctx, runtimeUrl, hostId) {
-    const deadline = Date.now() + (ctx.deps.healthTimeoutMs ?? 60_000);
+    const deadline = Date.now() + (ctx.deps.healthTimeoutMs ?? cliTuning().stack.healthWaitMs);
     for (;;) {
         const health = await fetchHealth(ctx.deps, runtimeUrl);
         if (health?.status === "ok") {
@@ -221,7 +222,7 @@ async function waitForHealth(ctx, runtimeUrl, hostId) {
         }
         if (Date.now() > deadline)
             throw new CliError(`The Runtime did not answer ${runtimeUrl}/health. See "nylorun local logs runtime".`, 7);
-        await sleep(ctx.deps.pollMs ?? 500);
+        await sleep(ctx.deps.pollMs ?? cliTuning().stack.pollMs);
     }
 }
 /** The Runtime's `/ready` (503 while not ready, same body); undefined when it does not answer. */
@@ -229,7 +230,7 @@ async function fetchReady(deps, runtimeUrl) {
     try {
         const response = await deps.fetch(`${runtimeUrl}/ready`, {
             headers: { accept: "application/json" },
-            signal: AbortSignal.timeout(3000),
+            signal: AbortSignal.timeout(cliTuning().stack.probeTimeoutMs),
             redirect: "error",
         });
         const body = (await response.json());
@@ -289,11 +290,11 @@ function tenantCauseMessage(ctx, tenant) {
  * Tenant cannot open (`schema-too-new`, `database-layout-old`), which ends the wait.
  */
 async function waitForTenant(ctx, runtimeUrl) {
-    const deadline = Date.now() + (ctx.deps.healthTimeoutMs ?? 60_000);
+    const deadline = Date.now() + (ctx.deps.healthTimeoutMs ?? cliTuning().stack.tenantWaitMs);
     for (let poll = 1;; poll += 1) {
         const open = (await fetchReady(ctx.deps, runtimeUrl))?.tenant === true;
         const late = Date.now() > deadline;
-        if (open || late || poll % 10 === 0) {
+        if (open || late || poll % cliTuning().stack.operateEveryPolls === 0) {
             const tenant = await operateStatus(ctx);
             if (tenant?.state === "open" && tenant.id)
                 return { ...tenant, id: tenant.id };
@@ -302,7 +303,7 @@ async function waitForTenant(ctx, runtimeUrl) {
             if (late)
                 throw new CliError(`Tenant ${ctx.name} did not open (${runtimeUrl}/ready: ${open ? "open, but nylorun-operate status did not answer" : "not open"})${tenant?.message ? `: ${tenant.message.replace(/\.$/, "")}` : ""}. See "nylorun status" and "nylorun local logs runtime".`, 7);
         }
-        await sleep(ctx.deps.pollMs ?? 500);
+        await sleep(ctx.deps.pollMs ?? cliTuning().stack.pollMs);
     }
 }
 /**
@@ -427,7 +428,7 @@ async function bringUp(ctx, options) {
     const up = await deps.docker.stream(
     // --remove-orphans: a service this start's file no longer has (the harness after a rollback
     // to NYLORUN_HARNESS=in-process, sandboxes after disable) is removed, not left running.
-    composeArgs(ctx, "up", "--detach", "--wait", "--wait-timeout", "300", "--remove-orphans", ...coreServices(prepared.env.harness)));
+    composeArgs(ctx, "up", "--detach", "--wait", "--wait-timeout", String(cliTuning().stack.composeWaitSeconds), "--remove-orphans", ...coreServices(prepared.env.harness)));
     if (up !== 0) {
         // A Runtime whose Tenant cannot open fails readiness; nylorun-operate names the cause.
         const tenant = await operateStatus(ctx);
@@ -444,7 +445,7 @@ async function bringUp(ctx, options) {
     }
     let studioStarted = false;
     if (options.studio) {
-        const studio = await deps.docker.stream(composeArgs(ctx, "up", "--detach", "--wait", "--wait-timeout", "120", "studio"));
+        const studio = await deps.docker.stream(composeArgs(ctx, "up", "--detach", "--wait", "--wait-timeout", String(cliTuning().stack.studioWaitSeconds), "studio"));
         studioStarted = studio === 0;
         if (!studioStarted)
             deps.err(`Warning: Studio did not start (image ${prepared.env.studioImage}). The Runtime is up; see "nylorun local logs studio".`);
@@ -466,7 +467,7 @@ const errorText = (error) => (error instanceof Error ? error.message : String(er
 async function tryStudioLogin(ctx, studioPort, adminKey) {
     const { deps } = ctx;
     const origin = studioOrigin(studioPort);
-    const deadline = Date.now() + (deps.loginTimeoutMs ?? 15_000);
+    const deadline = Date.now() + (deps.loginTimeoutMs ?? cliTuning().stack.loginWaitMs);
     let lastError = "";
     for (;;) {
         try {
@@ -477,7 +478,7 @@ async function tryStudioLogin(ctx, studioPort, adminKey) {
         }
         if (Date.now() > deadline)
             break;
-        await sleep(deps.pollMs ?? 500);
+        await sleep(deps.pollMs ?? cliTuning().stack.pollMs);
     }
     deps.err(`Warning: Studio at ${origin} is not reachable for a login (${lastError}).`);
     return undefined;

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.16.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,9 +30,9 @@
     "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.18.0-beta",
+    "@nylorun/agents": "0.23.0-beta",
+    "@nylorun/core": "0.23.0-beta"
   },
   "devDependencies": {
     "@earendil-works/pi-ai": "0.99.1",
@@ -46,7 +46,7 @@
     "nylo": "dist/nylo.js"
   },
   "nylorun": {
-    "runtime": "0.26.0-beta",
-    "studio": "0.25.1-beta"
+    "runtime": "0.27.0-beta",
+    "studio": "0.26.0-beta"
   }
 }