@nylorun/runtime 0.25.0-beta → 0.27.0-beta

package/dist/tenant/limits.js

@@ -0,0 +1,175 @@
+/**
+ * What artifacts, skills and disk versions may hold: the Tenant's limits (`artifacts.config`,
+ * `skills.config` here, and the Runtime limits `diskVersion*` of `limits.config`), and an
+ * Environment's, which its manifest sets (`limits`). A limit the manifest leaves out is the
+ * Tenant's as it is when the limit is checked, and none is ever above the Tenant's: a manifest
+ * asking for more is refused when the Environment is made, and a Tenant that lowers a limit
+ * later lowers it for every Environment.
+ *
+ * Also the shape a manifest and an Environment's labels must fit, which the Tenant's Runtime
+ * limits set (`manifestShapeIssues`, `labelIssues`), checked when they are put rather than by
+ * their schemas (B15).
+ */
+import { SKILL_TOTAL_BYTES_DEFAULT, TenantSkillsConfigSchema, } from "@nylorun/core/contracts";
+import { parseSandboxDuration } from "@nylorun/core/define";
+import { readArtifactLimits } from "../artifacts/config.js";
+import { readRuntimeLimits } from "./runtime-limits.js";
+export const SKILLS_CONFIG_SETTING = "skills.config";
+/** The skill limits in force: the Tenant's, with the default for what it leaves unset. */
+export function effectiveSkillLimits(config) {
+    return { totalBytes: config.limits?.totalBytes ?? SKILL_TOTAL_BYTES_DEFAULT };
+}
+export async function readSkillsConfig(t) {
+    const raw = await t.getSetting(SKILLS_CONFIG_SETTING);
+    if (raw === undefined)
+        return {};
+    const parsed = TenantSkillsConfigSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : {};
+}
+export async function readSkillLimits(t) {
+    return effectiveSkillLimits(await readSkillsConfig(t));
+}
+export async function writeSkillsConfig(t, config) {
+    await t.putSetting(SKILLS_CONFIG_SETTING, JSON.stringify(TenantSkillsConfigSchema.parse(config)));
+}
+/** The Tenant's artifact, skill and disk version limits. */
+export async function readTenantLimits(t) {
+    const runtime = await readRuntimeLimits(t);
+    return {
+        artifacts: await readArtifactLimits(t),
+        skills: await readSkillLimits(t),
+        disk: { versionBytes: runtime.diskVersionBytes, versionEntries: runtime.diskVersionEntries },
+    };
+}
+/** The limits in force for an Environment whose manifest sets `set`: each within the Tenant's. */
+export function limitsInForce(tenant, set) {
+    const within = (asked, ceiling) => Math.min(asked ?? ceiling, ceiling);
+    return {
+        artifacts: {
+            fileBytes: within(set?.artifacts?.fileBytes, tenant.artifacts.fileBytes),
+            totalBytes: within(set?.artifacts?.totalBytes, tenant.artifacts.totalBytes),
+        },
+        skills: { totalBytes: within(set?.skills?.totalBytes, tenant.skills.totalBytes) },
+        disk: {
+            versionBytes: within(set?.disk?.versionBytes, tenant.disk.versionBytes),
+            versionEntries: within(set?.disk?.versionEntries, tenant.disk.versionEntries),
+        },
+    };
+}
+/** Why a manifest's `limits` cannot be made: each limit above the Tenant's. */
+export function limitIssues(set, tenant) {
+    const issues = [];
+    const check = (path, asked, ceiling, unit = "bytes") => {
+        if (asked !== undefined && asked > ceiling)
+            issues.push(`limits.${path} asks for ${asked} ${unit}; this Tenant allows at most ${ceiling}.`);
+    };
+    check("artifacts.fileBytes", set?.artifacts?.fileBytes, tenant.artifacts.fileBytes);
+    check("artifacts.totalBytes", set?.artifacts?.totalBytes, tenant.artifacts.totalBytes);
+    check("skills.totalBytes", set?.skills?.totalBytes, tenant.skills.totalBytes);
+    check("disk.versionBytes", set?.disk?.versionBytes, tenant.disk.versionBytes);
+    check("disk.versionEntries", set?.disk?.versionEntries, tenant.disk.versionEntries, "entries");
+    return issues;
+}
+/**
+ * Why `labels` cannot be set: more than the Tenant's Runtime limit `count` names
+ * (`environmentLabels` or `artifactLabels`), or a key or a value longer than `labelKeyChars` or
+ * `labelValueChars`.
+ */
+export function labelIssues(labels, limits, count = "environmentLabels") {
+    if (labels === undefined)
+        return [];
+    const issues = [];
+    const keys = Object.keys(labels);
+    if (keys.length > limits[count])
+        issues.push(`labels has ${keys.length}; the Runtime limit ${count} allows at most ${limits[count]} (PUT /v1/tenant/limits).`);
+    for (const key of keys) {
+        if (key.length > limits.labelKeyChars)
+            issues.push(`Label key ${JSON.stringify(key.slice(0, limits.labelKeyChars))}… has ${key.length} characters; the Runtime limit labelKeyChars allows at most ${limits.labelKeyChars} (PUT /v1/tenant/limits).`);
+        const value = labels[key];
+        if (value.length > limits.labelValueChars)
+            issues.push(`Label ${JSON.stringify(key)}'s value has ${value.length} characters; the Runtime limit labelValueChars allows at most ${limits.labelValueChars} (PUT /v1/tenant/limits).`);
+    }
+    return issues;
+}
+/** `"{what} has {n} characters; the Runtime limit {name} allows at most {limit} …"`, when over. */
+function longer(what, text, name, limits) {
+    return text !== undefined && text.length > limits[name]
+        ? [`${what} has ${text.length} characters; the Runtime limit ${name} allows at most ${limits[name]} (PUT /v1/tenant/limits).`]
+        : [];
+}
+/** `"{what} has {n}; the Runtime limit {name} allows at most {limit} …"`, when over. */
+function more(what, count, name, limits) {
+    return count > limits[name]
+        ? [`${what} has ${count}; the Runtime limit ${name} allows at most ${limits[name]} (PUT /v1/tenant/limits).`]
+        : [];
+}
+/**
+ * Why a secret write does not fit the Tenant's Runtime limits: an `environment_secret`'s or an
+ * `environment_variable`'s value past `secretValueChars`, or more hosts than `secretHosts`.
+ */
+export function secretRequestIssues(request, limits) {
+    const valued = request.type === "environment_secret" || request.type === "environment_variable";
+    return [
+        ...(valued && typeof request.value === "string" ? longer("value", request.value, "secretValueChars", limits) : []),
+        ...more("allowedHosts", request.allowedHosts?.length ?? 0, "secretHosts", limits),
+    ];
+}
+/**
+ * Why a tool policy does not fit the Tenant's Runtime limits: more rules than `toolRules`, a
+ * selector or a `when` path past `toolRuleFieldChars`, a `reason` or a `matches` past
+ * `toolRuleTextChars`.
+ */
+export function toolPolicyIssues(rules, limits) {
+    const issues = more("rules", rules.length, "toolRules", limits);
+    rules.forEach((rule, index) => {
+        const at = `rules[${index}]`;
+        issues.push(...longer(`${at}.tool`, rule.tool, "toolRuleFieldChars", limits), ...longer(`${at}.server`, rule.server, "toolRuleFieldChars", limits), ...longer(`${at}.agent`, rule.agent, "toolRuleFieldChars", limits), ...longer(`${at}.reason`, rule.reason, "toolRuleTextChars", limits));
+        for (const [path, condition] of Object.entries(rule.when ?? {}))
+            issues.push(...longer(`${at}.when path ${JSON.stringify(path.slice(0, limits.toolRuleFieldChars))}`, path, "toolRuleFieldChars", limits), ...longer(`${at}.when[${JSON.stringify(path)}].matches`, condition.matches, "toolRuleTextChars", limits));
+    });
+    return issues;
+}
+/** Why a set of model budgets does not fit: more than the Tenant's Runtime limit `modelBudgets`. */
+export function budgetIssues(budgets, limits) {
+    return more("budgets", budgets.length, "modelBudgets", limits);
+}
+/**
+ * Why an agent's `requires` does not fit: more secrets than an Environment's manifest may declare
+ * slots for (the Runtime limit `environmentSecretSlots`).
+ */
+export function requiresIssues(requires, limits) {
+    return more("requires.secrets", requires?.secrets?.length ?? 0, "environmentSecretSlots", limits);
+}
+/**
+ * Why a manifest (inline, or saved) does not fit the Tenant's Runtime limits: its description,
+ * its setup commands, their lengths and timeouts, its input file entries and the files of each,
+ * and its secret slots, their descriptions and hosts.
+ */
+export function manifestShapeIssues(manifest, limits) {
+    const issues = [];
+    const over = (what, count, name) => {
+        if (count > limits[name])
+            issues.push(`${what} has ${count}; the Runtime limit ${name} allows at most ${limits[name]} (PUT /v1/tenant/limits).`);
+    };
+    over("setup", manifest.setup?.length ?? 0, "environmentSetupCommands");
+    over("files", manifest.files?.length ?? 0, "environmentFiles");
+    over("secrets", Object.keys(manifest.secrets ?? {}).length, "environmentSecretSlots");
+    issues.push(...longer("description", manifest.description, "manifestDescriptionChars", limits));
+    for (const [name, slot] of Object.entries(manifest.secrets ?? {})) {
+        issues.push(...longer(`secrets.${name}.description`, slot.description, "secretDescriptionChars", limits));
+        if ("allowedHosts" in slot && Array.isArray(slot.allowedHosts))
+            issues.push(...more(`secrets.${name}.allowedHosts`, slot.allowedHosts.length, "secretHosts", limits));
+    }
+    manifest.setup?.forEach((command, index) => {
+        if (command.command.length > limits.setupCommandChars)
+            issues.push(`setup[${index}].command has ${command.command.length} characters; the Runtime limit setupCommandChars allows at most ${limits.setupCommandChars} (PUT /v1/tenant/limits).`);
+        const ms = command.timeout === undefined ? undefined : parseSandboxDuration(command.timeout);
+        if (ms !== undefined && ms > limits.setupCommandMs)
+            issues.push(`setup[${index}].timeout asks for ${ms} ms; the Runtime limit setupCommandMs allows at most ${limits.setupCommandMs} (PUT /v1/tenant/limits).`);
+    });
+    manifest.files?.forEach((file, index) => {
+        if ("files" in file)
+            over(`files[${index}].files`, Object.keys(file.files).length, "environmentFilesPerEntry");
+    });
+    return issues;
+}

