@nylorun/runtime 0.23.0-beta → 0.25.0-beta

package/dist/sandbox/share.d.ts

@@ -1,46 +1,41 @@
 /**
- * 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";
+import { type AgentManifest, 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. */
 export declare function sessionSandboxSpec(session: SessionSandboxRef): SandboxManifest | undefined;
-/** Sandbox spec declared on an agent capability or a workflow manifest. */
+/** The sandbox spec of a pinned agent manifest (its `runtime` block) or a workflow manifest. */
 export declare function sandboxSpecOf(manifest: AgentManifest | WorkflowManifest | Record<string, unknown> | undefined): SandboxManifest | undefined;
 /**
- * Where a definition document declares a sandbox: agent capabilities, the agents inlined as
- * tools or embedded in a flow agent, and a workflow's `sandbox`. Definitions no longer declare
- * one (Sandboxes v3), so registration refuses any of these.
+ * Where a definition document declares a sandbox: a workflow's `sandbox`, and the agents embedded
+ * in a flow agent. Definitions no longer declare one (Sandboxes v3), so registration refuses any
+ * of these. An agent manifest cannot: its sandbox is in the `runtime` block, which the schema
+ * refuses at registration.
  */
 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 agents of a definition document that set `runtime`: the document itself, the agents it
+ * uses as tools and those embedded in a flow agent. Only the Runtime writes that block, when it
+ * pins a session's manifest, so registration refuses any of these.
  */
-export declare function owningSandboxSessionId(session: SessionSandboxRef, lookup: (id: string) => SessionSandboxRef | undefined): string;
+export declare function authoredRuntimeBlocks(manifest: unknown, into?: string[]): 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.
+ * 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 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,32 +1,26 @@
 /**
- * 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);
 }
-/** Sandbox spec declared on an agent capability or a workflow manifest. */
+/** The sandbox spec of a pinned agent manifest (its `runtime` block) or a workflow manifest. */
 export function sandboxSpecOf(manifest) {
     if (!manifest || typeof manifest !== "object")
         return undefined;
     if (manifest.kind === "workflow")
         return manifest.sandbox;
-    const capabilities = manifest.capabilities;
-    if (!Array.isArray(capabilities))
-        return undefined;
-    for (const capability of capabilities)
-        if (capability.sandbox)
-            return capability.sandbox;
-    return undefined;
+    return manifest.runtime?.sandbox;
 }
 /**
- * Where a definition document declares a sandbox: agent capabilities, the agents inlined as
- * tools or embedded in a flow agent, and a workflow's `sandbox`. Definitions no longer declare
- * one (Sandboxes v3), so registration refuses any of these.
+ * Where a definition document declares a sandbox: a workflow's `sandbox`, and the agents embedded
+ * in a flow agent. Definitions no longer declare one (Sandboxes v3), so registration refuses any
+ * of these. An agent manifest cannot: its sandbox is in the `runtime` block, which the schema
+ * refuses at registration.
  */
 export function declaredSandboxes(manifest, into = []) {
     if (!manifest || typeof manifest !== "object")
@@ -39,60 +33,39 @@ export function declaredSandboxes(manifest, into = []) {
             declaredSandboxes(agent, into);
         return into;
     }
-    for (const capability of document.capabilities ?? []) {
-        if (capability.sandbox !== undefined)
-            into.push(`'${document.id}' (capability '${capability.id}')`);
-        for (const tool of capability.tools ?? [])
-            declaredSandboxes(tool.agent, into);
-    }
+    for (const tool of document.tools ?? [])
+        declaredSandboxes(tool.agent, 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 {
-        id: "sandbox",
-        type: "agent",
-        sandbox,
-        tools: [],
-    };
-}
 /**
- * Resolve the session id that keys the sandbox. Walks one hop via sandboxOwnerId;
- * cycles fall back to the starting session.
+ * The agents of a definition document that set `runtime`: the document itself, the agents it
+ * uses as tools and those embedded in a flow agent. Only the Runtime writes that block, when it
+ * pins a session's manifest, so registration refuses any of these.
  */
-export function 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);
+export function authoredRuntimeBlocks(manifest, into = []) {
+    if (!manifest || typeof manifest !== "object")
+        return into;
+    const document = manifest;
+    if (document.kind === "workflow") {
+        for (const agent of Object.values(document.agents ?? {}))
+            authoredRuntimeBlocks(agent, into);
+        return into;
     }
-    return session.id;
+    if (document.runtime !== undefined)
+        into.push(`'${document.id}'`);
+    for (const tool of document.tools ?? [])
+        authoredRuntimeBlocks(tool.agent, into);
+    return into;
 }
 /**
- * The workspace a session's sandbox tools run in: the 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/skills.d.ts

@@ -2,12 +2,14 @@ import { type AgentManifest } from "@nylorun/core/define";
 import type { SandboxHandle } from "./types.js";
 /** A skill's files, by path in its folder, as `sha256:<hex>`. */
 export type SkillFiles = Readonly<Record<string, string>>;
