@nylorun/runtime 0.25.0-beta → 0.27.0-beta

package/dist/tenant/definition-files.js

@@ -3,15 +3,22 @@
  * today a skill's folder (`SkillManifest.files`). A client uploads each one once
  * (`PUT /v1/files/sha256:<hex>`); its bytes go to the Object store at
  * `definitions/sha256/<hex>`, and a `definition_files` row says the Tenant holds it. A
- * definition naming a file the Tenant does not hold is refused (`definition_files_missing`).
- * The Runtime reads them to serve the skill tools and to give a sandbox the skills' files.
+ * definition naming a file the Tenant does not hold is refused (`definition_files_missing`), and
+ * one whose skill's files hold more than the Tenant's skill limit together (`limit_exceeded`,
+ * `skills.config`, default 2 GiB). One file may be as large as a whole skill.
+ * The Runtime serves them to a run's harness (`definition.file`: our engine's skill tools read
+ * them) and gives a sandbox the skills' files.
  *
  * Files are never deleted here: `definition_file_uses` records which definition version names
  * which file, for a later sweep.
  */
-import { createHash } from "node:crypto";
-import { DEFINITION_FILE_MAX_BYTES, definitionFilesOf, isDefinitionFileHash, } from "@nylorun/core/contracts";
+import { randomUUID } from "node:crypto";
+import { definitionFilesOf, isDefinitionFileHash, skillsOf, } from "@nylorun/core/contracts";
+import { BlobTooLargeError } from "../blob/index.js";
 import { fail } from "./http.js";
