@nylorun/runtime 0.24.0-beta → 0.26.0-beta

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

@@ -169,6 +169,34 @@
       "when": 1791730977999,
       "tag": "0023_artifact_pages",
       "breakpoints": true
+    },
+    {
+      "idx": 24,
+      "version": "7",
+      "when": 1791986741535,
+      "tag": "0024_flat_manifest",
+      "breakpoints": true
+    },
+    {
+      "idx": 25,
+      "version": "7",
+      "when": 1791993934444,
+      "tag": "0025_environment_manifests",
+      "breakpoints": true
+    },
+    {
+      "idx": 26,
+      "version": "7",
+      "when": 1791995791323,
+      "tag": "0026_environment_forks",
+      "breakpoints": true
+    },
+    {
+      "idx": 27,
+      "version": "7",
+      "when": 1791997067694,
+      "tag": "0027_environment_image_digest",
+      "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

@@ -61,10 +61,11 @@ function publicToolCall(body) {
         effectId: request.effectId,
         turnId: request.turnId,
         callId: typeof request.context?.callId === "string" ? request.context.callId : null,
-        capabilityId: request.capabilityId ?? null,
         toolName: request.toolName ?? null,
         kind: body.toolKind ?? null,
         server: body.server ?? null,
+        skill: body.skill ?? null,
+        plugin: body.plugin ?? null,
         status,
         // A row written before R5 counted no sends: it was sent once.
         attempts: body.attempts ?? 1,
@@ -332,7 +333,11 @@ export function createPostgresReadStore(source, tenantId) {
                     id: row.id,
                     kind: row.kind,
                     labels: row.labels,
-                    recipe: row.recipe,
+                    manifest: row.recipe,
+                    ...(row.manifestName === null ? {} : { manifestName: row.manifestName }),
+                    ...(row.manifestVersion === null ? {} : { manifestVersion: row.manifestVersion }),
+                    ...(row.manifestHash === null ? {} : { manifestHash: row.manifestHash }),
+                    ...(row.forkedFrom ? { forkedFrom: row.forkedFrom } : {}),
                     version: row.version,
                     appliedVersion: row.appliedVersion,
                     ownerUserId: row.ownerUserId,
@@ -353,6 +358,7 @@ export function createPostgresReadStore(source, tenantId) {
                                 volumeGeneration: row.volumeGen,
                                 hostEpoch: row.hostEpoch,
                                 ...(row.reason ? { reason: row.reason } : {}),
+                                ...(row.imageDigest ? { imageDigest: row.imageDigest } : {}),
                             },
                         }
                         : {}),

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

@@ -1307,6 +1307,25 @@ export declare const environments: import("drizzle-orm/pg-core").PgTableWithColu
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        imageDigest: import("drizzle-orm/pg-core").PgColumn<{
+            name: "imageDigest";
+            tableName: "environments";
+            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';
+        }>;
         diskOp: import("drizzle-orm/pg-core").PgColumn<{
             name: "diskOp";
             tableName: "environments";
@@ -1345,6 +1364,204 @@ export declare const environments: import("drizzle-orm/pg-core").PgTableWithColu
         }, {}, {
             pgColumnBuilderBrand: 'PgCustomColumnBuilderBrand';
         }>;
+        manifestName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "manifestName";
+            tableName: "environments";
+            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';
+        }>;
+        manifestVersion: import("drizzle-orm/pg-core").PgColumn<{
+            name: "manifestVersion";
+            tableName: "environments";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        manifestHash: import("drizzle-orm/pg-core").PgColumn<{
+            name: "manifestHash";
+            tableName: "environments";
+            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';
+        }>;
+        forkedFrom: import("drizzle-orm/pg-core").PgColumn<{
+            name: "forkedFrom";
+            tableName: "environments";
+            dataType: "custom";
+            columnType: "PgCustomColumn";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            pgColumnBuilderBrand: 'PgCustomColumnBuilderBrand';
+        }>;
+    };
+    dialect: 'pg';
+}>;
+/**
+ * An environment manifest's versions (D63): a named, versioned definition of a kind of
+ * Environment, saved like an agent. A version is written once and never changed; a save whose
+ * body hashes the same as the latest writes nothing.
+ */
+export declare const environmentManifests: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "environment_manifests";
+    schema: "nylorun";
+    columns: {
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "environment_manifests";
+            dataType: "custom";
+            columnType: "PgCustomColumn";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            pgColumnBuilderBrand: 'PgCustomColumnBuilderBrand';
+        }>;
+        version: import("drizzle-orm/pg-core").PgColumn<{
+            name: "version";
+            tableName: "environment_manifests";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        body: import("drizzle-orm/pg-core").PgColumn<{
+            name: "body";
+            tableName: "environment_manifests";
+            dataType: "custom";
+            columnType: "PgCustomColumn";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            pgColumnBuilderBrand: 'PgCustomColumnBuilderBrand';
+        }>;
+        hash: import("drizzle-orm/pg-core").PgColumn<{
+            name: "hash";
+            tableName: "environment_manifests";
+            dataType: "custom";
+            columnType: "PgCustomColumn";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            pgColumnBuilderBrand: 'PgCustomColumnBuilderBrand';
+        }>;
+        savedBy: import("drizzle-orm/pg-core").PgColumn<{
+            name: "savedBy";
+            tableName: "environment_manifests";
+            dataType: "custom";
+            columnType: "PgCustomColumn";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            pgColumnBuilderBrand: 'PgCustomColumnBuilderBrand';
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "createdAt";
+            tableName: "environment_manifests";
+            dataType: "custom";
+            columnType: "PgCustomColumn";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            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

@@ -165,14 +165,48 @@ export const environments = nylorun.table("environments", {
      * a join with another one means the volume was replaced (its files are gone), so `lost`.
      */
     volumeId: text(),
+    /** The workload image by digest, from the first ready pod on (Q14): later pods run it. */
+    imageDigest: textC(),
     /**
      * The disk lease (R2d step 3): `{ kind, version?, startedAt, until }` while a snapshot, a
      * restore or a seed copies the disk; turns are refused until it ends or `until` passes.
      */
     diskOp: jsonText(),
-    /** The disk version the next volume starts from: `{ artifactId, version }` (R2d step 3). */
+    /**
+     * The disk version the next volume starts from: `{ artifactId, version }` (R2d step 3). A
+     * fork onto other setup adds `setup: true` (Q17): once the version is written (`written`),
+     * the seed stays until the engine reports the setup done, and turns wait for both.
+     */
     diskSeed: jsonText(),
-}, (t) => [check("environments_kind_check", sql `${t.kind} IN ('virtual', 'pod', 'none')`)]);
+    /**
+     * The environment manifest it was made from and its version (D63): null for an Environment
+     * made from an inline manifest. Never changed after creation.
+     */
+    manifestName: textC(),
+    manifestVersion: integer(),
+    /** The hash of what it runs (`recipe`), from creation on. */
+    manifestHash: textC(),
+    /** The Environment it was forked from: `{ environment, disk }` (Q15). Never changed. */
+    forkedFrom: jsonText(),
+}, (t) => [
+    check("environments_kind_check", sql `${t.kind} IN ('virtual', 'pod', 'none')`),
+    index("environments_manifest").on(t.manifestName, t.manifestVersion),
+]);
+/**
+ * An environment manifest's versions (D63): a named, versioned definition of a kind of
+ * Environment, saved like an agent. A version is written once and never changed; a save whose
+ * body hashes the same as the latest writes nothing.
+ */
+export const environmentManifests = nylorun.table("environment_manifests", {
+    name: textC().notNull(),
+    version: integer().notNull(),
+    /** The manifest (`EnvironmentManifest`) as saved. */
+    body: jsonText().notNull(),
+    hash: textC().notNull(),
+    /** `{ actor }`: the subject the save acted for, else `application`. */
+    savedBy: jsonText().notNull(),
+    createdAt: textC().notNull(),
+}, (t) => [primaryKey({ name: "environment_manifests_pkey", columns: [t.name, t.version] })]);
 /**
  * A vault (D56): the host model's (`id = 'host'`), or one Environment's, created and deleted with
  * it (`environment_id`, unique, deleted with the Environment's row). No other vault exists.

package/dist/store/postgres/store.js

@@ -50,7 +50,7 @@
  */
 import { AsyncLocalStorage } from "node:async_hooks";
 import { randomUUID } from "node:crypto";
