@nylorun/runtime 0.26.0-beta → 0.28.0-beta

package/dist/sandbox/setup.js

@@ -1,24 +1,51 @@
+/**
+ * Setup and input files (R2d step 2, Host feature `environment-setup`): what a pod Environment's
+ * engine runs and copies when its disk is made or reset, before it takes any turn. The plan is
+ * the applied recipe's `setup` and `files`, handed to the engine with its host token (the join
+ * answer, and `GET host/setup` while it waits to retry, or, on a fork onto other setup, for its
+ * disk version to be written: Q17); the engine keeps a marker on the volume
+ * (`/harness/setup.json`), so a resume never runs it again and a reset (a new volume) does.
+ *
+ * Input files come only through the routes here, indexed into the applied recipe's `files`:
+ * a pod reads the artifact versions and the definition files by hash (Q6) its own recipe names,
+ * and nothing else of the Object store.
+ *
+ * The plan's `setupHash` names its commands and files: the engine runs the setup again on a volume
+ * whose marker names another (a new version's setup, track T3).
+ *
+ * A failed command fails the pod (`observed: failed`, a reason that starts `setup:`, and
+ * `agent.failed` with the command, its exit code and the end of its output), or, on a start on
+ * a new version, takes the Agent back to the version it ran (`revertStart`, T3): the turn that
+ * waits for it fails with that reason (`podUnusable`, `tenant/advance.ts`), the failure stays
+ * until a turn start asks the pod to run again (`wantRunning`), and the engine, polling, runs the
+ * setup again then.
+ */
+import { ENVIRONMENT_SETUP_TIMEOUT_DEFAULT, } from "@nylorun/core/contracts";
+import { createHash } from "node:crypto";
 import { parseSandboxDuration } from "@nylorun/core/define";
+import { canonical } from "../store/canonical.js";
 import { contentKey, readManifest } from "../artifacts/folders.js";
-import { contentTypeFor } from "../artifacts/media-types.js";
+import { contentTypeFor } from "@nylorun/core/contracts";
 import { definitionFileKey } from "../tenant/definition-files.js";
 import { SETUP_FAILED } from "./pods/lifecycle.js";
+import { readRuntimeLimits } from "../tenant/runtime-limits.js";
+import { revertStart } from "../tenant/agent-versions.js";
 export { SETUP_FAILED };