-/** The skills of the agent and the agents it uses as tools; the first of a name wins. */
+/**
+ * The skill versions of the agent and the agents it uses as tools, by folder
+ * (`/skills/<name>@<hash>`): each distinct version once.
+ */
 export declare function sandboxSkillsOf(manifest: AgentManifest | undefined, into?: Map<string, Readonly<Record<string, string>>>): Map<string, SkillFiles>;
-/** What a mounted skill holds, to tell whether a workspace has these files already. */
-export declare function skillSignature(files: SkillFiles): string;
 /**
- * Writes one skill's files to `/skills/<name>/` of the sandbox, replacing what was there, and
- * makes them read-only. `read` gives a file's bytes by `sha256:<hex>`.
+ * Writes one skill version's files to its folder `root` (`/skills/<name>@<hash>`), replacing a
+ * partial copy a failed mount left, and makes them read-only. `read` gives a file's bytes by
+ * `sha256:<hex>`.
  */
-export declare function mountSkill(handle: SandboxHandle, name: string, files: SkillFiles, read: (sha256: string) => Promise<Uint8Array>, signal: AbortSignal): Promise<void>;
+export declare function mountSkill(handle: SandboxHandle, root: string, files: SkillFiles, read: (sha256: string) => Promise<Uint8Array>, signal: AbortSignal): Promise<void>;

package/dist/sandbox/skills.js

@@ -1,36 +1,37 @@
 /**
- * A sandbox's skills (track R2 M4): each skill of the session's agent, and of the agents it uses
- * as tools (they share its sandbox), gets its files under `/skills/<name>/`, read-only, so the
- * model can read them and run their scripts with bash. The SandboxManager mounts them on a
- * workspace before the first call of a session's run that opens it, and again when a session
- * with other skills uses it; the bytes come from the Tenant's definition files.
+ * A sandbox's skills (track R2 M4, D66): each version of a skill of the session's agent, and of
+ * the agents it uses as tools (they share its sandbox), gets its files in its own folder,
+ * `/skills/<name>@<hash>/` (`skillFolderOf`), read-only, so the model can read them and run their
+ * scripts with bash. A version's folder is written once and never replaced: sessions whose agents
+ * carry different versions of one skill share an Environment, and run turns at once, without
+ * changing each other's files. The SandboxManager mounts the folders a session needs before the
+ * first call that needs them; the bytes come from the Tenant's definition files. Folders live
+ * outside the persisted disk, so a stop clears them and the next open mounts what is in use.
  */
 import { posix } from "node:path";
-import { SKILLS_MOUNT } from "@nylorun/core/define";
-import { canonical } from "../store/canonical.js";
+import { skillFolderOf } from "@nylorun/core/define";
 import { quote } from "./tools.js";
