@nylorun/runtime 0.23.0-beta → 0.24.0-beta

package/dist/sandbox/setup.js

@@ -0,0 +1,123 @@
+import { parseSandboxDuration } from "@nylorun/core/define";
+import { contentKey, readManifest } from "../artifacts/folders.js";
+import { SETUP_FAILED } from "./pods/lifecycle.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;
+    return {
+        recipeVersion: environment.appliedVersion,
+        commands: (recipe.setup ?? []).map((command) => ({
+            command: command.command,
+            cwd: command.cwd ?? "/workspace",
+            timeoutMs: (command.timeout && parseSandboxDuration(command.timeout)) || DEFAULT_TIMEOUT_MS,
+        })),
+        files: (recipe.files ?? []).map((file, index) => ({ index, path: file.path })),
+        environment: await ctx.vault.environmentVariables(t, environment.id),
+    };
+}
+export function parseSetupReport(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const report = value;
+    if (report.status !== "ok" && report.status !== "failed")
+        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;
+    return {
+        status: report.status,
+        ...(index === undefined ? {} : { index }),
+        ...(exitCode === undefined ? {} : { exitCode }),
+        ...(output === undefined ? {} : { output }),
+    };
+}
+/**
+ * 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.
+ */
+export async function recordSetup(ctx, id, epoch, report) {
+    await ctx.store.tx(async (t) => {
+        const environment = await t.environment(id, { lock: true });
+        const pod = environment?.pod;
+        if (!environment || !pod || pod.hostEpoch !== epoch || pod.desired !== "running")
+            return;
+        if (report.status === "ok")
+            return;
+        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 reason = `${SETUP_FAILED} ${what}${tail ? `: ${tail}` : ""}`;
+        await t.updateEnvironmentPod(id, { observed: "failed", reason }, new Date().toISOString());
+        await t.environmentEvent(id, "environment.failed", {
+            reason,
+            setup: {
+                ...(report.index === undefined ? {} : { index: report.index }),
+                ...(report.exitCode === undefined ? {} : { exitCode: report.exitCode }),
+                output: report.output ?? "",
+            },
+        });
+    });
+    if (report.status === "failed")
+        ctx.config.logger.warn("environment setup failed", { environmentId: id, index: report.index, exitCode: report.exitCode });
+    else
+        ctx.config.logger.info("environment setup done", { environmentId: id });
+}
+/** Whether the engine of `id` should run its setup again: the pod is no longer `failed`. */
+export async function setupState(ctx, id) {
+    return ctx.store.tx(async (t) => {
+        const environment = await t.environment(id);
+        const pod = environment?.pod;
+        if (!environment || !pod)
+            return { retry: false };
+        if (pod.observed === "failed")
+            return { retry: false };
+        const setup = await setupPlanOf(ctx, t, environment);
+        return { retry: true, ...(setup ? { setup } : {}) };
+    });
+}
+/**
+ * Input file `index` of Environment `id`'s applied recipe: a file artifact's bytes, a folder's
+ * listing, or (with `path`) one of the folder's files. Undefined when there is no such file.
+ */
+export async function setupFile(ctx, id, index, path) {
+    const found = await ctx.store.tx(async (t) => {
+        const environment = await t.environment(id);
+        const file = environment?.applied.files?.[index];
+        if (!file)
+            return undefined;
+        const artifact = await t.artifact(file.artifactId);
+        if (!artifact || artifact.sessionId !== null)
+            return undefined;
+        const version = await t.artifactVersion(file.artifactId, file.version);
+        return version ? { artifact, version } : undefined;
+    });
+    if (!found)
+        return undefined;
+    if (found.artifact.kind === "file") {
+        if (path !== undefined)
+            return undefined;
+        const got = await ctx.blobs.get(found.version.blobKey);
+        return got ? { kind: "file", contentType: found.version.contentType ?? found.artifact.contentType, body: got.body } : undefined;
+    }
+    const manifest = await readManifest(ctx.blobs, found.version);
+    if (path === undefined)
+        return {
+            kind: "folder",
+            entries: manifest.entries
+                .filter((entry) => entry.type === undefined)
+                .map((entry) => ({ path: entry.path, size: entry.size })),
+        };
+    const entry = manifest.entries.find((item) => item.path === path && item.type === undefined);
+    if (!entry)
+        return undefined;
+    const got = await ctx.blobs.get(contentKey(entry.sha256));
+    return got ? { kind: "file", contentType: entry.contentType, body: got.body } : undefined;
+}