-/** The most of a failed command's output kept in its event and reason. */
-const OUTPUT_TAIL = 4 * 1024;
-/** A command's timeout when the recipe gives none. */
-const DEFAULT_TIMEOUT_MS = 10 * 60_000;
 /** The setup of `recipe`, or undefined when it has neither commands nor files. */
 export async function setupPlanOf(ctx, t, environment) {
     const recipe = environment.applied;
     if (!recipe.setup?.length && !recipe.files?.length)
         return undefined;
+    // A command's own timeout, else the default, within the Tenant's `setupCommandMs` as it is now.
+    const { setupCommandMs } = await readRuntimeLimits(t);
+    const timeoutOf = (timeout) => Math.min(parseSandboxDuration(timeout ?? ENVIRONMENT_SETUP_TIMEOUT_DEFAULT), setupCommandMs);
     return {
         recipeVersion: environment.appliedVersion,
+        setupHash: createHash("sha256").update(canonical({ setup: recipe.setup ?? [], files: recipe.files ?? [] })).digest("hex"),
         commands: (recipe.setup ?? []).map((command) => ({
             command: command.command,
             cwd: command.cwd ?? "/workspace",
-            timeoutMs: (command.timeout && parseSandboxDuration(command.timeout)) || DEFAULT_TIMEOUT_MS,
+            timeoutMs: timeoutOf(command.timeout),
         })),
         files: (recipe.files ?? []).map((file, index) => ({ index, path: file.path })),
         environment: await ctx.vault.environmentVariables(t, environment.id),
@@ -32,7 +59,7 @@ export function parseSetupReport(value) {
         return undefined;
     const index = typeof report.index === "number" && Number.isInteger(report.index) ? report.index : undefined;
     const exitCode = typeof report.exitCode === "number" && Number.isInteger(report.exitCode) ? report.exitCode : undefined;
-    const output = typeof report.output === "string" ? report.output.slice(-OUTPUT_TAIL) : undefined;
+    const output = typeof report.output === "string" ? report.output : undefined;
     return {
         status: report.status,
         ...(index === undefined ? {} : { index }),
@@ -42,8 +69,10 @@ export function parseSetupReport(value) {
 }
 /**
  * Records a failed setup on Environment `id` held at host epoch `epoch` (the reporting engine's):
- * the pod is `failed` with a reason that starts `setup:`, and `environment.failed` says which
- * command failed and how. A report from an older host, or a success, changes nothing.
+ * the pod is `failed` with a reason that starts `setup:`, and `agent.failed` says which
+ * command failed and how, with the end of its output (the Tenant's `setupOutputChars`; the reason
+ * quotes `setupReasonChars` of it and `setupCommandExcerptChars` of the command). A report
+ * from an older host, or a success, changes nothing.
  */
 export async function recordSetup(ctx, id, epoch, report) {
     await ctx.store.tx(async (t) => {
@@ -57,19 +86,23 @@ export async function recordSetup(ctx, id, epoch, report) {
                 await t.updateEnvironment(id, { diskSeed: null }, new Date().toISOString());
             return;
         }
+        const { setupOutputChars, setupReasonChars, setupCommandExcerptChars } = await readRuntimeLimits(t);
+        const output = (report.output ?? "").slice(-setupOutputChars);
         const command = report.index === undefined ? undefined : environment.applied.setup?.[report.index];
-        const what = command === undefined ? "copying the input files failed" : `command ${report.index + 1} (${command.command.slice(0, 80)}) exited ${report.exitCode ?? "abnormally"}`;
-        const tail = (report.output ?? "").trim().slice(-500);
+        const what = command === undefined ? "copying the input files failed" : `command ${report.index + 1} (${command.command.slice(0, setupCommandExcerptChars)}) exited ${report.exitCode ?? "abnormally"}`;
+        const tail = output.trim().slice(-setupReasonChars);
         const reason = `${SETUP_FAILED} ${what}${tail ? `: ${tail}` : ""}`;
-        await t.updateEnvironmentPod(id, { observed: "failed", reason }, new Date().toISOString());
-        await t.environmentEvent(id, "environment.failed", {
+        await t.agentEvent(id, "agent.failed", {
             reason,
             setup: {
                 ...(report.index === undefined ? {} : { index: report.index }),
                 ...(report.exitCode === undefined ? {} : { exitCode: report.exitCode }),
-                output: report.output ?? "",
+                output,
             },
         });
+        // On a start on a new version (track T3), back to the version it ran; else failed.
+        if (!(await revertStart(t, environment, reason, new Date().toISOString())))
+            await t.updateEnvironmentPod(id, { observed: "failed", reason }, new Date().toISOString());
     });
     if (report.status === "failed")
         ctx.config.logger.warn("environment setup failed", { environmentId: id, index: report.index, exitCode: report.exitCode });

package/dist/sandbox/share.d.ts

@@ -1,7 +1,7 @@
 /**
  * A session's sandbox: the one of the Environment it names (protocol 11), whose id keys the
- * workspace, with the spec pinned when the session was opened (`Session.sandbox`). Definitions
- * no longer declare one (Sandboxes v3); `sandboxSpecOf` still reads a pinned manifest's.
+ * workspace, with the spec pinned when the session was opened (`Session.sandbox`, the one place
+ * it is kept since protocol 15). Definitions declare none (Sandboxes v3).
  */
 import { type AgentManifest, type SandboxManifest, type WorkflowManifest } from "@nylorun/core/define";
 export type SessionSandboxRef = {
@@ -13,23 +13,14 @@ export type SessionSandboxRef = {
     /** The Environment's sandbox spec, pinned when the session was opened. */
     readonly sandbox?: SandboxManifest;
 };
-/** The session's sandbox spec: the one pinned at open, else the one its definition declares. */
-export declare function sessionSandboxSpec(session: SessionSandboxRef): SandboxManifest | undefined;
-/** The sandbox spec of a pinned agent manifest (its `runtime` block) or a workflow manifest. */
-export declare function sandboxSpecOf(manifest: AgentManifest | WorkflowManifest | Record<string, unknown> | undefined): SandboxManifest | undefined;
+/** The session's sandbox spec, pinned when it was opened (or inherited from its tree's owner). */
+export declare function sessionSandboxSpec(session: Pick<SessionSandboxRef, "sandbox">): SandboxManifest | undefined;
 /**
  * Where a definition document declares a sandbox: a workflow's `sandbox`, and the agents embedded
  * in a flow agent. Definitions no longer declare one (Sandboxes v3), so registration refuses any
- * of these. An agent manifest cannot: its sandbox is in the `runtime` block, which the schema
- * refuses at registration.
+ * of these. An agent manifest has no field for one.
  */
 export declare function declaredSandboxes(manifest: unknown, into?: string[]): string[];
-/**
- * The agents of a definition document that set `runtime`: the document itself, the agents it
- * uses as tools and those embedded in a flow agent. Only the Runtime writes that block, when it
- * pins a session's manifest, so registration refuses any of these.
- */
-export declare function authoredRuntimeBlocks(manifest: unknown, into?: string[]): string[];
 /**
  * The workspace a session's sandbox tools run in: the session, whose log records the
  * workspace's events, and its Environment, whose id keys the workspace.

package/dist/sandbox/share.js

@@ -1,26 +1,17 @@
 /**
  * A session's sandbox: the one of the Environment it names (protocol 11), whose id keys the
- * workspace, with the spec pinned when the session was opened (`Session.sandbox`). Definitions
- * no longer declare one (Sandboxes v3); `sandboxSpecOf` still reads a pinned manifest's.
+ * workspace, with the spec pinned when the session was opened (`Session.sandbox`, the one place
+ * it is kept since protocol 15). Definitions declare none (Sandboxes v3).
  */
 import {} from "@nylorun/core/define";
-/** The session's sandbox spec: the one pinned at open, else the one its definition declares. */
+/** The session's sandbox spec, pinned when it was opened (or inherited from its tree's owner). */
 export function sessionSandboxSpec(session) {
-    return session.sandbox ?? sandboxSpecOf(session.manifest);
-}
-/** The sandbox spec of a pinned agent manifest (its `runtime` block) or a workflow manifest. */
-export function sandboxSpecOf(manifest) {
-    if (!manifest || typeof manifest !== "object")
-        return undefined;
-    if (manifest.kind === "workflow")
-        return manifest.sandbox;
-    return manifest.runtime?.sandbox;
+    return session.sandbox;
 }
 /**
  * Where a definition document declares a sandbox: a workflow's `sandbox`, and the agents embedded
  * in a flow agent. Definitions no longer declare one (Sandboxes v3), so registration refuses any
- * of these. An agent manifest cannot: its sandbox is in the `runtime` block, which the schema
- * refuses at registration.
+ * of these. An agent manifest has no field for one.
  */
 export function declaredSandboxes(manifest, into = []) {
     if (!manifest || typeof manifest !== "object")
@@ -37,26 +28,6 @@ export function declaredSandboxes(manifest, into = []) {
         declaredSandboxes(tool.agent, into);
     return into;
 }
-/**
- * The agents of a definition document that set `runtime`: the document itself, the agents it
- * uses as tools and those embedded in a flow agent. Only the Runtime writes that block, when it
- * pins a session's manifest, so registration refuses any of these.
- */
-export function authoredRuntimeBlocks(manifest, into = []) {
-    if (!manifest || typeof manifest !== "object")
-        return into;
-    const document = manifest;
-    if (document.kind === "workflow") {
-        for (const agent of Object.values(document.agents ?? {}))
-            authoredRuntimeBlocks(agent, into);
-        return into;
-    }
-    if (document.runtime !== undefined)
-        into.push(`'${document.id}'`);
-    for (const tool of document.tools ?? [])
-        authoredRuntimeBlocks(tool.agent, into);
-    return into;
-}
 /**
  * The workspace a session's sandbox tools run in: the session, whose log records the
  * workspace's events, and its Environment, whose id keys the workspace.

package/dist/sandbox/skills.d.ts

@@ -1,15 +1,9 @@
-import { type AgentManifest } from "@nylorun/core/define";
-import type { SandboxHandle } from "./types.js";
-/** A skill's files, by path in its folder, as `sha256:<hex>`. */
-export type SkillFiles = Readonly<Record<string, string>>;
+import type { SandboxFileBytes, SandboxHandle } from "./types.js";
+/** A folder's files, by path in it, as `sha256:<hex>`. */
+export type FolderFiles = Readonly<Record<string, string>>;
 /**
- * The skill versions of the agent and the agents it uses as tools, by folder
- * (`/skills/<name>@<hash>`): each distinct version once.
+ * Writes one folder's files to `root`, replacing a partial copy a failed mount left, and makes
+ * them read-only. `read` gives a file's bytes by `sha256:<hex>`, whole or as chunks, which are
+ * written as they come.
  */
-export declare function sandboxSkillsOf(manifest: AgentManifest | undefined, into?: Map<string, Readonly<Record<string, string>>>): Map<string, SkillFiles>;
-/**
- * Writes one skill version's files to its folder `root` (`/skills/<name>@<hash>`), replacing a
- * partial copy a failed mount left, and makes them read-only. `read` gives a file's bytes by
- * `sha256:<hex>`.
- */
-export declare function mountSkill(handle: SandboxHandle, root: string, files: SkillFiles, read: (sha256: string) => Promise<Uint8Array>, signal: AbortSignal): Promise<void>;
+export declare function mountFolderFiles(handle: SandboxHandle, root: string, files: FolderFiles, read: (sha256: string) => Promise<SandboxFileBytes>, signal: AbortSignal): Promise<void>;

package/dist/sandbox/skills.js

@@ -1,41 +1,26 @@
 /**
- * A sandbox's skills (track R2 M4, D66): each version of a skill of the session's agent, and of
- * the agents it uses as tools (they share its sandbox), gets its files in its own folder,
- * `/skills/<name>@<hash>/` (`skillFolderOf`), read-only, so the model can read them and run their
- * scripts with bash. A version's folder is written once and never replaced: sessions whose agents
- * carry different versions of one skill share an Environment, and run turns at once, without
- * changing each other's files. The SandboxManager mounts the folders a session needs before the
- * first call that needs them; the bytes come from the Tenant's definition files. Folders live
- * outside the persisted disk, so a stop clears them and the next open mounts what is in use.
+ * Folders a harness mounts in a sandbox (protocol 15): our engine's skill folders,
+ * `/skills/<name>@<hash>/` (`skillFolderOf`, track R2 M4, D66), each one version's files,
+ * read-only, so the model can read them and run their scripts with bash. Our engine decides which
+ * folders and when (before each sandbox call); the SandboxManager writes them once per open
+ * handle (`mountFolder`). A version's folder is written once and never replaced: sessions whose
+ * agents carry different versions of one skill share an Environment, and run turns at once,
+ * without changing each other's files. Folders live outside the persisted disk, so a stop clears
+ * them and the next call mounts them again.
  */
 import { posix } from "node:path";
-import { skillFolderOf } from "@nylorun/core/define";
-import { quote } from "./tools.js";
+import { helperCommandTimeoutMs, quote } from "./tools.js";
+import { hostTuning } from "../tuning.js";
 /**
- * The skill versions of the agent and the agents it uses as tools, by folder
- * (`/skills/<name>@<hash>`): each distinct version once.
+ * Writes one folder's files to `root`, replacing a partial copy a failed mount left, and makes
+ * them read-only. `read` gives a file's bytes by `sha256:<hex>`, whole or as chunks, which are
+ * written as they come.
  */
-export function sandboxSkillsOf(manifest, into = new Map()) {
-    for (const skill of Object.values(manifest?.skills ?? {})) {
-        const folder = skillFolderOf(skill);
-        if (!into.has(folder))
-            into.set(folder, skill.files);
-    }
-    for (const tool of manifest?.tools ?? [])
-        if (tool.agent !== undefined && !("kind" in tool.agent))
-            sandboxSkillsOf(tool.agent, into);
-    return into;
-}
-/**
- * Writes one skill version's files to its folder `root` (`/skills/<name>@<hash>`), replacing a
- * partial copy a failed mount left, and makes them read-only. `read` gives a file's bytes by
- * `sha256:<hex>`.
- */
-export async function mountSkill(handle, root, files, read, signal) {
+export async function mountFolderFiles(handle, root, files, read, signal) {
     const exec = async (command) => {
-        const result = await handle.exec({ command, cwd: "/", timeoutMs: 60_000 }, signal);
+        const result = await handle.exec({ command, cwd: "/", timeoutMs: helperCommandTimeoutMs() }, signal);
         if (result.exitCode !== 0)
-            throw new Error(`${command.slice(0, 120)} failed: ${result.stderr.trim() || `exit ${result.exitCode}`}`);
+            throw new Error(`${command.slice(0, hostTuning().harness.helperCommandExcerptChars)} failed: ${result.stderr.trim() || `exit ${result.exitCode}`}`);
     };
     const directories = new Set([root]);
     for (const path of Object.keys(files))

package/dist/sandbox/tenant-config.d.ts

@@ -4,13 +4,14 @@
  * fields take the defaults below.
  */
 import { type PlacementHost, type TenantEnvironmentsConfig } from "@nylorun/core/contracts";
+import { DEFAULT_SANDBOX_IDLE } from "./policy.js";
+export { DEFAULT_SANDBOX_IDLE };
 export declare const ENVIRONMENTS_CONFIG_SETTING = "environments.config";
 /** The Tenant's settings, as stored (`environments.config`). */
 export type TenantSandboxConfig = TenantEnvironmentsConfig;
 /** The most an Environment may ask for when the Tenant sets no maximum. */
 export declare const DEFAULT_MAX_CPUS = 4;
 export declare const DEFAULT_MAX_MEMORY_MIB = 8192;
-export declare const DEFAULT_SANDBOX_IDLE = "15m";
 /** The most Environments a Tenant holds when it sets no limit. */
 export declare const DEFAULT_MAX_ENVIRONMENTS = 100;
 export interface SandboxResourcesLimit {
@@ -47,4 +48,3 @@ export declare function effectiveSandboxConfig(config: TenantSandboxConfig): Eff
 /** The stored configuration, or `{}` when the Tenant has none. */
 export declare function readSandboxConfig(t: SettingsReader): Promise<TenantSandboxConfig>;
 export declare function writeSandboxConfig(t: SettingsWriter, config: TenantSandboxConfig): Promise<void>;
-export {};

package/dist/sandbox/tenant-config.js

@@ -5,17 +5,18 @@
  */
 import { TenantEnvironmentsConfigSchema, } from "@nylorun/core/contracts";
 import { parseSandboxSize } from "@nylorun/core/define";
-import { DEFAULT_SANDBOX_CPUS, DEFAULT_SANDBOX_MEMORY_MIB, DEV_PRESET_HOSTS, } from "./policy.js";
+import { DEFAULT_SANDBOX_CPUS, DEFAULT_SANDBOX_IDLE, DEFAULT_SANDBOX_MEMORY_MIB, DEV_PRESET_HOSTS, } from "./policy.js";
+import { hostTuning } from "../tuning.js";
+export { DEFAULT_SANDBOX_IDLE };
 export const ENVIRONMENTS_CONFIG_SETTING = "environments.config";
 /** The most an Environment may ask for when the Tenant sets no maximum. */
 export const DEFAULT_MAX_CPUS = 4;
 export const DEFAULT_MAX_MEMORY_MIB = 8192;
-export const DEFAULT_SANDBOX_IDLE = "15m";
 /** The most Environments a Tenant holds when it sets no limit. */
 export const DEFAULT_MAX_ENVIRONMENTS = 100;
 export function memoryMiB(value) {
     const bytes = parseSandboxSize(value);
-    return bytes === undefined ? 0 : Math.max(128, Math.ceil(bytes / 1024 ** 2));
+    return bytes === undefined ? 0 : Math.max(hostTuning().pods.memoryFloorMiB, Math.ceil(bytes / 1024 ** 2));
 }
 function resources(value, fallback) {
     return {

package/dist/sandbox/tools.d.ts

@@ -1,5 +1,6 @@
 import type { SandboxToolOutcome } from "@nylorun/core/contracts";
 import { type SandboxToolName } from "@nylorun/core/define";
+import { type SandboxToolLimits } from "@nylorun/harness";
 import type { SandboxHandle } from "./types.js";
 export type { SandboxToolOutcome };
 /** What the Runtime reports about a tool call on the session stream. */
@@ -9,6 +10,11 @@ export interface SandboxToolReport {
     readonly exitCode?: number;
     readonly killed?: boolean;
 }
+/**
+ * How long a command the Runtime runs for itself in a sandbox may take (making a file's folder,
+ * mounting a skill, a tool's own helper command): `harness.helperCommandTimeoutMs`.
+ */
+export declare const helperCommandTimeoutMs: () => number;
 export declare function quote(value: string): string;
 /**
  * An absolute path inside the sandbox. Relative paths are relative to the workspace; on a backend
@@ -20,6 +26,6 @@ export declare function truncateMiddle(value: string, limit?: number): {
     text: string;
     truncated: boolean;
 };
-export declare function runSandboxTool(handle: SandboxHandle, name: SandboxToolName, input: Record<string, any>, signal: AbortSignal, report: (value: SandboxToolReport) => void, 
+export declare function runSandboxTool(handle: SandboxHandle, name: SandboxToolName, input: Record<string, any>, signal: AbortSignal, report: (value: SandboxToolReport) => void, limits?: SandboxToolLimits, 
 /** Variables every command gets (R2c): secret names set to the sentinel, plain values. */
 environment?: Readonly<Record<string, string>>): Promise<SandboxToolOutcome>;

package/dist/sandbox/tools.js

@@ -1,16 +1,18 @@
 /**
- * The six built-in sandbox tools, implemented once over `SandboxHandle` so every backend behaves
- * the same. Expected problems are returned as failed outcomes; only infrastructure errors throw.
+ * The six sandbox operations, implemented once over `SandboxHandle` so every backend behaves the
+ * same, held to the harness's sandbox tool limits (`SandboxToolLimits`, the numbers its tools'
+ * schemas name). Expected problems are returned as failed outcomes; only infrastructure errors
+ * throw.
  */
 import { posix } from "node:path";
 import { SANDBOX_WORKSPACE } from "@nylorun/core/define";
-const OUTPUT_LIMIT = 30_000;
-const DEFAULT_TIMEOUT_S = 120;
-const DEFAULT_READ_LINES = 2000;
-const LINE_LIMIT = 2000;
-const DEFAULT_GREP_RESULTS = 200;
-const GLOB_LIMIT = 500;
-const GLOB_SCAN_LIMIT = 20_000;
+import { DEFAULT_SANDBOX_TOOL_LIMITS } from "@nylorun/harness";
+import { hostTuning } from "../tuning.js";
+/**
+ * How long a command the Runtime runs for itself in a sandbox may take (making a file's folder,
+ * mounting a skill, a tool's own helper command): `harness.helperCommandTimeoutMs`.
+ */
+export const helperCommandTimeoutMs = () => hostTuning().harness.helperCommandTimeoutMs;
 export function quote(value) {
     return `'${value.replaceAll("'", `'\\''`)}'`;
 }
@@ -24,7 +26,7 @@ export function resolveSandboxPath(path, workspace = SANDBOX_WORKSPACE) {
     return posix.normalize(path.startsWith("/") ? path : posix.join(workspace, path));
 }
 /** Keep the head and tail of long output so the model sees both the start and the error. */
-export function truncateMiddle(value, limit = OUTPUT_LIMIT) {
+export function truncateMiddle(value, limit = DEFAULT_SANDBOX_TOOL_LIMITS.outputChars) {
     if (value.length <= limit)
         return { text: value, truncated: false };
     const half = Math.floor(limit / 2);
@@ -39,20 +41,21 @@ const failed = (code, message) => ({
     code,
     message,
 });
-export async function runSandboxTool(handle, name, input, signal, report, 
+export async function runSandboxTool(handle, name, input, signal, report, limits = DEFAULT_SANDBOX_TOOL_LIMITS, 
 /** Variables every command gets (R2c): secret names set to the sentinel, plain values. */
 environment) {
+    const lineOf = (line) => (line.length > limits.lineChars ? `${line.slice(0, limits.lineChars)}…` : line);
     const workspace = handle.workspace ?? SANDBOX_WORKSPACE;
     const resolvePath = (path) => resolveSandboxPath(path, workspace);
-    const exec = (command, timeoutMs = 60_000) => handle.exec({ command, cwd: workspace, timeoutMs, ...(environment ? { env: environment } : {}) }, signal);
+    const exec = (command, timeoutMs = helperCommandTimeoutMs()) => handle.exec({ command, cwd: workspace, timeoutMs, ...(environment ? { env: environment } : {}) }, signal);
     switch (name) {
         case "bash": {
             const command = String(input.command);
-            const timeout = (input.timeout ?? DEFAULT_TIMEOUT_S) * 1000;
+            const timeout = Math.min(input.timeout ?? limits.defaultTimeoutS, limits.maxTimeoutS) * 1000;
             const result = await exec(command, timeout);
             report({ command, exitCode: result.exitCode, killed: result.killed });
-            const stdout = truncateMiddle(result.stdout);
-            const stderr = truncateMiddle(result.stderr);
+            const stdout = truncateMiddle(result.stdout, limits.outputChars);
+            const stderr = truncateMiddle(result.stderr, limits.outputChars);
             return {
                 kind: "completed",
                 output: {
@@ -76,14 +79,11 @@ environment) {
             if (lines.at(-1) === "")
                 lines.pop();
             const start = (input.offset ?? 1) - 1;
-            const limit = input.limit ?? DEFAULT_READ_LINES;
+            const limit = Math.min(input.limit ?? limits.readLines, limits.maxReadLines);
             const slice = lines.slice(start, start + limit);
             const width = String(start + slice.length).length;
             const text = slice
-                .map((line, index) => {
-                const clipped = line.length > LINE_LIMIT ? `${line.slice(0, LINE_LIMIT)}…` : line;
-                return `${String(start + index + 1).padStart(width, " ")}\t${clipped}`;
-            })
+                .map((line, index) => `${String(start + index + 1).padStart(width, " ")}\t${lineOf(line)}`)
                 .join("\n");
             const remaining = lines.length - (start + slice.length);
             return {
@@ -124,7 +124,7 @@ environment) {
             return { kind: "completed", output: { path, replacements: input.replace_all === true ? count : 1 } };
         }
         case "grep": {
-            const max = input.max_results ?? DEFAULT_GREP_RESULTS;
+            const max = Math.min(input.max_results ?? limits.grepResults, limits.maxGrepResults);
             const target = input.path ? String(input.path) : ".";
             const flags = ["-rnE", ...(input.ignore_case ? ["-i"] : [])];
             const include = input.glob ? ` --include=${quote(String(input.glob))}` : "";
@@ -137,7 +137,7 @@ environment) {
                 return result.stderr.trim()
                     ? failed("sandbox.grep_failed", result.stderr.trim())
                     : { kind: "completed", output: "No matches." };
-            const shown = lines.slice(0, max).map((line) => (line.length > LINE_LIMIT ? `${line.slice(0, LINE_LIMIT)}…` : line));
+            const shown = lines.slice(0, max).map(lineOf);
             return {
                 kind: "completed",
                 output: lines.length > max ? `${shown.join("\n")}\n… more matches omitted; narrow the search.` : shown.join("\n"),
@@ -146,7 +146,7 @@ environment) {
         case "glob": {
             const root = resolvePath(input.path ? String(input.path) : ".");
             const pattern = String(input.pattern);
-            const command = `find ${quote(root)} -type f -not -path '*/.git/*' 2>/dev/null | head -n ${GLOB_SCAN_LIMIT}`;
+            const command = `find ${quote(root)} -type f -not -path '*/.git/*' 2>/dev/null | head -n ${limits.globScan}`;
             report({ command });
             const result = await exec(command);
             const byBasename = !pattern.includes("/");
@@ -157,7 +157,7 @@ environment) {
                 const relative = posix.relative(root, file);
                 if (posix.matchesGlob(byBasename ? posix.basename(relative) : relative, pattern)) {
                     matches.push(file);
-                    if (matches.length > GLOB_LIMIT)
+                    if (matches.length > limits.globResults)
                         break;
                 }
             }
@@ -166,8 +166,8 @@ environment) {
             matches.sort();
             return {
                 kind: "completed",
-                output: matches.length > GLOB_LIMIT
-                    ? `${matches.slice(0, GLOB_LIMIT).join("\n")}\n… more files omitted; narrow the pattern.`
+                output: matches.length > limits.globResults
+                    ? `${matches.slice(0, limits.globResults).join("\n")}\n… more files omitted; narrow the pattern.`
                     : matches.join("\n"),
             };
         }

package/dist/sandbox/types.d.ts

@@ -51,6 +51,10 @@ export interface ExecResult {
     readonly killed: boolean;
     readonly timedOut: boolean;
 }
+/** A file's bytes: whole, or as chunks to write as they come. */
+export type SandboxFileBytes = Uint8Array | AsyncIterable<Uint8Array>;
+/** `content` whole, for a backend that writes a file at once. */
+export declare function wholeBytes(content: SandboxFileBytes): Promise<Uint8Array>;
 export interface SandboxHandle {
     /** The directory tools run in and resolve relative paths against. Default: `/workspace`. */
     readonly workspace?: string;
@@ -61,7 +65,7 @@ export interface SandboxHandle {
     readFile(path: string): Promise<string | undefined>;
     /**
      * The file's bytes, or undefined when it does not exist; refuses one larger than `maxBytes`
-     * (`SandboxFileTooLargeError`). For `save_artifact`, which keeps binary files intact.
+     * (`SandboxFileTooLargeError`). For `save_artifact` and the export, which keep binary files intact.
      */
     readBytes?(path: string, maxBytes: number): Promise<Uint8Array | undefined>;
     /**
@@ -70,8 +74,11 @@ export interface SandboxHandle {
      * directory. Stops after `maxEntries + 1` files (`truncated`). For the turn-end export (F8.2).
      */
     listFiles?(dir: string, maxEntries: number): Promise<SandboxListing | undefined>;
-    /** Text is written as UTF-8, bytes as they are. Parent directories must already exist. */
-    writeFile(path: string, content: string | Uint8Array): Promise<void>;
+    /**
+     * Text is written as UTF-8, bytes as they are, chunks as they come (a skill's file, which may
+     * be too large to hold at once). Parent directories must already exist.
+     */
+    writeFile(path: string, content: string | SandboxFileBytes): Promise<void>;
     /** Release compute; files persist. */
     stop(): Promise<void>;
     /**

package/dist/sandbox/types.js

@@ -1,3 +1,12 @@
+/** `content` whole, for a backend that writes a file at once. */
+export async function wholeBytes(content) {
+    if (content instanceof Uint8Array)
+        return content;
+    const chunks = [];
+    for await (const chunk of content)
+        chunks.push(chunk);
+    return Buffer.concat(chunks);
+}
 /** A sandbox file read with `readBytes` is larger than the caller allows. */
 export class SandboxFileTooLargeError extends Error {
     path;

package/dist/store/postgres/connect.d.ts

@@ -1,22 +1,23 @@
 import { type Sql } from "postgres";
 export type PostgresClient = Sql;
 export interface PostgresClientOptions {
-    /** Pool size. Default 10. */
+    /** Pool size. Default `postgres.poolSize` (Host tuning, 10). */
     max?: number;
-    /** Seconds before an idle connection closes. Default 30. */
+    /** Seconds before an idle connection closes. Default `postgres.idleTimeoutSeconds` (30). */
     idleTimeoutSeconds?: number;
-    /** Seconds to wait for a connection. Default 10. */
+    /** Seconds to wait for a connection. Default `postgres.connectTimeoutSeconds` (10). */
     connectTimeoutSeconds?: number;
     /** `application_name` on every connection. Default `nylorun-runtime`. */
     applicationName?: string;
     /**
      * `statement_timeout`: a statement running or waiting for a lock longer fails. Default
-     * 60 s; 0 turns it off. Migrations lift it (`lockMigrations` in `migrate.ts`).
+     * `postgres.statementTimeoutMs` (60 s); 0 turns it off. Migrations lift it (`lockMigrations` in `migrate.ts`).
      */
     statementTimeoutMs?: number;
     /**
      * `idle_in_transaction_session_timeout`: a transaction left idle this long is ended and its
-     * connection closed, releasing its locks. Default 60 s; 0 turns it off.
+     * connection closed, releasing its locks. Default `postgres.idleInTransactionTimeoutMs` (60 s); 0
+     * turns it off.
      */
     idleInTransactionTimeoutMs?: number;
 }

package/dist/store/postgres/connect.js

@@ -1,4 +1,5 @@
 import postgres, {} from "postgres";
+import { hostTuning } from "../../tuning.js";
 /**
  * Opens a connection pool on the Tenant's database, for its Session Store and the Tenant
  * bootstrap (`tenant.ts`). Stores never end it, so the caller calls `client.end()` at
@@ -13,15 +14,16 @@ import postgres, {} from "postgres";
  * not hold a connection forever: both are bounded by default.
  */
 export function createPostgresClient(url, options = {}) {
+    const tuning = hostTuning().postgres;
     return postgres(url, {
-        max: options.max ?? 10,
-        idle_timeout: options.idleTimeoutSeconds ?? 30,
-        connect_timeout: options.connectTimeoutSeconds ?? 10,
+        max: options.max ?? tuning.poolSize,
+        idle_timeout: options.idleTimeoutSeconds ?? tuning.idleTimeoutSeconds,
+        connect_timeout: options.connectTimeoutSeconds ?? tuning.connectTimeoutSeconds,
         onnotice: () => { },
         connection: {
             application_name: options.applicationName ?? "nylorun-runtime",
-            statement_timeout: options.statementTimeoutMs ?? 60_000,
-            idle_in_transaction_session_timeout: options.idleInTransactionTimeoutMs ?? 60_000,
+            statement_timeout: options.statementTimeoutMs ?? tuning.statementTimeoutMs,
+            idle_in_transaction_session_timeout: options.idleInTransactionTimeoutMs ?? tuning.idleInTransactionTimeoutMs,
         },
     });
 }
@@ -58,17 +60,18 @@ function connectionOf(source) {
 }
 /** Separate, bounded pool for read projections; inherits the Tenant connection credentials. */
 export function createPostgresReadClient(source) {
+    const tuning = hostTuning().postgres;
     const options = {
         ...connectionOf(source),
-        max: 4,
-        idle_timeout: 30,
-        connect_timeout: 2,
+        max: tuning.readPoolSize,
+        idle_timeout: tuning.idleTimeoutSeconds,
+        connect_timeout: tuning.readConnectTimeoutSeconds,
         onnotice() { },
         connection: {
             ...source.options.connection,
             application_name: "nylorun-reads",
-            statement_timeout: 2000,
-            idle_in_transaction_session_timeout: 2000,
+            statement_timeout: tuning.readStatementTimeoutMs,
+            idle_in_transaction_session_timeout: tuning.readStatementTimeoutMs,
             default_transaction_read_only: true,
         },
     };
@@ -87,7 +90,7 @@ export function createPostgresListenClient(source, handlers) {
         max: 1,
         idle_timeout: 0,
         max_lifetime: null,
-        connect_timeout: 10,
+        connect_timeout: hostTuning().postgres.connectTimeoutSeconds,
         fetch_types: false,
         onnotice() { },
         onnotify: handlers.onNotify,