-import { and, count, eq, getTableColumns, gte, gt, inArray, isNotNull, isNull, lt, lte, ne, or, sql, } from "drizzle-orm";
+import { and, count, desc, eq, getTableColumns, gte, gt, inArray, isNotNull, isNull, lt, lte, ne, or, sql, } from "drizzle-orm";
 import { appendEnvironmentEvent, appendEvent } from "../../record/index.js";
 import { OwnershipLostError, PrincipalRoleConflict } from "../ownership.js";
 import { followControlSignals, pruneSignals, writeSignal } from "./control.js";
@@ -58,7 +58,7 @@ import { database, driverError } from "./db.js";
 import { expectedSchemaVersion, readSchemaVersion } from "./migrate.js";
 import { createPostgresRecordReader } from "./record.js";
 import { postgresEnvironmentRecordWriter, postgresRecordWriter } from "./record-writer.js";
-import { artifacts, artifactVersions, artifactContent, definitionFiles, definitionFileUses, commands, definitions, effects, links, modelBudgets, modelUsage, principals, sandboxes, environmentEvents, environments, sessionEvents, sessionLogHeads, sessions, toJson, toolCrossings, signingKeys, tenant, tenantSettings, vaultAudit, vaultCredentials, vaultIdempotency, vaults, sandboxSignals, wakes, } from "./schema.js";
+import { artifacts, artifactVersions, artifactContent, definitionFiles, definitionFileUses, commands, definitions, effects, links, modelBudgets, modelUsage, principals, sandboxes, environmentEvents, environments, environmentManifests, sessionEvents, sessionLogHeads, sessions, toJson, toolCrossings, signingKeys, tenant, tenantSettings, vaultAudit, vaultCredentials, vaultIdempotency, vaults, sandboxSignals, wakes, } from "./schema.js";
 export function createPostgresSessionStore(options) {
     return new PostgresSessionStore(options);
 }