package/dist/sandbox/share.d.ts

@@ -1,19 +1,16 @@
 /**
- * Shared sandboxes: one sandbox per owning session, attached via PutSession.sandbox =
- * { session }; keys use the owner id. A sandbox is either declared by the definition (an agent
- * capability or a workflow's `sandbox`) or chosen when the session was opened and pinned on the
- * session record (`sandbox`).
+ * 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.
  */
 import { type AgentManifest, type CapabilityManifest, type SandboxManifest, type WorkflowManifest } from "@nylorun/core/define";
 export type SessionSandboxRef = {
     readonly id: string;
     readonly ownerUserId: string;
     readonly manifest: AgentManifest | WorkflowManifest | Record<string, unknown>;
-    /** Session whose id keys the sandbox. Absent means this session owns its own. */
-    readonly sandboxOwnerId?: string | null;
-    /** The sandbox resource the session is attached to; its id keys the workspace. */
-    readonly sandboxId?: string;
-    /** The sandbox chosen when the session was opened (or inherited from its owner), resolved. */
+    /** The Environment the session names; its id keys the workspace. */
+    readonly environmentId?: string;
+    /** 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. */
@@ -26,21 +23,14 @@ export declare function sandboxSpecOf(manifest: AgentManifest | WorkflowManifest
  * one (Sandboxes v3), so registration refuses any of these.
  */
 export declare function declaredSandboxes(manifest: unknown, into?: string[]): string[];
-export declare function sandboxSpecsEqual(a: SandboxManifest | undefined, b: SandboxManifest | undefined): boolean;
 /** Synthetic capability so SandboxManager.run can use a workflow (or shared) spec. */
 export declare function capabilityForSandbox(sandbox: SandboxManifest): CapabilityManifest;
 /**
- * Resolve the session id that keys the sandbox. Walks one hop via sandboxOwnerId;
- * cycles fall back to the starting session.
+ * 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.
  */
-export declare function owningSandboxSessionId(session: SessionSandboxRef, lookup: (id: string) => SessionSandboxRef | undefined): string;
-/**
- * The workspace a session's sandbox tools run in: the owning session (one hop through
- * `sandboxOwnerId`, whose log records the workspace's events) and, when that session is
- * attached to a sandbox resource, the resource's id, which keys the workspace.
- */
-export declare function sandboxWorkspaceOf(session: SessionSandboxRef, lookup: (id: string) => SessionSandboxRef | undefined): {
+export declare function sandboxWorkspaceOf(session: SessionSandboxRef): {
     readonly ownerId: string;
-    readonly sandboxId?: string;
+    readonly environmentId?: string;
 };
-export declare function sessionHasSandbox(session: SessionSandboxRef, lookup: (id: string) => SessionSandboxRef | undefined): boolean;
+export declare function sessionHasSandbox(session: SessionSandboxRef): boolean;

package/dist/sandbox/share.js

@@ -1,10 +1,9 @@
 /**
- * Shared sandboxes: one sandbox per owning session, attached via PutSession.sandbox =
- * { session }; keys use the owner id. A sandbox is either declared by the definition (an agent
- * capability or a workflow's `sandbox`) or chosen when the session was opened and pinned on the
- * session record (`sandbox`).
+ * 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.
  */
-import { canonical, } from "@nylorun/core/define";
+import {} from "@nylorun/core/define";
 /** The session's sandbox spec: the one pinned at open, else the one its definition declares. */
 export function sessionSandboxSpec(session) {
     return session.sandbox ?? sandboxSpecOf(session.manifest);
@@ -47,13 +46,6 @@ export function declaredSandboxes(manifest, into = []) {
     }
     return into;
 }
-export function sandboxSpecsEqual(a, b) {
-    if (a === undefined && b === undefined)
-        return true;
-    if (a === undefined || b === undefined)
-        return false;
-    return canonical(a) === canonical(b);
-}
 /** Synthetic capability so SandboxManager.run can use a workflow (or shared) spec. */
 export function capabilityForSandbox(sandbox) {
     return {
@@ -64,35 +56,14 @@ export function capabilityForSandbox(sandbox) {
     };
 }
 /**
- * Resolve the session id that keys the sandbox. Walks one hop via sandboxOwnerId;
- * cycles fall back to the starting session.
- */
-export function owningSandboxSessionId(session, lookup) {
-    const seen = new Set();
-    let current = session;
-    while (current) {
-        if (seen.has(current.id))
-            return session.id;
-        seen.add(current.id);
-        const ownerId = current.sandboxOwnerId;
-        if (!ownerId || ownerId === current.id)
-            return current.id;
-        current = lookup(ownerId);
-    }
-    return session.id;
-}
-/**
- * The workspace a session's sandbox tools run in: the owning session (one hop through
- * `sandboxOwnerId`, whose log records the workspace's events) and, when that session is
- * attached to a sandbox resource, the resource's id, which keys the workspace.
+ * 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.
  */
-export function sandboxWorkspaceOf(session, lookup) {
-    const ownerId = owningSandboxSessionId(session, lookup);
-    const owner = ownerId === session.id ? session : lookup(ownerId) ?? session;
-    return owner.sandboxId === undefined ? { ownerId } : { ownerId, sandboxId: owner.sandboxId };
+export function sandboxWorkspaceOf(session) {
+    return session.environmentId === undefined
+        ? { ownerId: session.id }
+        : { ownerId: session.id, environmentId: session.environmentId };
 }
-export function sessionHasSandbox(session, lookup) {
-    const ownerId = owningSandboxSessionId(session, lookup);
-    const owner = ownerId === session.id ? session : lookup(ownerId) ?? session;
-    return sessionSandboxSpec(owner) !== undefined || sessionSandboxSpec(session) !== undefined;
+export function sessionHasSandbox(session) {
+    return sessionSandboxSpec(session) !== undefined;
 }

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

@@ -1,41 +1,39 @@
 /**
- * A Tenant's sandbox configuration, stored as Tenant setting `sandbox.config`: the sandbox a
- * session gets when it names none, and the limits every session's sandbox must fit. Unset
+ * A Tenant's Environment settings, stored as Tenant setting `environments.config`: the limits
+ * every Environment's recipe must fit, the pods' stop grace and the harness placement. Unset
  * fields take the defaults below.
  */
-import { type SandboxInlineRequest, type SandboxPlacementHost, type TenantSandboxConfig } from "@nylorun/core/contracts";
-export declare const SANDBOX_CONFIG_SETTING = "sandbox.config";
-/** The most a session may ask for when the Tenant sets no maximum. */
+import { type PlacementHost, type TenantEnvironmentsConfig } from "@nylorun/core/contracts";
+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 sandbox resources a Tenant holds when it sets no limit. */
-export declare const DEFAULT_MAX_SANDBOXES = 100;
+/** The most Environments a Tenant holds when it sets no limit. */
+export declare const DEFAULT_MAX_ENVIRONMENTS = 100;
 export interface SandboxResourcesLimit {
     readonly cpus: number;
     readonly memoryMiB: number;
 }
 /** A configuration with every default applied. */
 export interface EffectiveSandboxConfig {
-    readonly default: "none" | "virtual" | SandboxInlineRequest;
     readonly limits: {
         readonly network: readonly string[];
         readonly resources: SandboxResourcesLimit;
         readonly defaultResources: SandboxResourcesLimit;
         readonly idle: string;
-        /** The most sandbox resources (`PUT /v1/sandboxes/{id}`) the Tenant may hold. */
-        readonly sandboxes: number;
-        /** Pods: the longest `lifecycle.ttl`. */
-        readonly ttl?: string;
+        /** The most Environments the Tenant may hold. */
+        readonly environments: number;
     };
     /** Pods (F7.2, D36). */
     readonly lifecycle: {
-        readonly onExpiry: "retain" | "delete";
         readonly stopGrace: string;
     };
     /** Where each harness may run (D38). */
     readonly placement: Readonly<Record<string, {
-        readonly hosts: readonly SandboxPlacementHost[];
+        readonly hosts: readonly PlacementHost[];
     }>>;
 }
 interface SettingsReader {

package/dist/sandbox/tenant-config.js

@@ -1,18 +1,18 @@
 /**
- * A Tenant's sandbox configuration, stored as Tenant setting `sandbox.config`: the sandbox a
- * session gets when it names none, and the limits every session's sandbox must fit. Unset
+ * A Tenant's Environment settings, stored as Tenant setting `environments.config`: the limits
+ * every Environment's recipe must fit, the pods' stop grace and the harness placement. Unset
  * fields take the defaults below.
  */
-import { TenantSandboxConfigSchema, } from "@nylorun/core/contracts";
+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";
-export const SANDBOX_CONFIG_SETTING = "sandbox.config";
-/** The most a session may ask for when the Tenant sets no maximum. */
+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 sandbox resources a Tenant holds when it sets no limit. */
-export const DEFAULT_MAX_SANDBOXES = 100;
+/** 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));
@@ -26,7 +26,6 @@ function resources(value, fallback) {
 export function effectiveSandboxConfig(config) {
     const limits = config.limits ?? {};
     return {
-        default: config.default ?? "none",
         limits: {
             network: limits.network ?? DEV_PRESET_HOSTS,
             resources: resources(limits.resources, {
@@ -38,23 +37,19 @@ export function effectiveSandboxConfig(config) {
                 memoryMiB: DEFAULT_SANDBOX_MEMORY_MIB,
             }),
             idle: limits.idle ?? DEFAULT_SANDBOX_IDLE,
-            sandboxes: limits.sandboxes ?? DEFAULT_MAX_SANDBOXES,
-            ...(limits.ttl === undefined ? {} : { ttl: limits.ttl }),
-        },
-        lifecycle: {
-            onExpiry: config.lifecycle?.onExpiry ?? "retain",
-            stopGrace: config.lifecycle?.stopGrace ?? "10s",
+            environments: limits.environments ?? DEFAULT_MAX_ENVIRONMENTS,
         },
+        lifecycle: { stopGrace: config.lifecycle?.stopGrace ?? "10s" },
         placement: config.placement ?? { "*": { hosts: ["harness-container", "sandbox"] } },
     };
 }
 /** The stored configuration, or `{}` when the Tenant has none. */
 export async function readSandboxConfig(t) {
-    const raw = await t.getSetting(SANDBOX_CONFIG_SETTING);
+    const raw = await t.getSetting(ENVIRONMENTS_CONFIG_SETTING);
     if (raw === undefined)
         return {};
-    return TenantSandboxConfigSchema.parse(JSON.parse(raw));
+    return TenantEnvironmentsConfigSchema.parse(JSON.parse(raw));
 }
 export async function writeSandboxConfig(t, config) {
-    await t.putSetting(SANDBOX_CONFIG_SETTING, JSON.stringify(config));
+    await t.putSetting(ENVIRONMENTS_CONFIG_SETTING, JSON.stringify(config));
 }

package/dist/sandbox/types.d.ts

@@ -32,6 +32,7 @@ export interface SandboxSpec {
     readonly memoryMiB: number;
     readonly network: ResolvedNetwork;
 }
+import type { DiskRoots } from "./disk-fs.js";
 export interface ExecRequest {
     readonly command: string;
     readonly cwd: string;
@@ -73,6 +74,11 @@ export interface SandboxHandle {
     writeFile(path: string, content: string | Uint8Array): Promise<void>;
     /** Release compute; files persist. */
     stop(): Promise<void>;
+    /**
+     * Where the disk's roots are, for disk versions (R2d step 3, `sandbox/disk-fs.ts`): the
+     * workspace, and in a pod the engine's `/harness`. Absent for a backend without a disk.
+     */
+    readonly diskRoots?: DiskRoots;
 }
 /** The files `listFiles` found: paths relative to the directory listed. */
 export interface SandboxListing {

package/dist/store/postgres/drizzle/0020_environments.sql

@@ -0,0 +1,63 @@
+-- Protocol 11: Environments (R2d), a fresh start (Q2). Sandbox resources and every vault but
+-- the host's are dropped, not mapped: which Environment a person's key belongs in is the app's
+-- mapping, and each seal binds its vault id. Sessions opened before protocol 11 are closed
+-- (Q12): their history stays readable and a new turn is refused (`session_closed`).
+CREATE TABLE "nylorun_streams"."environment_events" (
+	"environment_id" text COLLATE "C" NOT NULL,
+	"seq" bigint NOT NULL,
+	"type" text NOT NULL,
+	"body" json NOT NULL,
+	"committed_at" timestamp with time zone DEFAULT now() NOT NULL,
+	CONSTRAINT "environment_events_pkey" PRIMARY KEY("environment_id","seq")
+);
+--> statement-breakpoint
+CREATE TABLE "nylorun"."environments" (
+	"id" text COLLATE "C" PRIMARY KEY NOT NULL,
+	"kind" text NOT NULL,
+	"labels" json NOT NULL,
+	"recipe" json NOT NULL,
+	"applied" json NOT NULL,
+	"version" integer DEFAULT 1 NOT NULL,
+	"applied_version" integer DEFAULT 1 NOT NULL,
+	"owner_user_id" text,
+	"last_used_at" timestamp with time zone DEFAULT now() NOT NULL,
+	"created_at" text COLLATE "C" NOT NULL,
+	"updated_at" text COLLATE "C" NOT NULL,
+	"k8s_name" text COLLATE "C",
+	"volume_gen" integer DEFAULT 0 NOT NULL,
+	"desired" text,
+	"observed" text,
+	"pod_uid" text,
+	"host_epoch" integer DEFAULT 0 NOT NULL,
+	"join_token_hash" text,
+	"rev" integer DEFAULT 0 NOT NULL,
+	"last_active_at" timestamp with time zone,
+	"started_at" timestamp with time zone,
+	"reason" text,
+	"retiring" text COLLATE "C",
+	"volume_id" text,
+	CONSTRAINT "environments_kind_check" CHECK ("nylorun"."environments"."kind" IN ('virtual', 'pod', 'none'))
+);
+--> statement-breakpoint
+DROP TABLE "nylorun_streams"."sandbox_events" CASCADE;--> statement-breakpoint
+DROP TABLE "nylorun"."sandbox_resources" CASCADE;--> statement-breakpoint
+DELETE FROM "nylorun"."vaults" WHERE "id" <> 'host';--> statement-breakpoint
+DELETE FROM "nylorun"."vault_idempotency" WHERE "id" NOT LIKE 'host-model%';--> statement-breakpoint
+DELETE FROM "nylorun"."sandboxes";--> statement-breakpoint
+DELETE FROM "nylorun"."sandbox_signals";--> statement-breakpoint
+UPDATE "nylorun"."sessions" SET "body" = (("body"::jsonb - 'sandboxId' - 'sandboxSource' - 'sandboxOwnerId' - 'sandbox' - 'vaultIds' - 'credentialSelections') || '{"closedReason":"protocol_11"}'::jsonb)::json;--> statement-breakpoint
+UPDATE "nylorun"."tenant_settings" SET "key" = 'environments.config', "value" = ((("value"::jsonb - 'default') #- '{limits,ttl}' #- '{lifecycle,onExpiry}' #- '{limits,sandboxes}') || CASE WHEN ("value"::jsonb #> '{limits,sandboxes}') IS NULL THEN '{}'::jsonb ELSE jsonb_build_object('limits', (("value"::jsonb -> 'limits') - 'sandboxes' - 'ttl') || jsonb_build_object('environments', "value"::jsonb #> '{limits,sandboxes}')) END)::text WHERE "key" = 'sandbox.config';--> statement-breakpoint
+ALTER TABLE "nylorun"."vaults" DROP CONSTRAINT "vaults_scope_check";--> statement-breakpoint
+DROP INDEX "nylorun"."sessions_sandbox";--> statement-breakpoint
+DROP INDEX "nylorun"."vaults_owner";--> statement-breakpoint
+DROP INDEX "nylorun"."vaults_one_host";--> statement-breakpoint
+ALTER TABLE "nylorun"."sessions" ADD COLUMN "environment_id" text GENERATED ALWAYS AS (nylorun.doc(body)->>'environmentId') STORED;--> statement-breakpoint
+ALTER TABLE "nylorun"."vaults" ADD COLUMN "environment_id" text COLLATE "C";--> statement-breakpoint
+ALTER TABLE "nylorun"."vaults" ADD CONSTRAINT "vaults_environment_id_fkey" FOREIGN KEY ("environment_id") REFERENCES "nylorun"."environments"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "sessions_environment" ON "nylorun"."sessions" USING btree ("environment_id");--> statement-breakpoint
+CREATE UNIQUE INDEX "vault_credentials_name" ON "nylorun"."vault_credentials" USING btree ("vault_id","name");--> statement-breakpoint
+CREATE UNIQUE INDEX "vaults_environment" ON "nylorun"."vaults" USING btree ("environment_id");--> statement-breakpoint
+ALTER TABLE "nylorun"."sessions" DROP COLUMN "sandbox_id";--> statement-breakpoint
+ALTER TABLE "nylorun"."vaults" DROP COLUMN "owner_user_id";--> statement-breakpoint
+ALTER TABLE "nylorun"."vaults" DROP COLUMN "scope";--> statement-breakpoint
+ALTER TABLE "nylorun"."vaults" ADD CONSTRAINT "vaults_owner_check" CHECK (("nylorun"."vaults"."id" = 'host') = ("nylorun"."vaults"."environment_id" IS NULL));

package/dist/store/postgres/drizzle/0021_disk_versions.sql

@@ -0,0 +1,7 @@
+-- R2d step 3: an Environment's disk versions are one folder artifact it owns (environment_id),
+-- and its row holds the disk lease (disk_op) and the version its next volume starts from
+-- (disk_seed).
+ALTER TABLE "nylorun"."artifacts" ADD COLUMN "environment_id" text COLLATE "C";--> statement-breakpoint
+ALTER TABLE "nylorun"."environments" ADD COLUMN "disk_op" json;--> statement-breakpoint
+ALTER TABLE "nylorun"."environments" ADD COLUMN "disk_seed" json;--> statement-breakpoint
+CREATE UNIQUE INDEX "artifacts_environment_disk" ON "nylorun"."artifacts" USING btree ("environment_id") WHERE environment_id IS NOT NULL;

package/dist/store/postgres/drizzle/0022_model_usage_timing.sql

@@ -0,0 +1,5 @@
+-- R7.1: the gate's own timing of a model call (its span): when it sent the call, when the answer
+-- was complete, and how long the provider took to its first stream event. Null on older rows.
+ALTER TABLE "nylorun"."model_usage" ADD COLUMN "started_at" text;--> statement-breakpoint
+ALTER TABLE "nylorun"."model_usage" ADD COLUMN "ended_at" text;--> statement-breakpoint
+ALTER TABLE "nylorun"."model_usage" ADD COLUMN "first_token_ms" integer;

package/dist/store/postgres/drizzle/0023_artifact_pages.sql

@@ -0,0 +1 @@
+CREATE INDEX "artifacts_creation_order" ON "nylorun"."artifacts" USING btree ("created_at","id");

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

@@ -141,6 +141,34 @@
       "when": 1791530515498,
       "tag": "0019_sandbox_signal_outbox",
       "breakpoints": true
+    },
+    {
+      "idx": 20,
+      "version": "7",
+      "when": 1791702110945,
+      "tag": "0020_environments",
+      "breakpoints": true
+    },
+    {
+      "idx": 21,
+      "version": "7",
+      "when": 1791709466639,
+      "tag": "0021_disk_versions",
+      "breakpoints": true
+    },
+    {
+      "idx": 22,
+      "version": "7",
+      "when": 1791717547905,
+      "tag": "0022_model_usage_timing",
+      "breakpoints": true
+    },
+    {
+      "idx": 23,
+      "version": "7",
+      "when": 1791730977999,
+      "tag": "0023_artifact_pages",
+      "breakpoints": true
     }
   ]
 }