@nylorun/runtime 0.25.0-beta → 0.27.0-beta

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,

package/dist/store/postgres/control.js

@@ -11,8 +11,8 @@
  *   exists exactly when what it announces committed.
  * - **Follow.** `followControlSignals` holds one connection of its own that LISTENs (a pooled
  *   connection cannot). Each notification reads back the signals of the last
- *   `WINDOW_SECONDS` and delivers those this follower has not delivered yet. So does a poll
- *   every `pollMs`, and every LISTEN after a reconnect: Postgres does not queue notifications
+ *   `postgres.controlWindowSeconds` (Host tuning) and delivers those this follower has not delivered yet. So does a poll
+ *   every `pollMs` (`postgres.controlPollMs`), and every LISTEN after a reconnect: Postgres does not queue notifications
  *   for a session that is not connected, and the rows are what catches up. Ids are never read
  *   as a cursor: they are allocated at insert and commit out of order, so a later id can be
  *   visible first.
@@ -23,14 +23,10 @@
  */
 import { gte, lt, sql } from "drizzle-orm";
 import { createPostgresListenClient } from "./connect.js";
+import { hostTuning } from "../../tuning.js";
 import { controlSignals } from "./schema.js";
 /** The channel every signal is notified on. */
 export const CONTROL_CHANNEL = "nylorun_control";
