@nylorun/runtime 0.23.0-beta → 0.24.0-beta

package/dist/store/postgres/schema.js

@@ -69,14 +69,14 @@ export const sessions = nylorun.table("sessions", {
     ownerExpiresAt: timestamp({ withTimezone: true, mode: "date" }),
     /** The session owner (`ownerUserId`), not the lease column `owner`. */
     ownerUserId: field("->>'ownerUserId'"),
-    /** The sandbox resource the session is attached to (`sandbox: { id }`). */
-    sandboxId: field("->>'sandboxId'"),
+    /** The Environment the session names (`environment`, protocol 11). */
+    environmentId: field("->>'environmentId'"),
 }, (t) => [
     index("sessions_created").on(t.createdAt.desc().nullsLast(), t.id.desc().nullsFirst()),
     index("sessions_status").on(t.status, t.ownerExpiresAt),
     index("sessions_agent").on(t.agentId),
     index("sessions_owner_user").on(t.ownerUserId),
-    index("sessions_sandbox").on(t.sandboxId),
+    index("sessions_environment").on(t.environmentId),
 ]);
 export const commands = documents("commands");
 export const effects = nylorun.table("effects", {
@@ -107,22 +107,92 @@ export const principals = nylorun.table("principals", {
     idempotencyKey: text(),
     createdAt: text().notNull(),
 });
+/**
+ * An Environment (D55, protocol 11): its id, kind, labels, the recipe the app asked for and the
+ * recipe its compute runs (`applied`, copied from `recipe` when a stopped pod is asked to run),
+ * the owner guard, and when it was last used. Kind `pod` adds the pod's lifecycle columns.
+ * Sessions name it by id (the session body's `environmentId`). Not the `sandboxes` document
+ * table, which holds the virtual backend's compute records, keyed by workspace key.
+ */
+export const environments = nylorun.table("environments", {
+    id: textC().primaryKey(),
+    kind: text({ enum: ["virtual", "pod", "none"] }).notNull(),
+    /** `{ key: value }`, filtered through `nylorun.doc(labels)`. */
+    labels: jsonText().notNull(),
+    /** What the app asked for (`EnvironmentRecipe`), resolved against the Tenant's limits. */
+    recipe: jsonText().notNull(),
+    /** The recipe the current pod or workspace runs. */
+    applied: jsonText().notNull(),
+    version: integer().notNull().default(1),
+    appliedVersion: integer().notNull().default(1),
+    /** The owner guard: only this owner's sessions may name the Environment. */
+    ownerUserId: text(),
+    /** A turn's end, a recipe change, a secret write, a stop or a reset (`lifecycle.deleteAfter`). */
+    lastUsedAt: timestamp({ withTimezone: true, mode: "string" }).notNull().defaultNow(),
+    createdAt: textC().notNull(),
+    updatedAt: textC().notNull(),
+    // Kind `pod` (F7.2, D34): null otherwise. `tenant/environments.ts` and the `Sandbox`
+    // object's reconcile (`sandbox/pods/reconcile.ts`) are the only writers.
+    /** The agent-sandbox Sandbox's name, `sbx-<16 base32>-g<volume_gen>` (`podName`). */
+    k8sName: textC(),
+    /** Bumped by every reset: a new Sandbox on a new volume. */
+    volumeGen: integer().notNull().default(0),
+    /** `running`, `suspended` or `deleted`. */
+    desired: text({ enum: ["running", "suspended", "deleted"] }),
+    /** `creating`, `running`, `suspended`, `lost`, `failed` or `deleting`. */
+    observed: text({ enum: ["creating", "running", "suspended", "lost", "failed", "deleting"] }),
+    /** The UID of the pod that last joined. */
+    podUid: text(),
+    /**
+     * Bumped by every join (`host.join`), relaunch, loss and reset: host and egress tokens carry
+     * it (`epc`), and one of an older epoch is refused (egress-gate reads it too).
+     */
+    hostEpoch: integer().notNull().default(0),
+    /** sha256 (hex) of the incarnation's join token; the token itself is never stored. */
+    joinTokenHash: text(),
+    /** Bumped by every change the Runtime asks of the pod: the sandboxes service's `opId`. */
+    rev: integer().notNull().default(0),
+    /** When a turn last ended on it, for the idle timer. */
+    lastActiveAt: timestamp({ withTimezone: true }),
+    /** When the current incarnation was asked to run, for the ready deadline. */
+    startedAt: timestamp({ withTimezone: true }),
+    /** Why it failed or was lost. */
+    reason: text(),
+    /** An earlier incarnation's Sandbox still to delete (after a reset or a loss). */
+    retiring: textC(),
+    /**
+     * The id the engine keeps on the volume (`/harness/volume-id`), recorded at the first join:
+     * a join with another one means the volume was replaced (its files are gone), so `lost`.
+     */
+    volumeId: text(),
+    /**
+     * 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). */
+    diskSeed: jsonText(),
+}, (t) => [check("environments_kind_check", sql `${t.kind} IN ('virtual', 'pod', 'none')`)]);
+/**
+ * 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.
+ */
 export const vaults = nylorun.table("vaults", {
     id: textC().primaryKey(),
     name: text().notNull(),
-    ownerUserId: text().notNull(),
     /** JSON text, or null. */
     metadataJson: text(),
     createdAt: textC().notNull(),
-    /**
-     * `user`: one person's (owner `ownerUserId`); `installation`: the installation's own,
-     * attachable to any session (owner `installation`); `host`: the model vault, never attached.
-     */
-    scope: text({ enum: ["user", "installation", "host"] }).notNull().default("user"),
+    /** The Environment the vault belongs to; null only for the host vault. */
+    environmentId: textC(),
 }, (t) => [
-    index("vaults_owner").on(t.ownerUserId, t.createdAt, t.id),
-    uniqueIndex("vaults_one_host").on(t.scope).where(sql `scope = 'host'`),
-    check("vaults_scope_check", sql `scope IN ('user', 'installation', 'host')`),
+    uniqueIndex("vaults_environment").on(t.environmentId),
+    foreignKey({
+        name: "vaults_environment_id_fkey",
+        columns: [t.environmentId],
+        foreignColumns: [environments.id],
+    }).onDelete("cascade"),
+    check("vaults_owner_check", sql `(${t.id} = 'host') = (${t.environmentId} IS NULL)`),
 ]);
 /** A credential of a vault: its binding in the clear, its secret sealed. */
 export const vaultCredentials = nylorun.table("vault_credentials", {
@@ -146,6 +216,7 @@ export const vaultCredentials = nylorun.table("vault_credentials", {
         foreignColumns: [vaults.id],
     }).onDelete("cascade"),
     index("vault_credentials_vault").on(t.vaultId, t.createdAt, t.id),
+    uniqueIndex("vault_credentials_name").on(t.vaultId, t.name),
 ]);
 export const vaultAudit = nylorun.table("vault_audit", {
     ord: bigint({ mode: "number" }).primaryKey().generatedAlwaysAsIdentity(),
@@ -198,7 +269,9 @@ export const signingKeys = nylorun.table("signing_keys", {
  * The model usage ledger (P1.3): one row per model call a gate served, written after the call.
  * A second row for the same effect (a call the gate ran again after a gateway restart) is
  * flagged `duplicate`; both were billed. Budgets read their spend from it. Token counts are 0
- * when the provider sent none.
+ * when the provider sent none. `startedAt`, `endedAt` and `firstTokenMs` are the gate's own
+ * timing of the call (R7.1, migration 0022); null on rows written before, and `firstTokenMs`
+ * when the provider streamed nothing.
  */
 export const modelUsage = nylorun.table("model_usage", {
     id: textC().primaryKey(),
@@ -222,6 +295,12 @@ export const modelUsage = nylorun.table("model_usage", {
     /** True when an earlier row has the same `effectKey`: the provider billed the call twice. */
     duplicate: boolean().notNull(),
     createdAt: text().notNull(),
+    /** When the gate sent the call to the provider. */
+    startedAt: text(),
+    /** When the provider's answer was complete. */
+    endedAt: text(),
+    /** From `startedAt` to the provider's first stream event. */
+    firstTokenMs: integer(),
 }, (t) => [
     index("model_usage_session").on(t.sessionId, t.createdAt, t.id),
     index("model_usage_export").on(t.txid, t.id),
@@ -260,60 +339,6 @@ export const toolCrossings = nylorun.table("tool_crossings", {
     /** The gate's answer (`McpAnswer`), once the call ended; null while it runs or once lost. */
     answer: jsonText(),
 }, (t) => [index("tool_crossings_settled").on(t.settledAt)]);
-/**
- * A sandbox resource (blueprint D39, F7.1): its id, kind, the spec resolved against the
- * Tenant's limits when it was created, and the developer's labels. Sessions attach to it by id
- * (the session body's `sandboxId`). Not the `sandboxes` document table, which holds the virtual
- * backend's compute records, keyed by workspace key.
- */
-export const sandboxResources = nylorun.table("sandbox_resources", {
-    id: textC().primaryKey(),
-    kind: text({ enum: ["virtual", "pod"] }).notNull(),
-    /** The resolved `SandboxManifest`. */
-    spec: jsonText().notNull(),
-    /** `{ key: value }`, filtered through `nylorun.doc(labels)`. */
-    labels: jsonText().notNull(),
-    createdAt: textC().notNull(),
-    updatedAt: textC().notNull(),
-    // Kind `pod` (F7.2, D34): null for a virtual sandbox. `tenant/sandboxes.ts` and the
-    // `Sandbox` object's reconcile (`sandbox/pods/reconcile.ts`) are the only writers.
-    /** The agent-sandbox Sandbox's name, `sbx-<16 base32>-g<volume_gen>` (`podName`). */
-    k8sName: textC(),
-    /** Bumped by every reset: a new Sandbox on a new volume. */
-    volumeGen: integer().notNull().default(0),
-    /** `running`, `suspended` or `deleted`. */
-    desired: text({ enum: ["running", "suspended", "deleted"] }),
-    /** `creating`, `running`, `suspended`, `expired`, `lost`, `failed` or `deleting`. */
-    observed: text({
-        enum: ["creating", "running", "suspended", "expired", "lost", "failed", "deleting"],
-    }),
-    /** The UID of the pod that last joined. */
-    podUid: text(),
-    /**
-     * Bumped by every join (`host.join`), relaunch, loss and reset: host and egress tokens carry
-     * it (`epc`), and one of an older epoch is refused (egress-gate reads it too).
-     */
-    hostEpoch: integer().notNull().default(0),
-    /** sha256 (hex) of the incarnation's join token; the token itself is never stored. */
-    joinTokenHash: text(),
-    /** Bumped by every change the Runtime asks of the pod: the sandboxes service's `opId`. */
-    rev: integer().notNull().default(0),
-    /** When a turn last ended on it, for the idle timer. */
-    lastActiveAt: timestamp({ withTimezone: true }),
-    /** When its TTL passes (`createdAt + lifecycle.ttl`). */
-    expiresAt: timestamp({ withTimezone: true }),
-    /** When the current incarnation was asked to run, for the ready deadline. */
-    startedAt: timestamp({ withTimezone: true }),
-    /** Why it failed or was lost. */
-    reason: text(),
-    /** An earlier incarnation's Sandbox still to delete (after a reset or a loss). */
-    retiring: textC(),
-    /**
-     * The id the engine keeps on the volume (`/harness/volume-id`), recorded at the first join:
-     * a join with another one means the volume was replaced (its files are gone), so `lost`.
-     */
-    volumeId: text(),
-});
 /**
  * Artifacts (blueprint D35, F8.1 and F8.2): an id, a name and numbered versions. The bytes are in
  * the Object store under each version's `blobKey` (a folder's: its manifest); a blob counts only
@@ -331,8 +356,12 @@ export const artifacts = nylorun.table("artifacts", {
     labelsJson: text(),
     createdAt: textC().notNull(),
     updatedAt: text().notNull(),
+    /** The Environment whose disk versions this folder holds (R2d step 3); one per Environment. */
+    environmentId: textC(),
 }, (t) => [
     index("artifacts_session").on(t.sessionId, t.createdAt, t.id),
+    uniqueIndex("artifacts_environment_disk").on(t.environmentId).where(sql `environment_id IS NOT NULL`),
+    index("artifacts_creation_order").on(t.createdAt, t.id),
     check("artifacts_kind_check", sql `kind IN ('file', 'folder')`),
 ]);
 /** The versions of an artifact, immutable once written. */
@@ -344,7 +373,7 @@ export const artifactVersions = nylorun.table("artifact_versions", {
     size: bigint({ mode: "number" }).notNull(),
     sha256: text().notNull(),
     contentType: text().notNull(),
-    source: text({ enum: ["upload", "engine", "export"] }).notNull(),
+    source: text({ enum: ["upload", "engine", "export", "snapshot"] }).notNull(),
     createdAt: textC().notNull(),
 }, (t) => [
     primaryKey({ name: "artifact_versions_pkey", columns: [t.artifactId, t.version] }),
@@ -471,16 +500,16 @@ export const sandboxSignals = nylorun.table("sandbox_signals", {
 // ---------------------------------------------------------------------------
 // nylorun_streams: the record
 /**
- * Each sandbox's lifecycle stream (`nylorun.sandbox-event/1`), numbered from 0 per sandbox id.
- * Written only by the record module; not published to the stream relay.
+ * Each Environment's lifecycle stream (`nylorun.environment-event/1`), numbered from 0 per
+ * Environment id. Written only by the record module; not published to the stream relay.
  */
-export const sandboxEvents = nylorunStreams.table("sandbox_events", {
-    sandboxId: textC().notNull(),
+export const environmentEvents = nylorunStreams.table("environment_events", {
+    environmentId: textC().notNull(),
     seq: bigint({ mode: "number" }).notNull(),
     type: text().notNull(),
     body: jsonText().notNull(),
     committedAt: timestamp({ withTimezone: true, mode: "string" }).notNull().defaultNow(),
-}, (t) => [primaryKey({ name: "sandbox_events_pkey", columns: [t.sandboxId, t.seq] })]);
+}, (t) => [primaryKey({ name: "environment_events_pkey", columns: [t.environmentId, t.seq] })]);
 /** Each session's log head: the next seq and the basin generation its events go to. */
 export const sessionLogHeads = nylorunStreams.table("session_log_heads", {
     sessionId: textC().primaryKey(),

package/dist/store/postgres/store.js

@@ -32,7 +32,7 @@
  *    head).
  * 2. A transaction that touches several sessions locks them in ascending id
  *    order, with `lockSessions` (`./locking.ts`), before writing any of them.
- * 3. A sandbox resource's row (`sandboxResource(id, { lock: true })`, which orders its
+ * 3. An Environment's row (`environment(id, { lock: true })`, which orders its
  *    lifecycle stream) is locked after every session row the transaction locks, never
  *    before one.
  *
@@ -51,14 +51,14 @@
 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 { appendEvent, appendSandboxEvent } from "../../record/index.js";
+import { appendEnvironmentEvent, appendEvent } from "../../record/index.js";
 import { OwnershipLostError, PrincipalRoleConflict } from "../ownership.js";
 import { followControlSignals, pruneSignals, writeSignal } from "./control.js";
 import { database, driverError } from "./db.js";
 import { expectedSchemaVersion, readSchemaVersion } from "./migrate.js";
 import { createPostgresRecordReader } from "./record.js";
-import { postgresRecordWriter, postgresSandboxRecordWriter } from "./record-writer.js";
-import { artifacts, artifactVersions, artifactContent, definitionFiles, definitionFileUses, commands, definitions, effects, links, modelBudgets, modelUsage, principals, sandboxes, sandboxEvents, sandboxResources, sessionEvents, sessionLogHeads, sessions, toJson, toolCrossings, signingKeys, tenant, tenantSettings, vaultAudit, vaultCredentials, vaultIdempotency, vaults, sandboxSignals, wakes, } from "./schema.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";
 export function createPostgresSessionStore(options) {
     return new PostgresSessionStore(options);
 }
@@ -240,14 +240,21 @@ function ownership(row) {
         ownerExpiresAt: row.ownerExpiresAt?.toISOString() ?? null,
     };
 }
-function sandboxResourceOf(row) {
+function environmentOf(row) {
     return {
         id: row.id,
         kind: row.kind,
-        spec: row.spec,
         labels: row.labels,
+        recipe: row.recipe,
+        applied: row.applied,
+        version: row.version,
+        appliedVersion: row.appliedVersion,
+        ...(row.ownerUserId !== null ? { ownerUserId: row.ownerUserId } : {}),
+        lastUsedAt: new Date(row.lastUsedAt).toISOString(),
         createdAt: row.createdAt,
         updatedAt: row.updatedAt,
+        ...(row.diskOp ? { diskOp: row.diskOp } : {}),
+        ...(row.diskSeed ? { diskSeed: row.diskSeed } : {}),
         ...(row.k8sName !== null && row.desired !== null && row.observed !== null
             ? {
                 pod: {
@@ -260,7 +267,6 @@ function sandboxResourceOf(row) {
                     ...(row.joinTokenHash !== null ? { joinTokenHash: row.joinTokenHash } : {}),
                     rev: row.rev,
                     ...(row.lastActiveAt ? { lastActiveAt: row.lastActiveAt.toISOString() } : {}),
-                    ...(row.expiresAt ? { expiresAt: row.expiresAt.toISOString() } : {}),
                     ...(row.startedAt ? { startedAt: row.startedAt.toISOString() } : {}),
                     ...(row.reason !== null ? { reason: row.reason } : {}),
                     ...(row.retiring !== null ? { retiring: row.retiring } : {}),
@@ -283,7 +289,6 @@ function podColumns(patch) {
         joinTokenHash: patch.joinTokenHash,
         rev: patch.rev,
         lastActiveAt: date(patch.lastActiveAt),
-        expiresAt: date(patch.expiresAt),
         startedAt: date(patch.startedAt),
         reason: patch.reason,
         retiring: patch.retiring,
@@ -389,7 +394,7 @@ class PostgresTx {
         const [row] = await this.sessions().where(eq(sessions.id, id)).for("update");
         return row && storedSession(row);
     }
-    async event(sessionId, turnId, type, payload) {
+    async event(sessionId, turnId, type, payload, writer) {
         this.check();
         const db = this.db;
         // The session row lock orders the session's events; the log head allocates under it.
@@ -408,6 +413,7 @@ class PostgresTx {
             time: this.now(),
             type,
             payload,
+            ...(writer ? { writer } : {}),
         });
         this.events.push(event);
         this.generations.push(generation);
@@ -612,88 +618,92 @@ class PostgresTx {
         this.check();
         return this.bodies(sandboxes);
     }
-    // --- sandbox resources ---------------------------------------------------
-    async sandboxResource(id, options = {}) {
+    // --- Environments ----------------------------------------------------------
+    async environment(id, options = {}) {
         this.check();
-        const query = this.db.select().from(sandboxResources).where(eq(sandboxResources.id, id));
+        const query = this.db.select().from(environments).where(eq(environments.id, id));
         const [row] = options.lock ? await query.for("update") : await query;
-        return row && sandboxResourceOf(row);
+        return row && environmentOf(row);
     }
-    async createSandboxResource(row, limit) {
+    async createEnvironment(row, limit) {
         this.check();
         // Every create takes this lock, so two never both see room for one more.
-        await this.db.execute(sql `SELECT pg_advisory_xact_lock(hashtext('nylorun.sandbox_resources'))`);
+        await this.db.execute(sql `SELECT pg_advisory_xact_lock(hashtext('nylorun.environments'))`);
         const [found] = await this.db
-            .select({ id: sandboxResources.id })
-            .from(sandboxResources)
-            .where(eq(sandboxResources.id, row.id));
+            .select({ id: environments.id })
+            .from(environments)
+            .where(eq(environments.id, row.id));
         if (found)
             return "exists";
-        const [counted] = await this.db.select({ n: count() }).from(sandboxResources);
+        const [counted] = await this.db.select({ n: count() }).from(environments);
         if ((counted?.n ?? 0) >= limit)
             return "limit";
-        const { pod, ...resource } = row;
-        await this.db.insert(sandboxResources).values({ ...resource, ...(pod ? podColumns(pod) : {}) });
+        const { pod, ownerUserId, diskOp, diskSeed, ...environment } = row;
+        await this.db.insert(environments).values({
+            ...environment,
+            ownerUserId: ownerUserId ?? null,
+            diskOp: diskOp ?? null,
+            diskSeed: diskSeed ?? null,
+            ...(pod ? podColumns(pod) : {}),
+        });
         return "created";
     }
-    async updateSandboxSpec(id, spec, updatedAt) {
-        this.check();
-        await this.db.update(sandboxResources).set({ spec, updatedAt }).where(eq(sandboxResources.id, id));
-    }
-    async updateSandboxPod(id, patch, updatedAt) {
+    async updateEnvironment(id, patch, updatedAt) {
         this.check();
+        const columns = Object.fromEntries(Object.entries(patch).filter(([, value]) => value !== undefined));
         await this.db
-            .update(sandboxResources)
-            .set({ ...podColumns(patch), updatedAt })
-            .where(eq(sandboxResources.id, id));
+            .update(environments)
+            .set({ ...columns, updatedAt })
+            .where(eq(environments.id, id));
     }
-    async updateSandboxLabels(id, labels, updatedAt) {
+    async updateEnvironmentPod(id, patch, updatedAt) {
         this.check();
         await this.db
-            .update(sandboxResources)
-            .set({ labels, updatedAt })
-            .where(eq(sandboxResources.id, id));
+            .update(environments)
+            .set({ ...podColumns(patch), updatedAt })
+            .where(eq(environments.id, id));
     }
-    async deleteSandboxResource(id) {
+    async deleteEnvironment(id) {
         this.check();
-        await this.db.delete(sandboxResources).where(eq(sandboxResources.id, id));
+        // Its vault and credentials go with it (ON DELETE CASCADE).
+        await this.db.delete(environments).where(eq(environments.id, id));
     }
-    async listSandboxResources(filter = {}) {
+    async listEnvironments(filter = {}) {
         this.check();
         const labels = filter.labels;
         const rows = await this.db
             .select()
-            .from(sandboxResources)
+            .from(environments)
             .where(labels === undefined || Object.keys(labels).length === 0
             ? undefined
-            : sql `nylorun.doc(${sandboxResources.labels}) @> ${toJson(labels)}::jsonb`)
-            .orderBy(sandboxResources.id);
-        return rows.map(sandboxResourceOf);
+            : sql `nylorun.doc(${environments.labels}) @> ${toJson(labels)}::jsonb`)
+            .orderBy(environments.id);
+        return rows.map(environmentOf);
     }
-    async sessionsOnSandbox(sandboxId) {
+    async sessionsOnEnvironment(environmentId) {
         this.check();
         const rows = await this.sessions()
-            .where(eq(sessions.sandboxId, sandboxId))
+            .where(eq(sessions.environmentId, environmentId))
             .orderBy(sessions.id);
         return rows.map((row) => storedSession(row));
     }
-    async sandboxEvent(sandboxId, type, payload) {
+    async environmentEvent(environmentId, type, payload) {
         this.check();
-        return appendSandboxEvent(postgresSandboxRecordWriter(this.db), {
+        return appendEnvironmentEvent(postgresEnvironmentRecordWriter(this.db), {
             tenantId: this.tenantId,
-            sandboxId,
+            environmentId,
             time: this.now(),
             type,
             payload,
         });
     }
-    async sandboxEvents(sandboxId, options = {}) {
+    async environmentEvents(environmentId, options = {}) {
         this.check();
         const rows = await this.db
-            .select({ body: sandboxEvents.body })
-            .from(sandboxEvents)
-            .where(and(eq(sandboxEvents.sandboxId, sandboxId), options.fromSeq === undefined ? undefined : gte(sandboxEvents.seq, options.fromSeq)))
-            .orderBy(sandboxEvents.seq)
+            .select({ body: environmentEvents.body })
+            .from(environmentEvents)
+            .where(and(eq(environmentEvents.environmentId, environmentId), options.fromSeq === undefined ? undefined : gte(environmentEvents.seq, options.fromSeq)))
+            .orderBy(environmentEvents.seq)
             .limit(options.limit ?? 1000);
         return rows.map((row) => row.body);
     }
@@ -831,21 +841,13 @@ class PostgresTx {
         const [row] = await this.db.select().from(vaults).where(eq(vaults.id, id));
         return row;
     }
-    async vaultsByOwner(ownerUserId) {
-        this.check();
-        return this.db
-            .select()
-            .from(vaults)
-            .where(and(eq(vaults.ownerUserId, ownerUserId), eq(vaults.scope, "user")))
-            .orderBy(vaults.createdAt, vaults.id);
-    }
-    async installationVaults() {
+    async vaultOfEnvironment(environmentId) {
         this.check();
-        return this.db
+        const [row] = await this.db
             .select()
             .from(vaults)
-            .where(eq(vaults.scope, "installation"))
-            .orderBy(vaults.createdAt, vaults.id);
+            .where(eq(vaults.environmentId, environmentId));
+        return row;
     }
     async updateVaultMetadata(id, metadataJson) {
         this.check();
@@ -868,6 +870,14 @@ class PostgresTx {
             .where(eq(vaultCredentials.id, id));
         return row;
     }
+    async credentialByName(vaultId, name) {
+        this.check();
+        const [row] = await this.db
+            .select()
+            .from(vaultCredentials)
+            .where(and(eq(vaultCredentials.vaultId, vaultId), eq(vaultCredentials.name, name)));
+        return row;
+    }
     async credentialsForVault(vaultId, filter = {}) {
         this.check();
         return this.db
@@ -976,6 +986,16 @@ class PostgresTx {
             .returning();
         return inserted;
     }
+    async modelUsageOf(effectKey) {
+        this.check();
+        const [row] = await this.db
+            .select()
+            .from(modelUsage)
+            .where(and(eq(modelUsage.effectKey, effectKey), eq(modelUsage.duplicate, false)))
+            .orderBy(modelUsage.createdAt, modelUsage.id)
+            .limit(1);
+        return row;
+    }
     async modelUsageTotals(query) {
         this.check();
         const [row] = await this.db
@@ -1016,6 +1036,15 @@ class PostgresTx {
             .returning({ key: toolCrossings.key });
         return inserted.length === 1;
     }
+    async restartToolCrossing(row) {
+        this.check();
+        const restarted = await this.db
+            .update(toolCrossings)
+            .set({ startedAt: row.startedAt })
+            .where(and(eq(toolCrossings.key, row.key), eq(toolCrossings.hash, row.hash), isNull(toolCrossings.settledAt)))
+            .returning({ key: toolCrossings.key });
+        return restarted.length === 1;
+    }
     async settleToolCrossing(key, answer, settledAt) {
         this.check();
         await this.db
@@ -1038,6 +1067,12 @@ class PostgresTx {
         const [row] = options.lock ? await query.for("update") : await query;
         return row;
     }
+    async diskArtifact(environmentId, options = {}) {
+        this.check();
+        const query = this.db.select().from(artifacts).where(eq(artifacts.environmentId, environmentId));
+        const [row] = options.lock ? await query.for("update") : await query;
+        return row;
+    }
     async listArtifacts(filter = {}) {
         this.check();
         return this.db
@@ -1088,6 +1123,24 @@ class PostgresTx {
         await this.db.delete(artifacts).where(eq(artifacts.id, id));
         return deleted.map((row) => row.blobKey);
     }
+    async deleteArtifactVersion(artifactId, version) {
+        this.check();
+        const [deleted] = await this.db
+            .delete(artifactVersions)
+            .where(and(eq(artifactVersions.artifactId, artifactId), eq(artifactVersions.version, version)))
+            .returning({ blobKey: artifactVersions.blobKey });
+        if (!deleted)
+            return undefined;
+        const [left] = await this.db
+            .select({ latest: sql `max(${artifactVersions.version})` })
+            .from(artifactVersions)
+            .where(eq(artifactVersions.artifactId, artifactId));
+        await this.db
+            .update(artifacts)
+            .set({ latestVersion: Number(left?.latest ?? 0), updatedAt: new Date().toISOString() })
+            .where(eq(artifacts.id, artifactId));
+        return deleted.blobKey;
+    }
     async lockArtifactQuota() {
         this.check();
         await this.db.execute(sql `SELECT pg_advisory_xact_lock(hashtext('nylorun.artifacts'))`);
@@ -1228,10 +1281,11 @@ class PostgresTx {
                 basinGeneration: sql `${tenant.basinGeneration} + 1`,
             });
         }
-        if (scope === "sandboxes" || scope === "all") {
+        if (scope === "environments" || scope === "all") {
             await db.delete(sandboxes);
-            await db.delete(sandboxResources);
-            await db.delete(sandboxEvents);
+            // Their vaults and credentials go with them (ON DELETE CASCADE).
+            await db.delete(environments);
+            await db.delete(environmentEvents);
             await db.delete(sandboxSignals);
         }
         if (scope === "all") {
@@ -1241,7 +1295,6 @@ class PostgresTx {
             await db.delete(modelUsage);
             await db.delete(modelBudgets);
             await db.delete(artifacts);
-            await db.delete(vaults).where(ne(vaults.scope, "host"));
         }
     }
 }