-/** The skills of the agent and the agents it uses as tools; the first of a name wins. */
+/**
+ * The skill versions of the agent and the agents it uses as tools, by folder
+ * (`/skills/<name>@<hash>`): each distinct version once.
+ */
 export function sandboxSkillsOf(manifest, into = new Map()) {
-    for (const capability of manifest?.capabilities ?? []) {
-        for (const skill of Object.values(capability.skills ?? {}))
-            if (!into.has(skill.name))
-                into.set(skill.name, skill.files);
-        for (const tool of capability.tools ?? [])
-            if (tool.agent !== undefined && !("kind" in tool.agent))
-                sandboxSkillsOf(tool.agent, into);
+    for (const skill of Object.values(manifest?.skills ?? {})) {
+        const folder = skillFolderOf(skill);
+        if (!into.has(folder))
+            into.set(folder, skill.files);
     }
+    for (const tool of manifest?.tools ?? [])
+        if (tool.agent !== undefined && !("kind" in tool.agent))
+            sandboxSkillsOf(tool.agent, into);
     return into;
 }
-/** What a mounted skill holds, to tell whether a workspace has these files already. */
-export function skillSignature(files) {
-    return canonical(files);
-}
 /**
- * Writes one skill's files to `/skills/<name>/` of the sandbox, replacing what was there, and
- * makes them read-only. `read` gives a file's bytes by `sha256:<hex>`.
+ * Writes one skill version's files to its folder `root` (`/skills/<name>@<hash>`), replacing a
+ * partial copy a failed mount left, and makes them read-only. `read` gives a file's bytes by
+ * `sha256:<hex>`.
  */
-export async function mountSkill(handle, name, files, read, signal) {
-    const root = `${SKILLS_MOUNT}/${name}`;
+export async function mountSkill(handle, root, files, read, signal) {
     const exec = async (command) => {
         const result = await handle.exec({ command, cwd: "/", timeoutMs: 60_000 }, signal);
         if (result.exitCode !== 0)

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/0024_flat_manifest.sql

@@ -0,0 +1,7 @@
+-- Protocol 13: manifest 7, flat (no capabilities), with the Runtime's tools in a `runtime` block.
+-- A fresh start for sessions: one opened before protocol 13 pinned a manifest 5 or 6, which the
+-- engine no longer runs, so it is closed (`session_closed`) and its history stays readable. No
+-- column changes: tool calls are read from the effect journal's documents, whose old
+-- `capabilityId` field is ignored.
+UPDATE "nylorun"."sessions" SET "body" = ("body"::jsonb || '{"closedReason":"protocol_13"}'::jsonb)::json
+WHERE nylorun.doc("body") ->> 'closedReason' IS NULL;

package/dist/store/postgres/drizzle/0025_environment_manifests.sql

@@ -0,0 +1,14 @@
+CREATE TABLE "nylorun"."environment_manifests" (
+	"name" text COLLATE "C" NOT NULL,
+	"version" integer NOT NULL,
+	"body" json NOT NULL,
+	"hash" text COLLATE "C" NOT NULL,
+	"saved_by" json NOT NULL,
+	"created_at" text COLLATE "C" NOT NULL,
+	CONSTRAINT "environment_manifests_pkey" PRIMARY KEY("name","version")
+);
+--> statement-breakpoint
+ALTER TABLE "nylorun"."environments" ADD COLUMN "manifest_name" text COLLATE "C";--> statement-breakpoint
+ALTER TABLE "nylorun"."environments" ADD COLUMN "manifest_version" integer;--> statement-breakpoint
+ALTER TABLE "nylorun"."environments" ADD COLUMN "manifest_hash" text COLLATE "C";--> statement-breakpoint
+CREATE INDEX "environments_manifest" ON "nylorun"."environments" USING btree ("manifest_name","manifest_version");

package/dist/store/postgres/drizzle/0026_environment_forks.sql

@@ -0,0 +1 @@
+ALTER TABLE "nylorun"."environments" ADD COLUMN "forked_from" json;

package/dist/store/postgres/drizzle/0027_environment_image_digest.sql

@@ -0,0 +1 @@
+ALTER TABLE "nylorun"."environments" ADD COLUMN "image_digest" text COLLATE "C";

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

@@ -141,6 +141,62 @@
       "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
+    },
+    {
+      "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
     }
   ]
 }