-/** How far back a read-back looks. Longer than the poll, so a missed notification is caught. */
-const WINDOW_SECONDS = 120;
-const POLL_MS = 5000;
-const RETRY_MIN_MS = 100;
-const RETRY_MAX_MS = 5000;
 const SIGNAL = {
     id: controlSignals.id,
     kind: controlSignals.kind,
@@ -69,7 +65,11 @@ export async function pruneSignals(db, before) {
  * start is fixed; the first LISTEN may still be retrying, and the poll covers it meanwhile.
  */
 export async function followControlSignals(source, db, onSignal, options = {}) {
-    const pollMs = options.pollMs ?? POLL_MS;
+    const tuning = hostTuning().postgres;
+    const pollMs = options.pollMs ?? tuning.controlPollMs;
+    // How far back a read-back looks: longer than the poll, so a missed notification is caught.
+    const windowSeconds = tuning.controlWindowSeconds;
+    const { minMs: retryMinMs, maxMs: retryMaxMs } = tuning.controlRetry;
     const onError = options.onError ?? (() => { });
     // Drizzle leaves timestamps to its column types, so a raw read of one is text.
     const [start] = await db.execute(sql `SELECT clock_timestamp()::text AS now`);
@@ -78,7 +78,7 @@ export async function followControlSignals(source, db, onSignal, options = {}) {
     const delivered = new Map();
     let stopped = false;
     let retry;
-    let delay = RETRY_MIN_MS;
+    let delay = retryMinMs;
     let draining;
     let again = false;
     const client = createPostgresListenClient(source, {
@@ -98,14 +98,14 @@ export async function followControlSignals(source, db, onSignal, options = {}) {
             void listen();
         }, delay);
         retry.unref();
-        delay = Math.min(delay * 2, RETRY_MAX_MS);
+        delay = Math.min(delay * 2, retryMaxMs);
     }
     async function listen() {
         if (stopped)
             return;
         try {
             await client.unsafe(`LISTEN ${CONTROL_CHANNEL}`);
-            delay = RETRY_MIN_MS;
+            delay = retryMinMs;
             drain();
         }
         catch (error) {
@@ -129,7 +129,7 @@ export async function followControlSignals(source, db, onSignal, options = {}) {
                     const rows = await db
                         .select(SIGNAL)
                         .from(controlSignals)
-                        .where(gte(controlSignals.createdAt, sql `greatest(${since}::timestamptz, clock_timestamp() - make_interval(secs => ${WINDOW_SECONDS}))`))
+                        .where(gte(controlSignals.createdAt, sql `greatest(${since}::timestamptz, clock_timestamp() - make_interval(secs => ${windowSeconds}))`))
                         .orderBy(controlSignals.id);
                     for (const row of rows)
                         deliver(row);
@@ -160,7 +160,7 @@ export async function followControlSignals(source, db, onSignal, options = {}) {
     }
     /** A row a read-back can still return is younger than the window: keep twice that. */
     function forgetOld() {
-        const before = Date.now() - 2 * WINDOW_SECONDS * 1000;
+        const before = Date.now() - 2 * windowSeconds * 1000;
         for (const [id, at] of delivered)
             if (at < before)
                 delivered.delete(id);

package/dist/store/postgres/drizzle/0028_artifact_write_keys.sql

@@ -0,0 +1,2 @@
+ALTER TABLE "nylorun"."artifact_versions" ADD COLUMN "write_key" text COLLATE "C";--> statement-breakpoint
+CREATE UNIQUE INDEX "artifact_versions_write_key" ON "nylorun"."artifact_versions" USING btree ("write_key") WHERE write_key IS NOT NULL;

package/dist/store/postgres/drizzle/0029_protocol_15.sql

@@ -0,0 +1,11 @@
+-- Protocol 15: the harness boundary. `read_artifact` and `save_artifact` are our harness's own
+-- tools, no longer the Runtime's: the manifest schema refuses a pinned `runtime` block that holds
+-- them. A fresh start for the sessions that pinned one (every agent session since protocol 12):
+-- each is closed (`session_closed`) and its history stays readable. Workflow sessions pin no
+-- `runtime` block and carry over.
+UPDATE "nylorun"."sessions" SET "body" = ("body"::jsonb || '{"closedReason":"protocol_15"}'::jsonb)::json
+WHERE nylorun.doc("body") ->> 'closedReason' IS NULL
+  AND jsonb_path_exists(
+    nylorun.doc("body") -> 'manifest' -> 'runtime' -> 'tools',
+    '$[*] ? (@.name == "read_artifact" || @.name == "save_artifact")'
+  );

package/dist/store/postgres/drizzle/0030_protocol_15_runtime_block.sql

@@ -0,0 +1,11 @@
+-- Protocol 15: the harness writes the model's instructions and defines the sandbox and skill
+-- tools, so the manifest schema refuses a pinned `runtime` block, and a session pins its
+-- definition as registered. A fresh start for the agent sessions that still pinned one (opened
+-- by a build of protocol 15 before this change, on the root agent or an agent it uses as a tool):
+-- each is closed (`session_closed`) and its history stays readable. The others carry over.
+UPDATE "nylorun"."sessions" SET "body" = ("body"::jsonb || '{"closedReason":"protocol_15"}'::jsonb)::json
+WHERE nylorun.doc("body") ->> 'closedReason' IS NULL
+  AND (
+    jsonb_path_exists(nylorun.doc("body") -> 'manifest', 'lax $.runtime')
+    OR jsonb_path_exists(nylorun.doc("body") -> 'manifest', 'lax $.tools[*].agent.runtime')
+  );

package/dist/store/postgres/drizzle/0031_protocol_15_mcp_snapshot.sql

@@ -0,0 +1,8 @@
+-- Protocol 15: the harness names a session's MCP tools and decides which to defer, so the
+-- session pins what its servers listed, raw (`snapshotSchemaVersion` 2), and every MCP call names
+-- its tool by `{server, tool}`. A session that pinned the former snapshot (model-facing names,
+-- deferral decided by core) cannot run its next turn: each still open is closed
+-- (`session_closed`) and its history stays readable. The others carry over.
+UPDATE "nylorun"."sessions" SET "body" = ("body"::jsonb || '{"closedReason":"protocol_15"}'::jsonb)::json
+WHERE nylorun.doc("body") ->> 'closedReason' IS NULL
+  AND nylorun.doc("body") -> 'mcpSnapshot' ->> 'snapshotSchemaVersion' = '1';

package/dist/store/postgres/drizzle/meta/_journal.json

@@ -197,6 +197,34 @@
       "when": 1791997067694,
       "tag": "0027_environment_image_digest",
       "breakpoints": true
+    },
+    {
+      "idx": 28,
+      "version": "7",
+      "when": 1792084466204,
+      "tag": "0028_artifact_write_keys",
+      "breakpoints": true
+    },
+    {
+      "idx": 29,
+      "version": "7",
+      "when": 1792086180701,
+      "tag": "0029_protocol_15",
+      "breakpoints": true
+    },
+    {
+      "idx": 30,
+      "version": "7",
+      "when": 1792091020175,
+      "tag": "0030_protocol_15_runtime_block",
+      "breakpoints": true
+    },
+    {
+      "idx": 31,
+      "version": "7",
+      "when": 1792094620175,
+      "tag": "0031_protocol_15_mcp_snapshot",
+      "breakpoints": true
     }
   ]
 }

package/dist/store/postgres/migrate.js

@@ -96,7 +96,7 @@ export async function assertCurrentLayout(q) {
     if (row?.versioned)
         throw openError("database-layout-old", "The database was created by a pre-release build of one Tenant per database, whose " +
             "migrations this release replaces. It is never changed: point the Runtime at a new " +
-            "database (locally, `nylorun reset` and then `nylorun start`).");
+            "database (locally, `nylorun local reset` and then `nylorun start`).");
 }
 /**
  * The database's schema version: the number of migrations its journal records, or undefined

package/dist/store/postgres/reads.js

@@ -4,12 +4,14 @@ import { and, asc, desc, eq, exists, gt, inArray, isNull, lt, ne, or, sql, } fro
 import { isArtifactId } from "@nylorun/core/compatibility";
 import { readCursor } from "../../reads/cursor.js";
 import { fail } from "../../tenant/http.js";
+import { limitsInForce, readTenantLimits } from "../../tenant/limits.js";
 import { artifactView } from "../../artifacts/service.js";
 import { sandboxWorkspaceKey } from "../../sandbox/records.js";
 import { database, driverError } from "./db.js";
 import { createPostgresReadClient } from "./connect.js";
+import { hostTuning } from "../../tuning.js";
 import { toolCallDuration, toolCallStatus } from "../../harness-api/tool-status.js";
-import { effects, artifacts, modelUsage, environments, sandboxes, sessions, sessionEvents, } from "./schema.js";
+import { effects, artifacts, modelUsage, environments, sandboxes, sessions, sessionEvents, tenantSettings, } from "./schema.js";
 const sessionFields = {
     id: sessions.id,
     agentId: sessions.agentId,
@@ -64,6 +66,7 @@ function publicToolCall(body) {
         toolName: request.toolName ?? null,
         kind: body.toolKind ?? null,
         server: body.server ?? null,
+        tool: body.tool ?? null,
         skill: body.skill ?? null,
         plugin: body.plugin ?? null,
         status,
@@ -118,7 +121,7 @@ export function createPostgresReadStore(source, tenantId) {
         return row.id;
     }
     return {
-        close: () => pool.end({ timeout: 2 }),
+        close: () => pool.end({ timeout: hostTuning().postgres.readCloseTimeoutSeconds }),
         artifacts: (filters, page, access) => read(async (tx) => {
             if (filters.sessionId !== undefined)
                 await requireSession(tx, filters.sessionId, access);
@@ -315,6 +318,10 @@ export function createPostgresReadStore(source, tenantId) {
                 .where(and(grants?.length === 0 ? sql `false` : allowed, key ? gt(environments.id, key[0]) : undefined, or(isNull(environments.desired), ne(environments.desired, "deleted")), ...Object.entries(labels).map(([k, v]) => sql `${environments.labels}::jsonb->>${k} = ${v}`)))
                 .orderBy(asc(environments.id))
                 .limit(page.limit + 1);
+            const tenantLimits = await readTenantLimits({
+                getSetting: async (setting) => (await tx.select({ value: tenantSettings.value }).from(tenantSettings).where(eq(tenantSettings.key, setting)))[0]
+                    ?.value,
+            });
             const items = [];
             for (const row of rows.slice(0, page.limit)) {
                 const [related] = await tx
@@ -337,6 +344,7 @@ export function createPostgresReadStore(source, tenantId) {
                     ...(row.manifestName === null ? {} : { manifestName: row.manifestName }),
                     ...(row.manifestVersion === null ? {} : { manifestVersion: row.manifestVersion }),
                     ...(row.manifestHash === null ? {} : { manifestHash: row.manifestHash }),
+                    limits: limitsInForce(tenantLimits, row.recipe.limits),
                     ...(row.forkedFrom ? { forkedFrom: row.forkedFrom } : {}),
                     version: row.version,
                     appliedVersion: row.appliedVersion,

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

@@ -3348,6 +3348,25 @@ export declare const artifactVersions: import("drizzle-orm/pg-core").PgTableWith
         }, {}, {
             pgColumnBuilderBrand: 'PgCustomColumnBuilderBrand';
         }>;
+        writeKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "writeKey";
+            tableName: "artifact_versions";
+            dataType: "custom";
+            columnType: "PgCustomColumn";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            pgColumnBuilderBrand: 'PgCustomColumnBuilderBrand';
+        }>;
     };
     dialect: 'pg';
 }>;

package/dist/store/postgres/schema.js

@@ -409,8 +409,15 @@ export const artifactVersions = nylorun.table("artifact_versions", {
     contentType: text().notNull(),
     source: text({ enum: ["upload", "engine", "export", "snapshot"] }).notNull(),
     createdAt: textC().notNull(),
+    /**
+     * The idempotency key of the harness write that stored the version (the artifact seam,
+     * protocol 15): the SHA-256 of its session and the harness's key, so a repeated write answers
+     * this version. Null for every other write.
+     */
+    writeKey: textC(),
 }, (t) => [
     primaryKey({ name: "artifact_versions_pkey", columns: [t.artifactId, t.version] }),
+    uniqueIndex("artifact_versions_write_key").on(t.writeKey).where(sql `write_key IS NOT NULL`),
     foreignKey({
         name: "artifact_versions_artifact_id_fkey",
         columns: [t.artifactId],