package/dist/tenant/module.d.ts

@@ -3,7 +3,10 @@ export interface CreateTenantModuleOptions {
     /** Opens the Host's Tenant (`store-pg.ts`). */
     open: TenantOpener;
     logger: Logger;
-    /** Bound on opening the Tenant; a slower open fails with `open-timeout`. */
+    /**
+     * Bound on opening the Tenant; a slower open fails with `open-timeout`. Default the Host
+     * tuning's `tenant.openTimeoutMs` (30 s).
+     */
     openTimeoutMs?: number;
     /**
      * Runs once the Tenant is open, at start or on a later retry: the Host starts what needs the

package/dist/tenant/module.js

@@ -1,10 +1,7 @@
 import { openError, TenantOpenError } from "./cause.js";
 import { TimeoutError, withTimeout } from "./pool.js";
+import { hostTuning } from "../tuning.js";
 import { TenantUnavailableError, } from "./types.js";
-const OPEN_TIMEOUT_MS = 30_000;
-/** Retries of an open that failed outside the Tenant: from 1 s, doubling, at most 30 s apart. */
-const RETRY_FIRST_MS = 1_000;
-const RETRY_MAX_MS = 30_000;
 /**
  * Deep Tenant module (§8): the Host's one Tenant over an injected opener (tenancy.md §5).
  *
@@ -15,11 +12,15 @@ const RETRY_MAX_MS = 30_000;
  * with backoff, and by the next request, which gets 503 meanwhile.
  */
 export function createTenantModule(options) {
-    const { logger, openTimeoutMs = OPEN_TIMEOUT_MS } = options;
+    const tuning = hostTuning().tenant;
+    const { logger, openTimeoutMs = tuning.openTimeoutMs } = options;
+    // Retries of an open that failed outside the Tenant: from `openRetry.minMs`, doubling, at most
+    // `openRetry.maxMs` apart.
+    const { minMs: firstRetryMs, maxMs: maxRetryMs } = tuning.openRetry;
     let state = { kind: "idle" };
     let opening;
     let retry;
-    let nextDelayMs = RETRY_FIRST_MS;
+    let nextDelayMs = firstRetryMs;
     const current = () => state;
     async function openOnce() {
         let handle;
@@ -64,7 +65,7 @@ export function createTenantModule(options) {
             return;
         }
         state = { kind: "open", handle };
-        nextDelayMs = RETRY_FIRST_MS;
+        nextDelayMs = firstRetryMs;
         logger.info("tenant opened", { tenantId: handle.envelope.id });
         try {
             await options.onOpen?.(handle);
@@ -92,7 +93,7 @@ export function createTenantModule(options) {
         if (retry)
             return;
         const delayMs = nextDelayMs;
-        nextDelayMs = Math.min(delayMs * 2, RETRY_MAX_MS);
+        nextDelayMs = Math.min(delayMs * 2, maxRetryMs);
         retry = setTimeout(() => {
             retry = undefined;
             void load();

package/dist/tenant/outbound.d.ts

@@ -30,21 +30,21 @@ export type OutboundResult = {
     code: string;
     message: string;
 };
-/** The largest answer read from an endpoint. */
-export declare const MAX_RESPONSE_BYTES: number;
 /** True when `address` is private, loopback, link-local or unspecified (IPv4-mapped included). */
 export declare function isPrivateAddress(address: string): boolean;
 /** Why the Host refuses `url`, or `undefined` when it may be called. */
 export declare function refusal(url: URL, policy: OutboundPolicy): string | undefined;
 /**
- * POSTs (or, with `method`, PUTs or PATCHes) the JSON `body` to `url` under `policy`. Never
+ * Sends one request to `url` under `policy`: with `method` (default `POST`) and the JSON `body`,
+ * or with no body (and no `content-type`) when `body` is undefined, as for a `GET`. Never
  * throws; `signal` aborts the request.
  */
-export declare function post(target: string, body: string, headers: Record<string, string>, options: {
+export declare function send(target: string, body: string | undefined, headers: Record<string, string>, options: {
     policy: OutboundPolicy;
     signal: AbortSignal;
-    maxResponseBytes?: number;
-    method?: "POST" | "PUT" | "PATCH";
+    /** The largest answer read: the Tenant's Runtime limit `toolAnswerBytes` for an HTTP tool. */
+    maxResponseBytes: number;
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
 }): Promise<OutboundResult>;
 /**
  * A refusal of `guardedFetch`: the Host's policy forbids the URL or every address it resolves
@@ -59,34 +59,32 @@ export declare class OutboundRefused extends Error {
 export declare class OutboundFailed extends Error {
     readonly code: string;
     /**
-     * The request was sent in full before it failed, as `post()`'s `lost` (R2b C7): the server
+     * The request was sent in full before it failed, as `send()`'s `lost` (R2b C7): the server
      * may have acted on it. False for a failure to resolve or connect.
      */
     readonly sent: boolean;
     constructor(message: string, code: string, 
     /**
-     * The request was sent in full before it failed, as `post()`'s `lost` (R2b C7): the server
+     * The request was sent in full before it failed, as `send()`'s `lost` (R2b C7): the server
      * may have acted on it. False for a failure to resolve or connect.
      */
     sent?: boolean);
 }
-/** The largest answer `guardedFetch` reads. */
-export declare const MAX_FETCH_RESPONSE_BYTES: number;
-/** How long a `guardedFetch` request may take without a signal of its own. */
-export declare const FETCH_TIMEOUT_MS = 30000;
 /**
  * A `fetch` under the Host's address policy (F9 C2): the literal-IP and DNS checks of `post`
  * on the address actually connected to, `localhost` rewritten for the local stack, no
- * redirects (`redirect: "error"`; a 3xx answer rejects), a bounded answer and a 30 s timeout
- * unless the caller passes a signal. A refused URL or address rejects with `OutboundRefused`,
- * any other failure with `OutboundFailed`.
+ * redirects (`redirect: "error"`; a 3xx answer rejects), an answer of at most `maxResponseBytes`
+ * and a `timeoutMs` timeout unless the caller passes a signal, both the caller's (a Tenant's
+ * Runtime limits). A refused URL or address rejects with `OutboundRefused`, any other failure
+ * with `OutboundFailed`.
  *
  * `stream`: the Response resolves once the headers arrive and its body streams, unbounded and
  * with no timeout but the caller's signal: remote MCP servers, whose answers and event streams
  * stay open (`mcp/connect.ts`).
  */
-export declare function guardedFetch(policy: OutboundPolicy, options?: {
-    maxResponseBytes?: number;
-    timeoutMs?: number;
-    stream?: boolean;
+export declare function guardedFetch(policy: OutboundPolicy, options: {
+    maxResponseBytes: number;
+    timeoutMs: number;
+} | {
+    stream: true;
 }): typeof fetch;

package/dist/tenant/outbound.js

@@ -13,8 +13,6 @@ import { request as httpRequest } from "node:http";
 import { request as httpsRequest } from "node:https";
 import { BlockList, isIP } from "node:net";
 import { Readable } from "node:stream";
-/** The largest answer read from an endpoint. */
-export const MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
 const PRIVATE = new BlockList();
 for (const [network, prefix] of [
     ["0.0.0.0", 8],
@@ -76,12 +74,13 @@ function guardedLookup(policy) {
     });
 }
 /**
- * POSTs (or, with `method`, PUTs or PATCHes) the JSON `body` to `url` under `policy`. Never
+ * Sends one request to `url` under `policy`: with `method` (default `POST`) and the JSON `body`,
+ * or with no body (and no `content-type`) when `body` is undefined, as for a `GET`. Never
  * throws; `signal` aborts the request.
  */
-export async function post(target, body, headers, options) {
+export async function send(target, body, headers, options) {
     const { policy, signal } = options;
-    const limit = options.maxResponseBytes ?? MAX_RESPONSE_BYTES;
+    const limit = options.maxResponseBytes;
     const url = new URL(target);
     const refused = refusal(url, policy);
     if (refused)
@@ -108,8 +107,9 @@ export async function post(target, body, headers, options) {
             headers: {
                 ...headers,
                 host: originalHost,
-                "content-type": "application/json",
-                "content-length": String(Buffer.byteLength(body)),
+                ...(body === undefined
+                    ? {}
+                    : { "content-type": "application/json", "content-length": String(Buffer.byteLength(body)) }),
             },
             lookup: lookup,
             signal,
@@ -156,7 +156,7 @@ export class OutboundFailed extends Error {
     sent;
     constructor(message, code, 
     /**
-     * The request was sent in full before it failed, as `post()`'s `lost` (R2b C7): the server
+     * The request was sent in full before it failed, as `send()`'s `lost` (R2b C7): the server
      * may have acted on it. False for a failure to resolve or connect.
      */
     sent = false) {
@@ -166,25 +166,22 @@ export class OutboundFailed extends Error {
         this.name = "OutboundFailed";
     }
 }
-/** The largest answer `guardedFetch` reads. */
-export const MAX_FETCH_RESPONSE_BYTES = 1024 * 1024;
-/** How long a `guardedFetch` request may take without a signal of its own. */
-export const FETCH_TIMEOUT_MS = 30_000;
 /**
  * A `fetch` under the Host's address policy (F9 C2): the literal-IP and DNS checks of `post`
  * on the address actually connected to, `localhost` rewritten for the local stack, no
- * redirects (`redirect: "error"`; a 3xx answer rejects), a bounded answer and a 30 s timeout
- * unless the caller passes a signal. A refused URL or address rejects with `OutboundRefused`,
- * any other failure with `OutboundFailed`.
+ * redirects (`redirect: "error"`; a 3xx answer rejects), an answer of at most `maxResponseBytes`
+ * and a `timeoutMs` timeout unless the caller passes a signal, both the caller's (a Tenant's
+ * Runtime limits). A refused URL or address rejects with `OutboundRefused`, any other failure
+ * with `OutboundFailed`.
  *
  * `stream`: the Response resolves once the headers arrive and its body streams, unbounded and
  * with no timeout but the caller's signal: remote MCP servers, whose answers and event streams
  * stay open (`mcp/connect.ts`).
  */
-export function guardedFetch(policy, options = {}) {
-    const limit = options.maxResponseBytes ?? MAX_FETCH_RESPONSE_BYTES;
-    const timeoutMs = options.timeoutMs ?? FETCH_TIMEOUT_MS;
-    const stream = options.stream === true;
+export function guardedFetch(policy, options) {
+    const stream = "stream" in options;
+    const limit = "stream" in options ? Infinity : options.maxResponseBytes;
+    const timeoutMs = "stream" in options ? undefined : options.timeoutMs;
     const lookup = guardedLookup(policy);
     const guarded = async (input, init = {}) => {
         const request = input instanceof Request ? input : undefined;
@@ -215,7 +212,7 @@ export function guardedFetch(policy, options = {}) {
         }
         const originalHost = url.host;
         dockerHost(url, policy);
-        const signal = init.signal ?? request?.signal ?? (stream ? undefined : AbortSignal.timeout(timeoutMs));
+        const signal = init.signal ?? request?.signal ?? (timeoutMs === undefined ? undefined : AbortSignal.timeout(timeoutMs));
         const outgoing = { host: originalHost };
         for (const [name, value] of headers)
             outgoing[name] = value;
@@ -223,7 +220,7 @@ export function guardedFetch(policy, options = {}) {
             outgoing["content-length"] = String(body.byteLength);
         return await new Promise((resolve, reject) => {
             let settled = false;
-            // Set when the request is fully sent, as `post()` does: a failure after it may follow
+            // Set when the request is fully sent, as `send()` does: a failure after it may follow
             // the server acting on the request.
             let delivered = false;
             const settle = (fn) => {

package/dist/tenant/run-grants.js

@@ -1,4 +1,5 @@
-import { mintRunToken, RUN_TOKEN_RENEW_SECONDS } from "./run-token.js";
+import { mintRunToken } from "./run-token.js";
+import { hostTuning } from "../tuning.js";
 export function createRunGrants() {
     const grants = new Map();
     return {
@@ -50,7 +51,7 @@ export async function renewRunGrant(ctx, lease, run, active = () => true) {
     const held = ctx.runGrants.get(lease.sessionId);
     if (held && held.claims.epoch !== lease.epoch)
         return;
-    if (held && held.claims.expiresAt - Date.now() > RUN_TOKEN_RENEW_SECONDS * 1000)
+    if (held && held.claims.expiresAt - Date.now() > hostTuning().keys.runTokenRenewSeconds * 1000)
         return;
     const grant = await mintRunToken(ctx, lease, held ? { agentId: held.claims.agentId, activeTurnId: held.claims.turnId } : run);
     if (active())

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

@@ -4,10 +4,6 @@ import type { SessionStore } from "../store/types.js";
 import type { Lease } from "./context.js";
 export declare const RUN_TOKEN_TYP = "nylorun-run+jwt";
 export declare const RUN_TOKEN_AUD = "nylorun-gates";
-/** How long a run token lives. */
-export declare const RUN_TOKEN_TTL_SECONDS: number;
-/** The lease heartbeat re-mints a token with less than this left. */
-export declare const RUN_TOKEN_RENEW_SECONDS: number;
 /** What a verified run token says: one lease of one session's turn. */
 export interface RunClaims {
     readonly tenantId: string;

package/dist/tenant/run-token.js

@@ -6,7 +6,7 @@
  *
  * Signed by the keys service with the Tenant's current signing key, like capability links,
  * and told apart from them by `typ` and `aud`. Internal: not in `openapi.json`. A token lives
- * `RUN_TOKEN_TTL_SECONDS`, no longer than `TOKEN_TTL_MAX_SECONDS`, so a key rotation never
+ * `keys.runTokenTtlSeconds` (Host tuning), no longer than `keys.tokenTtlMaxSeconds`, so a key rotation never
  * revokes a live one (`signing-keys.ts`).
  *
  * ```text
@@ -18,15 +18,10 @@
 import { randomUUID } from "node:crypto";
 import { errors, importJWK, jwtVerify } from "jose";
 import { tenantTokenIssuer } from "@nylorun/core/contracts";
-import { CLOCK_TOLERANCE_SECONDS, tokenKeyId } from "./jwt.js";
+import { clockToleranceSeconds, tokenKeyId } from "./jwt.js";
+import { hostTuning } from "../tuning.js";
 export const RUN_TOKEN_TYP = "nylorun-run+jwt";
 export const RUN_TOKEN_AUD = "nylorun-gates";
-/** How long a run token lives. */
-export const RUN_TOKEN_TTL_SECONDS = 15 * 60;
-/** The lease heartbeat re-mints a token with less than this left. */
-export const RUN_TOKEN_RENEW_SECONDS = 5 * 60;
-/** Allowed spread between `iat` and `exp` beyond the lifetime. */
-const LIFETIME_SLACK_SECONDS = 60;
 /**
  * Mints the run token of `lease` over `session`'s active turn. Throws when the session has
  * no active turn: there is no run to name.
@@ -37,7 +32,7 @@ export async function mintRunToken(signer, lease, session) {
         throw new Error(`Session ${lease.sessionId} has no active turn to mint a run token for`);
     const tenantId = signer.config.tenantId;
     const iat = Math.floor(Date.now() / 1000);
-    const exp = iat + RUN_TOKEN_TTL_SECONDS;
+    const exp = iat + hostTuning().keys.runTokenTtlSeconds;
     // Signed by the keys service (F4.2): this process never holds the private key.
     const { token } = await signer.keys.sign({
         typ: RUN_TOKEN_TYP,
@@ -92,7 +87,7 @@ export async function verifyRunToken(store, tenantId, raw, cache = new Map()) {
             issuer: tenantTokenIssuer(tenantId),
             audience: RUN_TOKEN_AUD,
             typ: RUN_TOKEN_TYP,
-            clockTolerance: CLOCK_TOLERANCE_SECONDS,
+            clockTolerance: clockToleranceSeconds(),
             requiredClaims: ["sub", "iat", "exp", "jti"],
         });
         payload = verified.payload;
@@ -112,7 +107,7 @@ export async function verifyRunToken(store, tenantId, raw, cache = new Map()) {
         typeof epc !== "number" ||
         !Number.isSafeInteger(epc) ||
         epc < 1 ||
-        exp - iat > RUN_TOKEN_TTL_SECONDS + LIFETIME_SLACK_SECONDS)
+        exp - iat > hostTuning().keys.runTokenTtlSeconds + hostTuning().keys.tokenLifetimeSlackSeconds)
         return refused("claims");
     return {
         ok: true,

package/dist/tenant/runtime-limits.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The Tenant's Runtime limits (harness boundary S0), stored as Tenant setting `limits.config`
+ * (`GET`/`PUT /v1/tenant/limits`): what one record entry, model call, model file, tool answer,
+ * custom harness state and Harness API chunk may hold. Unset limits take their defaults
+ * (`RUNTIME_LIMIT_DEFAULTS`); none may pass its ceiling (`runtimeLimitIssues`), which the route
+ * checks before it writes.
+ *
+ * Read from Postgres where a limit is checked, never kept: the Record seam, the store's event
+ * write, the gates and the segment's `turn.start` each read it in their own transaction.
+ */
+import { type RuntimeLimits, type TenantLimitsConfig } from "@nylorun/core/contracts";
+export declare const LIMITS_CONFIG_SETTING = "limits.config";
+interface SettingsReader {
+    getSetting(key: string): Promise<string | undefined>;
+}
+interface SettingsWriter extends SettingsReader {
+    putSetting(key: string, value: string): Promise<void>;
+}
+/** The Tenant's stored limits; a stored value that does not parse counts as none set. */
+export declare function readLimitsConfig(t: SettingsReader): Promise<TenantLimitsConfig>;
+/** The Runtime limits in force: the Tenant's, with the default for each it leaves out. */
+export declare function readRuntimeLimits(t: SettingsReader): Promise<RuntimeLimits>;
+export declare function writeLimitsConfig(t: SettingsWriter, config: TenantLimitsConfig): Promise<void>;
+export {};

package/dist/tenant/runtime-limits.js

@@ -0,0 +1,27 @@
+/**
+ * The Tenant's Runtime limits (harness boundary S0), stored as Tenant setting `limits.config`
+ * (`GET`/`PUT /v1/tenant/limits`): what one record entry, model call, model file, tool answer,
+ * custom harness state and Harness API chunk may hold. Unset limits take their defaults
+ * (`RUNTIME_LIMIT_DEFAULTS`); none may pass its ceiling (`runtimeLimitIssues`), which the route
+ * checks before it writes.
+ *
+ * Read from Postgres where a limit is checked, never kept: the Record seam, the store's event
+ * write, the gates and the segment's `turn.start` each read it in their own transaction.
+ */
+import { TenantLimitsConfigSchema, runtimeLimitsOf, } from "@nylorun/core/contracts";
+export const LIMITS_CONFIG_SETTING = "limits.config";
+/** The Tenant's stored limits; a stored value that does not parse counts as none set. */
+export async function readLimitsConfig(t) {
+    const raw = await t.getSetting(LIMITS_CONFIG_SETTING);
+    if (raw === undefined)
+        return {};
+    const parsed = TenantLimitsConfigSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : {};
+}
+/** The Runtime limits in force: the Tenant's, with the default for each it leaves out. */
+export async function readRuntimeLimits(t) {
+    return runtimeLimitsOf((await readLimitsConfig(t)).limits);
+}
+export async function writeLimitsConfig(t, config) {
+    await t.putSetting(LIMITS_CONFIG_SETTING, JSON.stringify(TenantLimitsConfigSchema.parse(config)));
+}