+import { readSkillLimits } from "./limits.js";
+/** Where an upload's bytes wait while their hash is checked; never read as a definition file. */
+const STAGING_PREFIX = "definitions/uploads/";
 /** Where a definition file's bytes are in the Object store. */
 export function definitionFileKey(sha256) {
     return `definitions/sha256/${sha256.slice("sha256:".length)}`;
@@ -26,73 +33,104 @@ export async function hasDefinitionFile(ctx, file) {
     const sha256 = checkHash(file);
     return (await ctx.store.tx((t) => t.definitionFile(sha256))) !== undefined;
 }
-/** The body, at most `DEFINITION_FILE_MAX_BYTES`; past it, `413 limit_exceeded`. */
-async function readBody(body, declared) {
-    const tooLarge = () => fail(413, `A definition file may hold at most ${DEFINITION_FILE_MAX_BYTES} bytes`, {
+function tooLarge(limitBytes) {
+    return fail(413, `A definition file may hold at most ${limitBytes} bytes, the Tenant's limit for a whole skill`, {
         code: "limit_exceeded",
-        details: { limitBytes: DEFINITION_FILE_MAX_BYTES },
+        details: { limitBytes },
     });
-    if (declared !== undefined && declared > DEFINITION_FILE_MAX_BYTES) {
-        await body?.cancel().catch(() => undefined);
-        tooLarge();
-    }
-    if (body === null)
-        return new Uint8Array();
-    const chunks = [];
-    let size = 0;
-    const reader = body.getReader();
-    for (;;) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        size += value.byteLength;
-        if (size > DEFINITION_FILE_MAX_BYTES) {
-            await reader.cancel().catch(() => undefined);
-            tooLarge();
-        }
-        chunks.push(value);
-    }
-    return Buffer.concat(chunks);
 }
 /**
  * Stores the bytes of definition file `file`: `201` when they are new, `200` when the Tenant
- * holds them already (the body is not read). Bytes that do not hash to `file` are a `400`.
+ * holds them already (the body is not read). Bytes that do not hash to `file` are a `400`; more
+ * than the Tenant's skill limit (`skills.config`) a `413`. The body streams to a staging key and is copied to
+ * the file's key only once its hash is checked, so no file is held in memory and bytes of
+ * another hash never replace a file at its key.
  */
 export async function putDefinitionFile(ctx, file, request, signal) {
     const sha256 = checkHash(file);
-    const held = await ctx.store.tx((t) => t.definitionFile(sha256));
+    const { held, maxBytes } = await ctx.store.tx(async (t) => ({
+        held: await t.definitionFile(sha256),
+        maxBytes: (await readSkillLimits(t)).totalBytes,
+    }));
     if (held) {
         await request.body?.cancel().catch(() => undefined);
         return { status: 200, view: { sha256, size: held.size } };
     }
-    const bytes = await readBody(request.body, request.declaredBytes);
-    const actual = `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
-    if (actual !== sha256)
-        fail(400, `The body's SHA-256 is ${actual}, not ${sha256}: upload a file at its own hash`, {
-            code: "invalid_request",
-            details: { expected: sha256, actual },
-        });
-    // The key is the content's hash: a concurrent upload of the same file writes the same bytes.
-    await ctx.blobs.put(definitionFileKey(sha256), bytes, {
+    if (request.declaredBytes !== undefined && request.declaredBytes > maxBytes) {
+        await request.body?.cancel().catch(() => undefined);
+        tooLarge(maxBytes);
+    }
+    const options = {
         ...(request.contentType === undefined ? {} : { contentType: request.contentType }),
         ...(signal ? { signal } : {}),
-    });
+    };
+    const staging = `${STAGING_PREFIX}${randomUUID()}`;
+    let size;
+    try {
+        let staged;
+        try {
+            staged = await ctx.blobs.put(staging, request.body ?? new Uint8Array(), {
+                ...options,
+                maxBytes,
+            });
+        }
+        catch (error) {
+            if (error instanceof BlobTooLargeError)
+                tooLarge(maxBytes);
+            throw error;
+        }
+        const actual = `sha256:${staged.sha256}`;
+        if (actual !== sha256)
+            fail(400, `The body's SHA-256 is ${actual}, not ${sha256}: upload a file at its own hash`, {
+                code: "invalid_request",
+                details: { expected: sha256, actual },
+            });
+        const got = await ctx.blobs.get(staging, signal ? { signal } : {});
+        if (!got)
+            throw new Error(`The Object store lost the upload of ${sha256} at ${staging}`);
+        // The key is the content's hash: a concurrent upload of the same file writes the same bytes.
+        await ctx.blobs.put(definitionFileKey(sha256), got.body, options);
+        size = staged.size;
+    }
+    finally {
+        await ctx.blobs.delete(staging).catch(() => undefined);
+    }
     const inserted = await ctx.store.tx((t) => t.insertDefinitionFile({
         sha256,
         kind: "skill",
-        size: bytes.byteLength,
+        size,
         contentType: request.contentType ?? null,
         createdAt: new Date().toISOString(),
     }));
-    return { status: inserted ? 201 : 200, view: { sha256, size: bytes.byteLength } };
+    return { status: inserted ? 201 : 200, view: { sha256, size } };
 }
-/** The definition files `document` names that the Tenant does not hold, in order. */
-export async function missingDefinitionFiles(t, document) {
+/**
+ * Why `document` cannot be stored for the files it names: the files the Tenant does not hold
+ * (`missing`), else each skill whose files hold more than `limitBytes` together (`oversized`).
+ * A file a skill names at two paths counts twice: a sandbox holds both.
+ */
+export async function definitionFileIssues(t, document, limitBytes) {
     const named = [...definitionFilesOf(document)].sort();
     if (named.length === 0)
-        return [];
+        return { missing: [], oversized: [] };
     const held = await t.heldDefinitionFiles(named);
-    return named.filter((sha256) => !held.has(sha256));
+    const missing = named.filter((sha256) => !held.has(sha256));
+    if (missing.length > 0)
+        return { missing, oversized: [] };
+    const oversized = [];
+    for (const skill of skillsOf(document)) {
+        let bytes = 0;
+        for (const hash of Object.values(skill.files ?? {}))
+            if (typeof hash === "string")
+                bytes += held.get(hash) ?? 0;
+        if (bytes > limitBytes)
+            oversized.push({ name: String(skill.name), bytes });
+    }
+    return { missing, oversized };
+}
+/** A definition file's bytes as a stream, or undefined when the Object store does not have them. */
+export async function openDefinitionFile(blobs, sha256, options = {}) {
+    return (await blobs.get(definitionFileKey(sha256), options))?.body;
 }
 /** A definition file's bytes, or undefined when the Object store does not have them. */
 export async function readDefinitionFile(blobs, sha256, signal) {

package/dist/tenant/effects.js

@@ -1,11 +1,10 @@
 import { embeddedAgent, flowDelegateManifest, hashManifest, } from "@nylorun/core/define";
 import { countActiveFlowWork, deriveAgentEffectSessionId, isFlowToolEffect, isWorkflowManifest, linkedMessageInput, linkedMessageKey, linkedTurnEnd, settleAgentEffect, } from "../core/flow-host.js";
 import { mayDispatchMore } from "../core/limits.js";
+import { readRuntimeLimits } from "./runtime-limits.js";
 import { sessionCredentials } from "../vault/sources.js";
 import { isRemoteMcpCall } from "../harness/calls.js";
 import { isHttpToolCall } from "../gates/http-tool.js";
-import { sandboxSpecOf } from "../sandbox/share.js";
-import { withRuntimeTools, withSandbox } from "../sandbox/session-sandbox.js";
 import { loadSession, ownedSession, sessionOf, } from "./context.js";
 import { fail } from "./http.js";
 import { turnManifestOf } from "./session.js";
@@ -41,7 +40,7 @@ export function recoversToolCalls(ctx) {
 }
 /** True when `request` calls a tool of a declared MCP server (every one is remote) or an HTTP tool. */
 export function isGateToolEffect(s, request) {
-    return (isRemoteMcpCall({ rootManifest: s.manifest, mcpSnapshot: s.mcpSnapshot }, request) ||
+    return (isRemoteMcpCall({ rootManifest: s.manifest }, request) ||
         isHttpToolCall(s.manifest, request));
 }
 /**
@@ -50,7 +49,7 @@ export function isGateToolEffect(s, request) {
  * the running call or gets its outcome, instead of becoming `uncertain`.
  */
 export function recoversModelCalls(ctx) {
-    return ctx.useVaultModel && ctx.modelGate.recovers === true;
+    return ctx.modelGate.recovers === true;
 }
 /** Journal and dispatch a new flow effect (agent or tool node). */
 export async function resolveNewFlowEffect(ctx, request, signal, lease) {
@@ -87,7 +86,7 @@ export async function resolveNewFlowEffect(ctx, request, signal, lease) {
         const active = await countActiveFlowWork(t, request.sessionId, request.turnId);
         // When the run journaled the effect (R7.1); a queued effect keeps it once dispatched.
         const startedAt = existing?.startedAt ?? new Date().toISOString();
-        if (!mayDispatchMore(active, ctx.flowLimits)) {
+        if (!mayDispatchMore(active, await readRuntimeLimits(t))) {
             if (!existing || existing.status !== "queued")
                 await t.put("effects", request.effectId, {
                     request,
@@ -162,16 +161,14 @@ export async function resolveNewFlowEffect(ctx, request, signal, lease) {
         if (exists)
             return;
         const definition = leafDefinition(workflow, body, request);
-        // The tree's Environment reaches every agent in it: its sandbox, with its tools, and its vault.
-        const inherited = inheritedSandbox(workflow, definition);
-        // Without one, the agent still gets its runtime block: read_artifact (R2b C11) and its skill tools.
-        const pinned = inherited?.manifest ? inherited : runtimeTools(definition.manifest);
+        // The tree's Environment reaches every agent in it: its sandbox and its vault.
+        const sandbox = workflow.sandbox;
         const created = {
             id: agentSessionId,
             agentId: body.agentId,
             ownerUserId: workflow.ownerUserId,
-            manifest: pinned?.manifest ?? definition.manifest,
-            manifestHash: pinned?.manifestHash ?? definition.manifestHash,
+            manifest: definition.manifest,
+            manifestHash: definition.manifestHash,
             definitionHash: definition.manifestHash,
             implementationVersion: definition.implementationVersion,
             status: "idle",
@@ -191,7 +188,7 @@ export async function resolveNewFlowEffect(ctx, request, signal, lease) {
                         ? {}
                         : { environmentVersion: workflow.environmentVersion }),
                 }),
-            ...(inherited ? { sandbox: inherited.spec } : {}),
+            ...(sandbox === undefined ? {} : { sandbox }),
         };
         await t.put("sessions", agentSessionId, created);
     });
@@ -247,30 +244,6 @@ export async function resolveNewFlowEffect(ctx, request, signal, lease) {
         return { status: "pending" };
     });
 }
-/**
- * The sandbox a linked session inherits from its tree's owner when that sandbox was chosen at
- * open (pinned on the owner). A definition that declares its own sandbox keeps it, as before.
- */
-function inheritedSandbox(owner, definition) {
-    const spec = owner?.sandbox;
-    if (!spec || sandboxSpecOf(definition.manifest))
-        return undefined;
-    if (isWorkflowManifest(definition.manifest))
-        return { spec };
-    const sandboxed = withSandbox(definition.manifest, spec);
-    if (!sandboxed.ok)
-        throw new Error(sandboxed.message);
-    return { spec, manifest: sandboxed.manifest, manifestHash: sandboxed.manifestHash };
-}
-/** A linked agent session's `runtime` block without a sandbox (R2b C11); undefined for a workflow. */
-function runtimeTools(manifest) {
-    if (isWorkflowManifest(manifest))
-        return undefined;
-    const pinned = withRuntimeTools(manifest);
-    if (!pinned.ok)
-        throw new Error(pinned.message);
-    return { manifest: pinned.manifest, manifestHash: pinned.manifestHash };
-}
 /**
  * The credential of an MCP server or HTTP tool request made on behalf of a session: from its
  * Environment's vault (`vault/sources.ts`).

package/dist/tenant/environment-manifests.js

@@ -18,6 +18,8 @@ import {} from "@nylorun/core/contracts";
 import { hashManifest } from "@nylorun/core/compatibility";
 import { canonical } from "../store/canonical.js";
 import { resolveRecipe } from "../sandbox/resolve.js";
+import { limitIssues, manifestShapeIssues, readTenantLimits } from "./limits.js";
+import { readRuntimeLimits } from "./runtime-limits.js";
 import { effectiveSandboxConfig, readSandboxConfig } from "../sandbox/tenant-config.js";
 import { actorOf, fileErrors } from "./environments.js";
 import { fail } from "./http.js";
@@ -32,6 +34,7 @@ export function manifestRecipeRequest(manifest) {
         ...(manifest.lifecycle === undefined ? {} : { lifecycle: manifest.lifecycle }),
         ...(manifest.setup === undefined ? {} : { setup: manifest.setup }),
         ...(manifest.files === undefined ? {} : { files: manifest.files }),
+        ...(manifest.limits === undefined ? {} : { limits: manifest.limits }),
         ...(manifest.secrets === undefined ? {} : { secrets: manifest.secrets }),
     };
 }
@@ -89,7 +92,12 @@ function warningsOf(ctx, manifest) {
 async function errorsOf(t, manifest) {
     const config = effectiveSandboxConfig(await readSandboxConfig(t));
     const resolved = resolveRecipe(manifest.kind ?? "virtual", manifestRecipeRequest(manifest), config);
-    return [...(resolved.kind === "error" ? resolved.errors : []), ...(await fileErrors(t, manifest.files))];
+    return [
+        ...(resolved.kind === "error" ? resolved.errors : []),
+        ...limitIssues(manifest.limits, await readTenantLimits(t)),
+        ...manifestShapeIssues(manifest, await readRuntimeLimits(t)),
+        ...(await fileErrors(t, manifest.files)),
+    ];
 }
 export async function saveEnvironmentManifest(ctx, name, body, scope, options = {}) {
     const { requestId: _, ...manifest } = body;

package/dist/tenant/environments.d.ts

@@ -116,8 +116,6 @@ export declare function newVolume(ctx: TenantContext, t: Tx, environment: Enviro
     };
     reason?: "restore" | "lost";
 }): Promise<number>;
-/** How long a pending seed holds the disk before another process may take it over. */
-export declare const SEED_LEASE_MS: number;
 /** `GET /v1/environments/{id}/events`: the Environment's lifecycle stream. */
 export declare function environmentEventsOf(ctx: TenantContext, id: string, scope: AuthScope, query?: EnvironmentEventsQuery): Promise<{
     events: {

package/dist/tenant/environments.js

@@ -54,8 +54,11 @@ import { SETUP_FAILED } from "../sandbox/pods/lifecycle.js";
 import { requirePods } from "../sandbox/placement.js";
 import { deleteDiskArtifact, forkSeedOf, runPendingSeed, snapshotEnvironment } from "../artifacts/disk.js";
 import { manifestChanges, manifestRecipeRequest } from "./environment-manifests.js";
+import { labelIssues, limitIssues, limitsInForce, manifestShapeIssues, readTenantLimits, secretRequestIssues, } from "./limits.js";
+import { readRuntimeLimits } from "./runtime-limits.js";
 import { harnessOf, sessionOf } from "./context.js";
-import { fail } from "./http.js";
+import { fail, failRetryLater } from "./http.js";
+import { hostTuning } from "../tuning.js";
 /** The Environment grants that limit `scope`, or undefined when it reaches every Environment. */
 export function environmentGrantsOf(scope) {
     return scope.kind === "token" ? (scope.environments ?? []) : undefined;
@@ -109,6 +112,7 @@ async function viewOf(ctx, t, environment, owner) {
         ...(environment.manifestName === undefined ? {} : { manifestName: environment.manifestName }),
         ...(environment.manifestVersion === undefined ? {} : { manifestVersion: environment.manifestVersion }),
         ...(environment.manifestHash === undefined ? {} : { manifestHash: environment.manifestHash }),
+        limits: limitsInForce(await readTenantLimits(t), environment.applied.limits),
         ...(environment.forkedFrom === undefined ? {} : { forkedFrom: environment.forkedFrom }),
         ...(slots === undefined ? {} : { slots }),
         version: environment.version,
@@ -173,6 +177,7 @@ const INLINE_FIELDS = [
     "lifecycle",
     "setup",
     "files",
+    "limits",
     "secrets",
 ];
 /** The hash of what an Environment runs, recorded when it is made. */
@@ -196,6 +201,7 @@ function recipeRequest(body, existing) {
         ...pick("lifecycle", body.lifecycle),
         ...pick("setup", body.setup),
         ...pick("files", body.files),
+        ...pick("limits", body.limits),
         ...pick("secrets", body.secrets),
     };
 }
@@ -305,16 +311,25 @@ export async function putEnvironment(ctx, id, body, scope, options = {}) {
     const view = await ctx.store.tx(async (t) => {
         const now = new Date().toISOString();
         const config = effectiveSandboxConfig(await readSandboxConfig(t));
-        const resolve = (kind, request) => {
+        const tenantLimits = await readTenantLimits(t);
+        const runtimeLimits = await readRuntimeLimits(t);
+        // `limits` and the manifest's shape are checked against the Tenant's only when an Environment
+        // is made: a get-or-create on one made before the Tenant lowered a limit still answers, and
+        // the lower limit applies. Labels are checked whenever they are set.
+        const labels = labelIssues(body.labels, runtimeLimits);
+        if (labels.length > 0)
+            fail(400, labels.join(" "));
+        const resolve = (kind, request, creating) => {
             const resolved = resolveRecipe(kind, request, config);
-            return resolved.kind === "error" ? fail(400, resolved.errors.join(" ")) : resolved.recipe;
+            const errors = [
+                ...(resolved.kind === "error" ? resolved.errors : []),
+                ...(creating ? [...limitIssues(request.limits, tenantLimits), ...manifestShapeIssues(request, runtimeLimits)] : []),
+            ];
+            return resolved.kind === "error" || errors.length > 0 ? fail(400, errors.join(" ")) : resolved.recipe;
         };
         const deleting = (row) => {
             if (row && !live(row))
-                fail(409, `Environment ${id} is being deleted. Try again once it is gone.`, {
-                    code: "environment_busy",
-                    details: { retryAfterSeconds: 5 },
-                }, { "retry-after": "5" });
+                failRetryLater(`Environment ${id} is being deleted. Try again once it is gone.`, "environment_busy");
         };
         const found = async (existing) => {
             if (fork !== undefined)
@@ -333,7 +348,7 @@ export async function putEnvironment(ctx, id, body, scope, options = {}) {
                     immutable(["kind"], existing);
                 if (body.storage !== undefined && body.storage !== existing.recipe.storage)
                     immutable(["storage"], existing);
-                const recipe = resolve(existing.kind, recipeRequest(body, existing));
+                const recipe = resolve(existing.kind, recipeRequest(body, existing), false);
                 const differing = Object.keys({ ...recipe, ...existing.recipe })
                     .filter((field) => canonical(recipe[field]) !== canonical(existing.recipe[field]))
                     .sort();
@@ -363,7 +378,7 @@ export async function putEnvironment(ctx, id, body, scope, options = {}) {
         const kind = manifest ? (manifest.body.kind ?? "virtual") : (body.kind ?? "virtual");
         if (manifest && kind === "pod")
             await requirePods(ctx.pods, `Environment manifest ${manifest.name} is of kind pod, and a pod Environment`);
-        const recipe = resolve(kind, manifest ? manifestRecipeRequest(manifest.body) : recipeRequest(body));
+        const recipe = resolve(kind, manifest ? manifestRecipeRequest(manifest.body) : recipeRequest(body), true);
         await checkFiles(t, recipe.files);
         const from = body.from === undefined ? undefined : await forkSource(t, scope, kind, body.from);
         // A fork onto other setup runs it on the written disk (Q17).
@@ -390,7 +405,7 @@ export async function putEnvironment(ctx, id, body, scope, options = {}) {
                         kind: "seed",
                         version: seed.version,
                         startedAt: now,
-                        until: new Date(Date.now() + SEED_LEASE_MS).toISOString(),
+                        until: new Date(Date.now() + hostTuning().tenant.seedLeaseMs).toISOString(),
                     },
                 }
                 : {}),
@@ -461,6 +476,14 @@ export async function putEnvironment(ctx, id, body, scope, options = {}) {
  * accepted only when its binding is the slot's. Without slots, today's typed body.
  */
 export async function secretRequestFor(ctx, id, name, raw) {
+    const request = await parseSecretRequest(ctx, id, name, raw);
+    // Within the Tenant's Runtime limits `secretValueChars` and `secretHosts`, read for the write.
+    const issues = secretRequestIssues(request, await ctx.store.tx((t) => readRuntimeLimits(t)));
+    if (issues.length > 0)
+        fail(400, issues.join(" "));
+    return request;
+}
+async function parseSecretRequest(ctx, id, name, raw) {
     const environment = await ctx.store.tx((t) => liveEnvironment(t, id));
     const slots = environment?.recipe.secrets;
     if (!environment || slots === undefined)
@@ -538,8 +561,14 @@ export async function forkEnvironment(ctx, sourceId, body, scope) {
                 : `Environment manifest ${name} has no version ${ref.version}.`, { code: "manifest_not_found" });
         const kind = manifest.body.kind ?? "virtual";
         const resolved = resolveRecipe(kind, manifestRecipeRequest(manifest.body), effectiveSandboxConfig(await readSandboxConfig(t)));
-        if (resolved.kind === "error")
-            return fail(400, resolved.errors.join(" "));
+        const errors = [
+            ...(resolved.kind === "error" ? resolved.errors : []),
+            ...limitIssues(manifest.body.limits, await readTenantLimits(t)),
+            ...manifestShapeIssues(manifest.body, await readRuntimeLimits(t)),
+            ...labelIssues(body.labels, await readRuntimeLimits(t)),
+        ];
+        if (resolved.kind === "error" || errors.length > 0)
+            return fail(400, errors.join(" "));
         const recipe = resolved.recipe;
         const asked = body.disk ?? "latest";
         const disk = kind === "none" || source.kind === "none" || asked === "empty"
@@ -666,19 +695,13 @@ export function diskHeld(environment, now = Date.now()) {
 /** Refused while a snapshot or restore copies the disk (a pending seed does not count). */
 export function refuseDiskCopy(environment) {
     if (diskHeld(environment) && environment.diskOp.kind !== "seed")
-        fail(409, `Environment ${environment.id}'s disk is being copied (${environment.diskOp.kind}). Try again shortly.`, {
-            code: "environment_busy",
-            details: { retryAfterSeconds: 5 },
-        }, { "retry-after": "5" });
+        failRetryLater(`Environment ${environment.id}'s disk is being copied (${environment.diskOp.kind}). Try again shortly.`, "environment_busy");
 }
 /** Refused while a session that names Environment `id` has a turn running. */
 async function refuseBusy(t, id) {
     const busy = (await t.sessionsOnEnvironment(id)).some((session) => session.activeTurnId !== null);
     if (busy)
-        fail(409, `Environment ${id} has a turn running. Cancel it, or wait for it to end.`, {
-            code: "environment_busy",
-            details: { retryAfterSeconds: 5 },
-        }, { "retry-after": "5" });
+        failRetryLater(`Environment ${id} has a turn running. Cancel it, or wait for it to end.`, "environment_busy");
 }
 /**
  * Deletes `environment` (locked, live) in `t`: its vault and credentials at once, its workspace
@@ -813,10 +836,7 @@ export async function resetEnvironment(ctx, id, scope) {
         refuseDiskCopy(environment);
         const pod = environment.pod;
         if (pod.retiring !== undefined)
-            fail(409, `Environment ${id} is still deleting its previous volume. Try again shortly.`, {
-                code: "environment_busy",
-                details: { retryAfterSeconds: 5 },
-            }, { "retry-after": "5" });
+            failRetryLater(`Environment ${id} is still deleting its previous volume. Try again shortly.`, "environment_busy");
         await newVolume(ctx, t, environment);
         return viewOf(ctx, t, (await t.environment(id)) ?? environment, subjectOf(scope));
     });
@@ -845,7 +865,7 @@ export async function newVolume(ctx, t, environment, options = {}) {
                     kind: "seed",
                     version: options.seed.version,
                     startedAt: now,
-                    until: new Date(Date.now() + SEED_LEASE_MS).toISOString(),
+                    until: new Date(Date.now() + hostTuning().tenant.seedLeaseMs).toISOString(),
                 },
             }),
     }, now);
@@ -873,12 +893,13 @@ export async function newVolume(ctx, t, environment, options = {}) {
     await revokeHost(t, id, epoch);
     return volumeGen;
 }
-/** How long a pending seed holds the disk before another process may take it over. */
-export const SEED_LEASE_MS = 10 * 60_000;
 /** `GET /v1/environments/{id}/events`: the Environment's lifecycle stream. */
 export async function environmentEventsOf(ctx, id, scope, query = {}) {
     reachable(environmentGrantsOf(scope), id);
-    return ctx.store.tx(async (t) => ({ events: await t.environmentEvents(id, query) }));
+    // One read returns at most the Tenant's Runtime limit `environmentEventItems`; `from` reads on.
+    return ctx.store.tx(async (t) => ({
+        events: await t.environmentEvents(id, { ...query, limit: (await readRuntimeLimits(t)).environmentEventItems }),
+    }));
 }
 /**
  * The owner guard (Q7): refuses a session of `ownerUserId` on an Environment guarded for
@@ -935,11 +956,14 @@ export async function checkEnvironmentTurn(t, session, scope, ctx) {
             code: "environment_owner_mismatch",
         });
     // The harness the turn would run on (R4.1, Q9): a pod about to wake runs its recipe's. A
-    // session never moves to another harness: its state is that harness's.
+    // session never moves to another harness: its state is that harness's. An Environment's
+    // harness never changes since protocol 14, so this refuses a session whose Environment id was
+    // deleted and made again with another harness, and an Environment changed in place before
+    // protocol 14 whose recipe (a pod's, at its wake) names another harness than it applied.
     const waking = environment.pod !== undefined && (environment.pod.desired !== "running" || environment.pod.observed === "failed");
     const runs = waking ? environment.recipe.harness : environment.applied.harness;
     if (!isWorkflowManifest(session.manifest) && runs !== harnessOf(session))
-        fail(409, `Environment ${id} now runs the ${runs} harness, and this session runs ${harnessOf(session)}: open a new session to run on it.`, {
+        fail(409, `Environment ${id} runs the ${runs} harness, and this session runs ${harnessOf(session)}: open a new session to run on it.`, {
             code: "harness_mismatch",
             details: { harness: harnessOf(session), environmentHarness: runs },
         });

package/dist/tenant/ephemeral.d.ts

@@ -31,7 +31,7 @@ export interface StartEphemeralRuntimeOptions {
     /** When true, close() leaves hostRoot on disk. */
     retainRoot?: boolean;
     /**
-     * Trusted issuers whose JWTs the Tenant API accepts (Host feature `trusted-issuers`): the
+     * Trusted issuers whose JWTs the Runtime API accepts (Host feature `trusted-issuers`): the
      * issuers of an identity file (`parseIdentityFile`), or ones already built with
      * `createTrustedIssuers`. Default none.
      */

package/dist/tenant/ephemeral.js

@@ -25,6 +25,7 @@ import { hostPaths, tenantPaths } from "./paths.js";
 import { hostPrincipals } from "./principals.js";
 import { openTenantRuntime } from "./runtime.js";
 import { createTrustedIssuers } from "./issuers.js";
+import { hostTuning } from "../tuning.js";
 const nodeRequire = createRequire(import.meta.url);
 function coreVersion() {
     try {
@@ -127,7 +128,7 @@ export async function startEphemeralRuntime(options) {
         await host?.close();
         await module.close();
         await streams.close();
-        await ownPool?.end({ timeout: 5 });
+        await ownPool?.end({ timeout: hostTuning().postgres.closeTimeoutSeconds });
         if (!options.retainRoot)
             rmSync(hostRoot, { recursive: true, force: true });
     };

package/dist/tenant/history.d.ts

@@ -16,7 +16,7 @@
  *   transcript on the row too and checks the fold against it at every segment start.
  */
 import type { LiveEvent } from "@nylorun/core/contracts";
-export { CHUNK_BYTES, TranscriptFoldError, applyUpdate, applyUpdates, transcriptOf, transcriptUpdates, withTranscript, type TranscriptUpdate, } from "@nylorun/core/harness-api";
+export { TranscriptFoldError, applyUpdate, applyUpdates, transcriptOf, transcriptUpdates, withTranscript, type TranscriptUpdate, } from "@nylorun/core/harness-api";
 /** Where a session's fold starts. */
 export interface SessionHistory {
     /** The fold reads the record from this seq: a snapshot at or before the turn's start. */

package/dist/tenant/history.js

@@ -1,5 +1,5 @@
 import { applyUpdate, transcriptOf } from "@nylorun/core/harness-api";
-export { CHUNK_BYTES, TranscriptFoldError, applyUpdate, applyUpdates, transcriptOf, transcriptUpdates, withTranscript, } from "@nylorun/core/harness-api";
+export { TranscriptFoldError, applyUpdate, applyUpdates, transcriptOf, transcriptUpdates, withTranscript, } from "@nylorun/core/harness-api";
 let shadow = false;
 /** Shadow mode: keep the transcript on the session row and check the fold against it. */
 export function transcriptShadow() {

package/dist/tenant/host-token.d.ts

@@ -5,8 +5,8 @@ export declare const HOST_TOKEN_TYP = "nylorun-host+jwt";
 export declare const HOST_TOKEN_AUD = "nylorun-harness-api";
 export declare const EGRESS_TOKEN_TYP = "nylorun-egress+jwt";
 export declare const EGRESS_TOKEN_AUD = "nylorun-egress";
-/** How long a host or egress token lives. The engine renews them before. */
-export declare const HOST_TOKEN_TTL_SECONDS: number;
+/** How long a host or egress token lives (`keys.hostTokenTtlSeconds`). The engine renews them before. */
+export declare const hostTokenTtlSeconds: () => number;
 /** What a verified host or egress token says. */
 export interface HostClaims {
     readonly tenantId: string;
@@ -37,7 +37,7 @@ export interface EgressTokenRequest {
     /** The host epoch the join set. */
     readonly epoch: number;
     readonly podUid: string;
-    /** Seconds. Default and maximum `HOST_TOKEN_TTL_SECONDS`. */
+    /** Seconds. Default and maximum `keys.hostTokenTtlSeconds`. */
     readonly ttl?: number;
 }
 /**