@@ -255,6 +255,10 @@ function environmentOf(row) {
         updatedAt: row.updatedAt,
         ...(row.diskOp ? { diskOp: row.diskOp } : {}),
         ...(row.diskSeed ? { diskSeed: row.diskSeed } : {}),
+        ...(row.manifestName !== null ? { manifestName: row.manifestName } : {}),
+        ...(row.manifestVersion !== null ? { manifestVersion: row.manifestVersion } : {}),
+        ...(row.manifestHash !== null ? { manifestHash: row.manifestHash } : {}),
+        ...(row.forkedFrom ? { forkedFrom: row.forkedFrom } : {}),
         ...(row.k8sName !== null && row.desired !== null && row.observed !== null
             ? {
                 pod: {
@@ -271,11 +275,22 @@ function environmentOf(row) {
                     ...(row.reason !== null ? { reason: row.reason } : {}),
                     ...(row.retiring !== null ? { retiring: row.retiring } : {}),
                     ...(row.volumeId !== null ? { volumeId: row.volumeId } : {}),
+                    ...(row.imageDigest !== null ? { imageDigest: row.imageDigest } : {}),
                 },
             }
             : {}),
     };
 }
+function environmentManifestOf(row) {
+    return {
+        name: row.name,
+        version: row.version,
+        body: row.body,
+        hash: row.hash,
+        savedBy: row.savedBy,
+        createdAt: row.createdAt,
+    };
+}
 /** A pod patch as column values: ISO times become dates, `null` clears. */
 function podColumns(patch) {
     const date = (value) => value === undefined ? undefined : value === null ? null : new Date(value);
@@ -293,6 +308,7 @@ function podColumns(patch) {
         reason: patch.reason,
         retiring: patch.retiring,
         volumeId: patch.volumeId,
+        imageDigest: patch.imageDigest,
     };
     return Object.fromEntries(Object.entries(columns).filter(([, value]) => value !== undefined));
 }
@@ -638,12 +654,16 @@ class PostgresTx {
         const [counted] = await this.db.select({ n: count() }).from(environments);
         if ((counted?.n ?? 0) >= limit)
             return "limit";
-        const { pod, ownerUserId, diskOp, diskSeed, ...environment } = row;
+        const { pod, ownerUserId, diskOp, diskSeed, manifestName, manifestVersion, manifestHash, forkedFrom, ...environment } = row;
         await this.db.insert(environments).values({
             ...environment,
             ownerUserId: ownerUserId ?? null,
             diskOp: diskOp ?? null,
             diskSeed: diskSeed ?? null,
+            manifestName: manifestName ?? null,
+            manifestVersion: manifestVersion ?? null,
+            manifestHash: manifestHash ?? null,
+            forkedFrom: forkedFrom ?? null,
             ...(pod ? podColumns(pod) : {}),
         });
         return "created";
@@ -680,6 +700,61 @@ class PostgresTx {
             .orderBy(environments.id);
         return rows.map(environmentOf);
     }
+    // --- Environment manifests (D63) -----------------------------------------------
+    async lockEnvironmentManifest(name) {
+        this.check();
+        await this.db.execute(sql `SELECT pg_advisory_xact_lock(hashtext(${`nylorun.environment_manifests:${name}`}))`);
+    }
+    async environmentManifest(name, version) {
+        this.check();
+        const [row] = await this.db
+            .select()
+            .from(environmentManifests)
+            .where(version === undefined
+            ? eq(environmentManifests.name, name)
+            : and(eq(environmentManifests.name, name), eq(environmentManifests.version, version)))
+            .orderBy(desc(environmentManifests.version))
+            .limit(1);
+        return row && environmentManifestOf(row);
+    }
+    async insertEnvironmentManifest(row) {
+        this.check();
+        await this.db.insert(environmentManifests).values(row);
+    }
+    async listEnvironmentManifests() {
+        this.check();
+        const rows = await this.db
+            .selectDistinctOn([environmentManifests.name])
+            .from(environmentManifests)
+            .orderBy(environmentManifests.name, desc(environmentManifests.version));
+        return rows.map(environmentManifestOf);
+    }
+    async environmentManifestVersions(name) {
+        this.check();
+        const rows = await this.db
+            .select()
+            .from(environmentManifests)
+            .where(eq(environmentManifests.name, name))
+            .orderBy(desc(environmentManifests.version));
+        return rows.map(environmentManifestOf);
+    }
+    async deleteEnvironmentManifest(name) {
+        this.check();
+        const deleted = await this.db
+            .delete(environmentManifests)
+            .where(eq(environmentManifests.name, name))
+            .returning({ version: environmentManifests.version });
+        return deleted.length;
+    }
+    async environmentsOfManifest(name) {
+        this.check();
+        const rows = await this.db
+            .select({ version: environments.manifestVersion, n: count() })
+            .from(environments)
+            .where(eq(environments.manifestName, name))
+            .groupBy(environments.manifestVersion);
+        return new Map(rows.filter((row) => row.version !== null).map((row) => [row.version, row.n]));
+    }
     async sessionsOnEnvironment(environmentId) {
         this.check();
         const rows = await this.sessions()
@@ -702,7 +777,7 @@ class PostgresTx {
         const rows = await this.db
             .select({ body: environmentEvents.body })
             .from(environmentEvents)
-            .where(and(eq(environmentEvents.environmentId, environmentId), options.fromSeq === undefined ? undefined : gte(environmentEvents.seq, options.fromSeq)))
+            .where(and(eq(environmentEvents.environmentId, environmentId), options.fromSeq === undefined ? undefined : gte(environmentEvents.seq, options.fromSeq), options.types === undefined ? undefined : inArray(environmentEvents.type, [...options.types]), options.since === undefined ? undefined : gte(environmentEvents.committedAt, options.since), options.until === undefined ? undefined : lt(environmentEvents.committedAt, options.until)))
             .orderBy(environmentEvents.seq)
             .limit(options.limit ?? 1000);
         return rows.map((row) => row.body);

package/dist/store/types.d.ts

@@ -63,7 +63,7 @@
 import type { KeyRole } from "@nylorun/core/compatibility";
 import type { RecordReader } from "../streams/relay/types.js";
 import type { SandboxSignal, Wake } from "../execution/types.js";
-import type { EventPayload, EventType, EventWriter, LiveEvent, EnvironmentEvent, EnvironmentEventPayload, EnvironmentEventType, EnvironmentKind, EnvironmentRecipe, PodDesired, PodObserved, SessionEventOf } from "@nylorun/core/contracts";
+import type { EventPayload, EventType, EventWriter, LiveEvent, EnvironmentEvent, EnvironmentEventPayload, EnvironmentEventType, EnvironmentKind, EnvironmentManifest, EnvironmentRecipe, PodDesired, PodObserved, SessionEventOf } from "@nylorun/core/contracts";
 import type { HostEffect } from "@nylorun/harness/run";
 import type { ArtifactRow, ArtifactVersionRow, DefinitionFileRow, ModelBudgetRow, ModelUsageRow, ModelUsageWrite, PrincipalRow, ToolCrossingRow, SigningKeyRow, VaultAuditRow, VaultCredentialRow, VaultIdempotencyRow, VaultRow } from "./postgres/schema.js";
 /** Tables holding JSON documents keyed by `id`. */
@@ -148,12 +148,42 @@ export interface Environment {
     pod?: SandboxPodState;
     /** The disk lease while a snapshot, restore or seed copies the disk (R2d step 3). */
     diskOp?: DiskOperation;
-    /** The disk version the next volume starts from (R2d step 3). */
-    diskSeed?: {
-        artifactId: string;
-        version: number;
+    /**
+     * The disk version the next volume starts from (R2d step 3). `setup` (a fork onto other setup,
+     * Q17): the setup runs once the version is written (`written`), and the seed stays until it is done.
+     */
+    diskSeed?: DiskSeed;
+    /** The environment manifest it was made from and its version (D63); absent for an inline one. */
+    manifestName?: string;
+    manifestVersion?: number;
+    /** The hash of what it runs (`recipe`), recorded at creation (protocol 14). */
+    manifestHash?: string;
+    /** The Environment it was forked from and the disk version it started from (Q15). */
+    forkedFrom?: {
+        environment: string;
+        disk: number | null;
     };
 }
+/** A pending seed of an Environment's disk (`disk_seed`). */
+export interface DiskSeed {
+    artifactId: string;
+    version: number;
+    /** Run the setup on the seeded disk (a fork onto other setup, Q17). */
+    setup?: true;
+    /** The version is written; with `setup`, the seed waits for the setup to be done. */
+    written?: true;
+}
+/** One version of an environment manifest (`environment_manifests`, D63). */
+export interface EnvironmentManifestRow {
+    name: string;
+    version: number;
+    body: EnvironmentManifest;
+    hash: string;
+    savedBy: {
+        actor: string;
+    };
+    createdAt: string;
+}
 /** A disk lease (R2d step 3): what holds the disk, since when, and until when unless renewed. */
 export interface DiskOperation {
     kind: "snapshot" | "restore" | "seed";
@@ -188,6 +218,11 @@ export interface SandboxPodState {
     retiring?: string;
     /** The id the engine keeps on the volume, from the first join. */
     volumeId?: string;
+    /**
+     * The workload image by digest (`repo@sha256:…`), recorded the first time a pod of the
+     * Environment is ready (Q14): every later pod, after a stop, a relaunch or a reset, runs it.
+     */
+    imageDigest?: string;
 }
 /** A change to a pod's columns: `null` clears an optional one. */
 export type SandboxPodPatch = {
@@ -531,10 +566,7 @@ export interface Tx {
         ownerUserId?: string | null;
         lastUsedAt?: string;
         diskOp?: DiskOperation | null;
-        diskSeed?: {
-            artifactId: string;
-            version: number;
-        } | null;
+        diskSeed?: DiskSeed | null;
     }, updatedAt: string): Promise<void>;
     /** Changes a pod Environment's lifecycle columns (the caller holds the row's lock). */
     updateEnvironmentPod(id: string, patch: SandboxPodPatch, updatedAt: string): Promise<void>;
@@ -551,11 +583,25 @@ export interface Tx {
      * caller holds the Environment row's lock (or created the row in this transaction).
      */
     environmentEvent<T extends EnvironmentEventType>(environmentId: string, type: T, payload: EnvironmentEventPayload<T>): Promise<EnvironmentEvent>;
-    /** The Environment's lifecycle stream, from `fromSeq` on, at most `limit` events. */
-    environmentEvents(environmentId: string, options?: {
-        fromSeq?: number;
-        limit?: number;
-    }): Promise<EnvironmentEvent[]>;
+    /**
+     * The Environment's stream, from `fromSeq` on, at most `limit` events: only `types` when given,
+     * and only events recorded at or after `since` and before `until` (ISO times) when given.
+     */
+    environmentEvents(environmentId: string, options?: EnvironmentEventsQuery): Promise<EnvironmentEvent[]>;
+    /** Holds manifest `name`'s save lock until the transaction ends, so saves of one name are serial. */
+    lockEnvironmentManifest(name: string): Promise<void>;
+    /** Version `version` of manifest `name`, or its latest when `version` is omitted. */
+    environmentManifest(name: string, version?: number): Promise<EnvironmentManifestRow | undefined>;
+    /** Writes a new version (the caller holds the name's lock and chose the next number). */
+    insertEnvironmentManifest(row: EnvironmentManifestRow): Promise<void>;
+    /** Each manifest's latest version, by name. */
+    listEnvironmentManifests(): Promise<EnvironmentManifestRow[]>;
+    /** Every version of manifest `name`, newest first. */
+    environmentManifestVersions(name: string): Promise<EnvironmentManifestRow[]>;
+    /** Deletes every version of manifest `name`; how many there were. */
+    deleteEnvironmentManifest(name: string): Promise<number>;
+    /** How many Environments were made from each version of manifest `name` (deleting ones too). */
+    environmentsOfManifest(name: string): Promise<Map<number, number>>;
     /** `invoking` effects of one session; takeover turns them `uncertain`. */
     invokingEffects<T extends EffectDoc = EffectDoc>(sessionId: string): Promise<T[]>;
     effectsForSession<T extends EffectDoc = EffectDoc>(sessionId: string, filter?: SessionEffectFilter): Promise<T[]>;
@@ -746,3 +792,11 @@ export interface Tx {
      */
     reset(scope: ResetScope): Promise<void>;
 }
+/** Which of an Environment's events to read (`Tx.environmentEvents`). */
+export interface EnvironmentEventsQuery {
+    readonly fromSeq?: number;
+    readonly limit?: number;
+    readonly types?: readonly string[];
+    readonly since?: string;
+    readonly until?: string;
+}

package/dist/tenant/advance.js

@@ -313,6 +313,9 @@ async function runRemoteSegment(ctx, lease, started, controller, run, onTaken, p
         // Aborted before a harness took it: settled as an abort of the engine would be.
         if (end.kind === "aborted")
             throw signal.reason;
+        // The harness's own tools take names of this turn's tools (Harness API 3): the turn fails.
+        if (end.kind === "refused")
+            throw new Error(end.message);
         // Checked before the abort: whatever core's signal says, the run's effects are unaccounted for.
         if (end.kind === "released" && end.reason === "connection.lost")
             throw new RunLost();

package/dist/tenant/artifact-tool.d.ts

@@ -4,7 +4,7 @@ import type { HostEffect } from "@nylorun/harness/run";
 import { type TenantContext } from "./context.js";
 export { isReadArtifactCall, isSaveArtifactCall } from "../harness/calls.js";
 export declare function callSaveArtifact(ctx: TenantContext, request: HostEffect, signal: AbortSignal): Promise<SandboxToolOutcome>;
-/** What `read_artifact` returns: a page of a text artifact, or an image as a file. */
+/** What `read_artifact` returns: a page of a text artifact, or a file the model reads. */
 interface ReadOutcome {
     readonly kind: "completed";
     readonly output: Record<string, unknown>;