@nylorun/runtime 0.27.0-beta → 0.29.0-beta

package/dist/reads/types.d.ts

@@ -1,4 +1,4 @@
-import type { ArtifactKind, ArtifactPage, ModelCallExportPage, ModelCallsPage, EnvironmentPage, ToolCallsPage, SessionManifestView, SessionPage, SessionListItem, SessionUsageTotals, LiveEvent } from "@nylorun/core/contracts";
+import type { ArtifactKind, ArtifactPage, ModelCallExportPage, ModelCallsPage, ToolCallsPage, SessionManifestView, SessionPage, SessionListItem, SessionUsageTotals, LiveEvent } from "@nylorun/core/contracts";
 export type ReadAccess = {
     owner?: string;
     agents?: readonly string[];
@@ -6,7 +6,8 @@ export type ReadAccess = {
 export type SessionFilters = {
     agentId?: string;
     status?: SessionListItem["status"];
-    environmentId?: string;
+    /** Sessions that pinned a version of this agent manifest. */
+    manifest?: string;
     ownerUserId?: string;
 };
 export type PageOptions = {
@@ -33,6 +34,5 @@ export interface ReadStore {
      * for a turn the session never had.
      */
     turnEvents(id: string, turnId: string, access: ReadAccess): Promise<LiveEvent[]>;
-    environments(labels: Record<string, string>, page: PageOptions, access: ReadAccess, grants?: readonly string[]): Promise<EnvironmentPage>;
     close(): Promise<void>;
 }

package/dist/record/agent.d.ts

@@ -0,0 +1,27 @@
+import { type AgentEvent, type AgentEventPayload, type AgentEventType } from "@nylorun/core/contracts";
+/** The Agent stream's two statements, in the caller's transaction. */
+export interface AgentRecordWriter {
+    /** The seq the Agent's next event takes: one past its last, or 0. */
+    nextSeq(agentId: string): Promise<number>;
+    insert(row: {
+        agentId: string;
+        seq: number;
+        type: string;
+        body: AgentEvent;
+    }): Promise<void>;
+}
+export interface AgentAppendInput<T extends AgentEventType> {
+    tenantId: string;
+    agentId: string;
+    time: Date;
+    type: T;
+    payload: AgentEventPayload<T>;
+    /** The Tenant's Runtime limit `recordEntryBytes`, as for a session's events. */
+    maxEntryBytes: number;
+}
+/** Builds the event and checks it against the Agent event catalog. */
+export declare function buildAgentEvent<T extends AgentEventType>(input: AgentAppendInput<T> & {
+    seq: number;
+}): AgentEvent;
+/** Appends one event to the Agent's stream through `writer`. */
+export declare function appendAgentEvent<T extends AgentEventType>(writer: AgentRecordWriter, input: AgentAppendInput<T>): Promise<AgentEvent>;

package/dist/record/agent.js

@@ -0,0 +1,46 @@
+/**
+ * An Agent's lifecycle stream (blueprint D39, F7.1; an Environment's before protocol 16):
+ * `agent.created`, `agent.attached`, `agent.detached` and `agent.deleted` (and the rest of
+ * `AGENT_EVENT_TYPES`, egress-gate's `agent.egress` for every connection among them, D67), on
+ * the `nylorun.agent-event/1` envelope, numbered from 0 per Agent id in
+ * `nylorun_streams.agent_events`. The record module is its only writer, as for session events;
+ * the store runs the two statements through `AgentRecordWriter` in the caller's transaction, under
+ * the Agent row's lock (or, for an Agent being created, its new row).
+ *
+ * The stream lives in the record only: it is not published to the stream relay, so no S2 stream
+ * follows it yet. Clients read it with `GET /v1/agents/{id}/events`.
+ */
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { AGENT_EVENT_PAYLOADS, AGENT_EVENT_SCHEMA, AgentEventSchema, } from "@nylorun/core/contracts";
+import { InvalidEventError } from "./envelope.js";
+import { checkEntry } from "./append.js";
+/** Builds the event and checks it against the Agent event catalog. */
+export function buildAgentEvent(input) {
+    const payload = AGENT_EVENT_PAYLOADS[input.type];
+    const checkedPayload = payload.safeParse(input.payload);
+    if (!checkedPayload.success)
+        throw new InvalidEventError(input.type, z.prettifyError(checkedPayload.error));
+    const event = JSON.parse(JSON.stringify({
+        schema: AGENT_EVENT_SCHEMA,
+        eventId: randomUUID(),
+        tenantId: input.tenantId,
+        agentId: input.agentId,
+        seq: input.seq,
+        time: input.time.toISOString(),
+        type: input.type,
+        payload: input.payload,
+    }));
+    const checked = AgentEventSchema.safeParse(event);
+    if (!checked.success)
+        throw new InvalidEventError(input.type, z.prettifyError(checked.error));
+    return event;
+}
+/** Appends one event to the Agent's stream through `writer`. */
+export async function appendAgentEvent(writer, input) {
+    checkEntry(`The ${input.type} event's payload`, input.payload, input.maxEntryBytes);
+    const seq = await writer.nextSeq(input.agentId);
+    const event = buildAgentEvent({ ...input, seq });
+    await writer.insert({ agentId: input.agentId, seq, type: input.type, body: event });
+    return event;
+}

package/dist/record/index.d.ts

@@ -9,4 +9,4 @@
 export { buildEvent, InvalidEventError, type EventInput } from "./envelope.js";
 export { decodeCursor, encodeCursor } from "./cursor.js";
 export { RecordEntryTooLargeError, appendEvent, checkEntry, entryBytes, type AppendInput, type RecordWriter, } from "./append.js";
-export { appendEnvironmentEvent, buildEnvironmentEvent, type EnvironmentAppendInput, type EnvironmentRecordWriter, } from "./environment.js";
+export { appendAgentEvent, buildAgentEvent, type AgentAppendInput, type AgentRecordWriter, } from "./agent.js";

package/dist/record/index.js

@@ -9,4 +9,4 @@
 export { buildEvent, InvalidEventError } from "./envelope.js";
 export { decodeCursor, encodeCursor } from "./cursor.js";
 export { RecordEntryTooLargeError, appendEvent, checkEntry, entryBytes, } from "./append.js";
-export { appendEnvironmentEvent, buildEnvironmentEvent, } from "./environment.js";
+export { appendAgentEvent, buildAgentEvent, } from "./agent.js";

package/dist/sandbox/join.js

@@ -32,7 +32,7 @@
  * which check failed.
  */
 import { createHash, timingSafeEqual } from "node:crypto";
-import { isEnvironmentId } from "@nylorun/core/contracts";
+import { isAgentId } from "@nylorun/core/contracts";
 import { recoverLostVolume, runPendingSeed } from "../artifacts/disk.js";
 import { recordSetup, setupFile, setupPlanOf, setupState, } from "./setup.js";
 import { mintHostTokens, staleHost, verifyHostToken, } from "../tenant/host-token.js";
@@ -87,7 +87,7 @@ export function hostAuthority(ctx) {
     return {
         async join(request) {
             const { sandboxId, podUid, joinToken, volumeId } = request;
-            if (!isEnvironmentId(sandboxId) ||
+            if (!isAgentId(sandboxId) ||
                 typeof podUid !== "string" ||
                 !POD_UID.test(podUid) ||
                 typeof joinToken !== "string" ||
@@ -136,7 +136,7 @@ export function hostAuthority(ctx) {
                     // A new, empty volume under the same Sandbox: the sandbox's files are gone.
                     const reason = "The sandbox's volume was replaced: its files are gone";
                     await t.updateEnvironmentPod(sandboxId, { observed: "lost", reason, hostEpoch: epoch }, now);
-                    await t.environmentEvent(sandboxId, "environment.lost", { reason });
+                    await t.agentEvent(sandboxId, "agent.lost", { reason });
                     // Its Sandbox is deleted; only a reset brings the sandbox back.
                     await t.signal({ type: "host.revoked", sandboxId, epoch });
                     await t.signalSandbox(sandboxId, { kind: "reconcile" });
@@ -150,9 +150,9 @@ export function hostAuthority(ctx) {
                 }, now);
                 if (pod.podUid !== podUid) {
                     if (pod.podUid !== undefined)
-                        await t.environmentEvent(sandboxId, "environment.relaunched", { hostEpoch: epoch });
+                        await t.agentEvent(sandboxId, "agent.relaunched", { hostEpoch: epoch });
                     else
-                        await t.environmentEvent(sandboxId, "environment.running", { hostEpoch: epoch });
+                        await t.agentEvent(sandboxId, "agent.running", { hostEpoch: epoch });
                 }
                 // The previous host's connection (an older epoch) serves nothing more, on any process.
                 await t.signal({ type: "host.revoked", sandboxId, epoch });

package/dist/sandbox/placement.d.ts

@@ -8,7 +8,7 @@
  * A session on a pod Environment runs on `sandbox`; every other session (a virtual or `none`
  * Environment, or none) on `harness-container` (D52). A host the Tenant does not allow is
  * `409 placement_refused`. A pod Environment needs sandbox pods: without a cluster (`nylorun
- * sandbox enable`), or with the sandboxes service not ready, it is `409 environment_unavailable`.
+ * sandbox enable`), or with the sandboxes service not ready, it is `409 agent_unavailable`.
  */
 import { type EnvironmentKind, type PlacementHost as SandboxPlacementHost } from "@nylorun/core/contracts";
 import type { TenantSandboxConfig } from "./tenant-config.js";

package/dist/sandbox/placement.js

@@ -8,7 +8,7 @@
  * A session on a pod Environment runs on `sandbox`; every other session (a virtual or `none`
  * Environment, or none) on `harness-container` (D52). A host the Tenant does not allow is
  * `409 placement_refused`. A pod Environment needs sandbox pods: without a cluster (`nylorun
- * sandbox enable`), or with the sandboxes service not ready, it is `409 environment_unavailable`.
+ * sandbox enable`), or with the sandboxes service not ready, it is `409 agent_unavailable`.
  */
 import { DEFAULT_HARNESS, } from "@nylorun/core/contracts";
 import { fail, failRetryLater } from "../tenant/http.js";
@@ -50,9 +50,9 @@ export async function podsReady(pods) {
 export async function requirePods(pods, what) {
     if (!pods)
         return fail(409, `${what} needs sandbox pods, and this Runtime has no cluster: ${ENABLE_PODS}.`, {
-            code: "environment_unavailable",
+            code: "agent_unavailable",
         });
     if (!(await podsReady(pods)))
-        failRetryLater(`${what} needs sandbox pods, and the sandboxes service is not ready. Check \`nylorun local sandbox status\`.`, "environment_unavailable");
+        failRetryLater(`${what} needs sandbox pods, and the sandboxes service is not ready. Check \`nylorun local sandbox status\`.`, "agent_unavailable");
     return pods;
 }

package/dist/sandbox/pods/lifecycle.d.ts

@@ -13,14 +13,14 @@
  *   <name>.r<rev>`, so a repeated apply is a no-op at the service, and a Sandbox whose `opId`
  *   is not the row's is applied again.
  * - **Idle** (`trigger: idle`): no turn on a session that names it, and none ended within its
- *   `lifecycle.idle` (at most the Tenant's `limits.idle`) → `Suspended` (`environment.suspended`,
+ *   `lifecycle.idle` (at most the Tenant's `limits.idle`) → `Suspended` (`agent.suspended`,
  *   reason `idle`). The volume is kept; the next turn start asks for `Running` again.
  * - **Lost**: an incarnation that has run (a pod joined) whose Sandbox is gone or whose volume
- *   is missing is `lost` (`environment.lost`): its host epoch moves, its Sandbox is deleted, and
+ *   is missing is `lost` (`agent.lost`): its host epoch moves, its Sandbox is deleted, and
  *   only a reset brings the Environment back. agent-sandbox recreates a deleted claim empty, so
  *   the engine's join also checks the id it keeps on the volume (`join.ts`): a new volume is
  *   lost too. A pod replaced on the same volume is not lost: the new pod's join bumps the epoch
- *   (`environment.relaunched`).
+ *   (`agent.relaunched`).
  * - **Delete** (`desired: deleted`): the Sandbox is deleted, and the row once it is gone.
  * - **Reset** (`tenant/environments.ts`) bumps the volume generation: a new name, so a new
  *   Sandbox and volume; the old name is `retiring` and deleted here.
@@ -35,7 +35,7 @@
  *
  * An unused Environment is deleted by the Tenant sweep (`lifecycle.deleteAfter`), not here.
  */
-import type { EnvironmentEventPayload, EnvironmentEventType } from "@nylorun/core/contracts";
+import type { AgentEventPayload, AgentEventType } from "@nylorun/core/contracts";
 import type { Environment, SandboxPodPatch, SandboxPodState } from "../../store/types.js";
 import type { PodStatus } from "./client.js";
 /**
@@ -79,9 +79,9 @@ export interface PodFacts {
     readonly now: number;
     readonly trigger: PodTrigger;
 }
-export interface PodEvent<T extends EnvironmentEventType = EnvironmentEventType> {
+export interface PodEvent<T extends AgentEventType = AgentEventType> {
     readonly type: T;
-    readonly payload: EnvironmentEventPayload<T>;
+    readonly payload: AgentEventPayload<T>;
 }
 export interface PodDecision {
     /** Apply the row's spec (after `patch`) in this mode; `rotateJoin` mints a new join token. */

package/dist/sandbox/pods/lifecycle.js

@@ -113,7 +113,7 @@ export function decide(facts) {
             patch.desired = desired;
             patch.rev = rev;
             patch.hostEpoch = pod.hostEpoch + 1;
-            events.push(event("environment.suspended", { reason: "idle" }));
+            events.push(event("agent.suspended", { reason: "idle" }));
         }
         else
             arm.push({ timer: "idle", at: due });
@@ -121,14 +121,14 @@ export function decide(facts) {
     // An incarnation a pod has joined, whose Sandbox or volume is gone: lost.
     if (pod.podUid !== undefined && (!status.exists || status.deleting || status.volume === "missing")) {
         const reason = !status.exists
-            ? "The Environment's pod and volume were deleted outside the Runtime"
+            ? "The Agent's pod and volume were deleted outside the Runtime"
             : status.deleting
-                ? "The Environment's pod is being deleted outside the Runtime"
-                : "The Environment's volume is gone";
+                ? "The Agent's pod is being deleted outside the Runtime"
+                : "The Agent's volume is gone";
         patch.observed = "lost";
         patch.reason = reason;
         patch.hostEpoch = (patch.hostEpoch ?? pod.hostEpoch) + 1;
-        events.push(event("environment.lost", { reason }));
+        events.push(event("agent.lost", { reason }));
         if (status.exists && !status.deleting)
             deletes.push(pod.k8sName);
         if (status.exists)
@@ -184,7 +184,7 @@ export function decide(facts) {
                 `The pod was not ready within ${Math.round(readyDeadlineMs / 1000)} s`;
             patch.observed = "failed";
             patch.reason = reason;
-            events.push(event("environment.failed", { reason }));
+            events.push(event("agent.failed", { reason }));
             return done();
         }
         if (pod.observed !== "creating")

package/dist/sandbox/pods/reconcile.js

@@ -23,6 +23,7 @@ import { recoverLostVolume } from "../../artifacts/disk.js";
 import { decide } from "./lifecycle.js";
 import { podLifecycleConfig, podSpecOf } from "./spec.js";
 import { hostTuning } from "../../tuning.js";
+import { idleMsOf, revertStart } from "../../tenant/agent-versions.js";
 export async function reconcileSandbox(ctx, sandboxId, trigger) {
     const pods = ctx.pods;
     if (!pods || ctx.closed)
@@ -51,7 +52,8 @@ export async function reconcileSandbox(ctx, sandboxId, trigger) {
             return undefined;
         }
     };
-    const lifecycle = podLifecycleConfig(config, row.recipe);
+    // While a start would apply a new version (track T3), it idles at most `tenant.upgradeIdleMs`.
+    const lifecycle = { ...podLifecycleConfig(config, row.recipe), idleMs: idleMsOf(config, row) };
     const decision = decide({
         row,
         image: row.applied.image ?? DEFAULT_SANDBOX_IMAGE,
@@ -140,9 +142,15 @@ export async function reconcileSandbox(ctx, sandboxId, trigger) {
         if (Object.keys(finalPatch).length > 0)
             await t.updateEnvironmentPod(sandboxId, finalPatch, new Date().toISOString());
         for (const item of decision.events)
-            await t.environmentEvent(sandboxId, item.type, item.payload);
+            await t.agentEvent(sandboxId, item.type, item.payload);
         if (epochMoved)
             await t.signal({ type: "host.revoked", sandboxId, epoch: finalPatch.hostEpoch });
+        // A pod that failed to start on a new version goes back to the version it ran (track T3).
+        if (finalPatch.observed === "failed" && current.startCheck) {
+            const failed = (await t.environment(sandboxId, { lock: true }));
+            await revertStart(t, failed, finalPatch.reason ?? "The pod failed", new Date().toISOString());
+            return { kind: "changed" };
+        }
         return { kind: "written" };
     });
     if (written.kind === "changed")

package/dist/sandbox/resolve.d.ts

@@ -1,5 +1,5 @@
 /**
- * Resolves an Environment's recipe (`PUT /v1/environments/{id}`) against its Tenant's limits,
+ * Resolves an Agent's recipe (`PUT /v1/agents/{id}`) against its Tenant's limits,
  * and the sandbox spec a recipe gives a session (`Session.sandbox`) and the pod. Pure: the
  * caller supplies the configuration. Every problem is reported, not only the first, so one
  * response lists all of them.
@@ -38,11 +38,11 @@ export type RecipeResolution = {
     readonly kind: "error";
     readonly errors: readonly string[];
 };
-/** The recipe `request` asks for an Environment of `kind`, or every reason it cannot have it. */
+/** The recipe `request` asks for an Agent of `kind`, or every reason it cannot have it. */
 export declare function resolveRecipe(kind: EnvironmentKind, request: RecipeRequest, config: EffectiveSandboxConfig): RecipeResolution;
 /**
  * The sandbox spec of a recipe: what a session pins when it opens and the virtual
- * workspace runs. Idle is the Environment's `lifecycle.idle`, else the Tenant's.
+ * workspace runs. Idle is the Agent's `lifecycle.idle`, else the Tenant's.
  */
 export declare function sandboxSpecOf(recipe: EnvironmentRecipe, tenantIdle: string): SandboxManifest;
 /** The pod's spec of a recipe: its sandbox spec and its volume's size. */

package/dist/sandbox/resolve.js

@@ -1,7 +1,7 @@
 import { DEFAULT_HARNESS } from "@nylorun/core/contracts";
 import { parseSandboxDuration } from "@nylorun/core/define";
 import { memoryMiB } from "./tenant-config.js";
-/** The recipe `request` asks for an Environment of `kind`, or every reason it cannot have it. */
+/** The recipe `request` asks for an Agent of `kind`, or every reason it cannot have it. */
 export function resolveRecipe(kind, request, config) {
     const { limits } = config;
     const errors = [];
@@ -9,7 +9,7 @@ export function resolveRecipe(kind, request, config) {
     // Any harness id (R4.1): placement decides where it may run, when a session opens.
     const harness = request.harness ?? DEFAULT_HARNESS;
     if (pod && harness !== DEFAULT_HARNESS && request.image === undefined)
-        errors.push(`harness ${harness} needs image: a pod Environment runs its image as the harness.`);
+        errors.push(`harness ${harness} needs image: a pod Agent runs its image as the harness.`);
     const lifecycle = request.lifecycle ?? {};
     const idle = lifecycle.idle === undefined ? undefined : parseSandboxDuration(lifecycle.idle);
     if (idle !== undefined && idle > (parseSandboxDuration(limits.idle) ?? Infinity))
@@ -17,7 +17,7 @@ export function resolveRecipe(kind, request, config) {
     if (kind === "none") {
         for (const field of ["image", "resources", "storage", "network", "setup", "files"])
             if (request[field] !== undefined)
-                errors.push(`${field} is for an Environment with a sandbox: kind none has none.`);
+                errors.push(`${field} is for an Agent with a sandbox: kind none has none.`);
         if (errors.length > 0)
             return { kind: "error", errors };
         return {
@@ -26,9 +26,9 @@ export function resolveRecipe(kind, request, config) {
         };
     }
     if (request.image !== undefined && !pod)
-        errors.push("image is for kind pod: a virtual Environment runs no images.");
+        errors.push("image is for kind pod: a virtual Agent runs no images.");
     if (request.storage !== undefined && !pod)
-        errors.push("storage is for kind pod: a virtual Environment has no volume.");
+        errors.push("storage is for kind pod: a virtual Agent has no volume.");
     for (const field of ["setup", "files"])
         if (request[field] !== undefined && request[field].length > 0 && !pod)
             errors.push(`${field} is for kind pod: it runs when a pod's disk is made or reset.`);
@@ -37,7 +37,7 @@ export function resolveRecipe(kind, request, config) {
         if (!withinCeiling(host, limits.network))
             errors.push(`network.allowedHosts includes ${host}, which this Tenant does not allow.`);
         else if (host.startsWith("*.") && !pod)
-            errors.push(`network.allowedHosts includes ${host}; a virtual Environment allows exact host names only, such as ${host.slice(2)}.`);
+            errors.push(`network.allowedHosts includes ${host}; a virtual Agent allows exact host names only, such as ${host.slice(2)}.`);
     }
     const cpus = request.resources?.cpus ?? limits.defaultResources.cpus;
     const memory = request.resources?.memory === undefined
@@ -79,7 +79,7 @@ function slotsOf(request) {
 }
 /**
  * The sandbox spec of a recipe: what a session pins when it opens and the virtual
- * workspace runs. Idle is the Environment's `lifecycle.idle`, else the Tenant's.
+ * workspace runs. Idle is the Agent's `lifecycle.idle`, else the Tenant's.
  */
 export function sandboxSpecOf(recipe, tenantIdle) {
     const allow = recipe.network?.allowedHosts ?? [];

package/dist/sandbox/setup.d.ts

@@ -6,6 +6,8 @@ export { SETUP_FAILED };
 export interface SetupPlan {
     /** The applied recipe's version: written into the volume's marker. */
     readonly recipeVersion: number;
+    /** The sha256 of the commands and files: a marker with another runs the setup again (T3). */
+    readonly setupHash: string;
     readonly commands: readonly {
         readonly command: string;
         readonly cwd: string;
@@ -33,7 +35,7 @@ export interface SetupReport {
 export declare function parseSetupReport(value: unknown): SetupReport | undefined;
 /**
  * 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
+ * the pod is `failed` with a reason that starts `setup:`, and `agent.failed` says which
  * command failed and how, with the end of its output (the Tenant's `setupOutputChars`; the reason
  * quotes `setupReasonChars` of it and `setupCommandExcerptChars` of the command). A report
  * from an older host, or a success, changes nothing.

package/dist/sandbox/setup.js

@@ -10,19 +10,26 @@
  * a pod reads the artifact versions and the definition files by hash (Q6) its own recipe names,
  * and nothing else of the Object store.
  *
+ * The plan's `setupHash` names its commands and files: the engine runs the setup again on a volume
+ * whose marker names another (a new version's setup, track T3).
+ *
  * A failed command fails the pod (`observed: failed`, a reason that starts `setup:`, and
- * `environment.failed` with the command, its exit code and the end of its output): the turn that
+ * `agent.failed` with the command, its exit code and the end of its output), or, on a start on
+ * a new version, takes the Agent back to the version it ran (`revertStart`, T3): the turn that
  * waits for it fails with that reason (`podUnusable`, `tenant/advance.ts`), the failure stays
  * until a turn start asks the pod to run again (`wantRunning`), and the engine, polling, runs the
  * setup again then.
  */
 import { ENVIRONMENT_SETUP_TIMEOUT_DEFAULT, } from "@nylorun/core/contracts";
+import { createHash } from "node:crypto";
 import { parseSandboxDuration } from "@nylorun/core/define";
+import { canonical } from "../store/canonical.js";
 import { contentKey, readManifest } from "../artifacts/folders.js";
 import { contentTypeFor } from "@nylorun/core/contracts";
 import { definitionFileKey } from "../tenant/definition-files.js";
 import { SETUP_FAILED } from "./pods/lifecycle.js";
 import { readRuntimeLimits } from "../tenant/runtime-limits.js";
+import { revertStart } from "../tenant/agent-versions.js";
 export { SETUP_FAILED };
 /** The setup of `recipe`, or undefined when it has neither commands nor files. */
 export async function setupPlanOf(ctx, t, environment) {
@@ -34,6 +41,7 @@ export async function setupPlanOf(ctx, t, environment) {
     const timeoutOf = (timeout) => Math.min(parseSandboxDuration(timeout ?? ENVIRONMENT_SETUP_TIMEOUT_DEFAULT), setupCommandMs);
     return {
         recipeVersion: environment.appliedVersion,
+        setupHash: createHash("sha256").update(canonical({ setup: recipe.setup ?? [], files: recipe.files ?? [] })).digest("hex"),
         commands: (recipe.setup ?? []).map((command) => ({
             command: command.command,
             cwd: command.cwd ?? "/workspace",
@@ -61,7 +69,7 @@ export function parseSetupReport(value) {
 }
 /**
  * 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
+ * the pod is `failed` with a reason that starts `setup:`, and `agent.failed` says which
  * command failed and how, with the end of its output (the Tenant's `setupOutputChars`; the reason
  * quotes `setupReasonChars` of it and `setupCommandExcerptChars` of the command). A report
  * from an older host, or a success, changes nothing.
@@ -84,8 +92,7 @@ export async function recordSetup(ctx, id, epoch, report) {
         const what = command === undefined ? "copying the input files failed" : `command ${report.index + 1} (${command.command.slice(0, setupCommandExcerptChars)}) exited ${report.exitCode ?? "abnormally"}`;
         const tail = output.trim().slice(-setupReasonChars);
         const reason = `${SETUP_FAILED} ${what}${tail ? `: ${tail}` : ""}`;
-        await t.updateEnvironmentPod(id, { observed: "failed", reason }, new Date().toISOString());
-        await t.environmentEvent(id, "environment.failed", {
+        await t.agentEvent(id, "agent.failed", {
             reason,
             setup: {
                 ...(report.index === undefined ? {} : { index: report.index }),
@@ -93,6 +100,9 @@ export async function recordSetup(ctx, id, epoch, report) {
                 output,
             },
         });
+        // On a start on a new version (track T3), back to the version it ran; else failed.
+        if (!(await revertStart(t, environment, reason, new Date().toISOString())))
+            await t.updateEnvironmentPod(id, { observed: "failed", reason }, new Date().toISOString());
     });
     if (report.status === "failed")
         ctx.config.logger.warn("environment setup failed", { environmentId: id, index: report.index, exitCode: report.exitCode });

package/dist/store/postgres/drizzle/0032_agents.sql

@@ -0,0 +1,54 @@
+-- Protocol 16: Agents from one manifest (track T2), a fresh start. Agent definitions and
+-- environment manifests cannot become agent manifests (v8) on their own: a definition has no
+-- runtime section, and an Environment held sessions of many agents. So both go, and so do the
+-- Environments with their pods, disks and vaults, as protocol 11 dropped sandboxes and vaults.
+-- Every open session is closed (`protocol_16`): its history stays readable. `environments` is
+-- renamed `agents` (made from a saved agent manifest only) and its lifecycle stream
+-- `agent_events`; model budget scope `agent` is `manifest`, keyed by the manifest's name, so a
+-- budget keeps its meaning, and the usage ledger names the manifest.
+UPDATE "nylorun"."sessions" SET "body" = ("body"::jsonb || '{"closedReason":"protocol_16"}'::jsonb)::json
+WHERE nylorun.doc("body") ->> 'closedReason' IS NULL;--> 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
+DELETE FROM "nylorun"."artifacts" WHERE "environment_id" IS NOT NULL;--> statement-breakpoint
+DELETE FROM "nylorun"."environments";--> statement-breakpoint
+DELETE FROM "nylorun"."definition_file_uses";--> statement-breakpoint
+DROP TABLE "nylorun"."definitions";--> statement-breakpoint
+DROP TABLE "nylorun"."environment_manifests";--> statement-breakpoint
+DROP TABLE "nylorun_streams"."environment_events";--> statement-breakpoint
+CREATE TABLE "nylorun_streams"."agent_events" (
+	"agent_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 "agent_events_pkey" PRIMARY KEY("agent_id","seq")
+);
+--> statement-breakpoint
+CREATE TABLE "nylorun"."agent_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 "agent_manifests_pkey" PRIMARY KEY("name","version")
+);
+--> statement-breakpoint
+ALTER TABLE "nylorun"."environments" RENAME TO "agents";--> statement-breakpoint
+ALTER TABLE "nylorun"."agents" RENAME CONSTRAINT "environments_pkey" TO "agents_pkey";--> statement-breakpoint
+ALTER TABLE "nylorun"."agents" DROP CONSTRAINT "environments_kind_check";--> statement-breakpoint
+ALTER TABLE "nylorun"."agents" ADD CONSTRAINT "agents_kind_check" CHECK ("nylorun"."agents"."kind" IN ('virtual', 'pod', 'none'));--> statement-breakpoint
+ALTER INDEX "nylorun"."environments_manifest" RENAME TO "agents_manifest";--> statement-breakpoint
+ALTER TABLE "nylorun"."agents" ALTER COLUMN "manifest_name" SET NOT NULL;--> statement-breakpoint
+ALTER TABLE "nylorun"."agents" ALTER COLUMN "manifest_version" SET NOT NULL;--> statement-breakpoint
+ALTER TABLE "nylorun"."agents" ALTER COLUMN "manifest_hash" SET NOT NULL;--> statement-breakpoint
+ALTER TABLE "nylorun"."agents" ADD COLUMN "manifest_ref" text NOT NULL;--> statement-breakpoint
+ALTER TABLE "nylorun"."agents" ADD COLUMN "desired_state" text DEFAULT 'on' NOT NULL;--> statement-breakpoint
+ALTER TABLE "nylorun"."model_usage" RENAME COLUMN "agent_id" TO "manifest_name";--> statement-breakpoint
+ALTER INDEX "nylorun"."model_usage_agent" RENAME TO "model_usage_manifest";--> statement-breakpoint
+UPDATE "nylorun"."model_budgets" SET "scope" = 'manifest' WHERE "scope" = 'agent';--> statement-breakpoint
+ALTER TABLE "nylorun"."sessions" ADD COLUMN "manifest_name" text GENERATED ALWAYS AS (nylorun.doc(body)->'definition'->>'name') STORED;--> statement-breakpoint
+CREATE INDEX "sessions_manifest" ON "nylorun"."sessions" USING btree ("manifest_name");

package/dist/store/postgres/drizzle/0033_agent_versions.sql

@@ -0,0 +1,7 @@
+-- Track T3, Agents that evolve (D73): an Agent moves between versions of its manifest. While it
+-- is outdated it names the version it moves to (`target_version`); a version that failed to start
+-- is kept so a tracking Agent does not move to it again (`failed_version`); and while a pod starts
+-- on a new version, what it ran before (`start_check`), which a failed start reverts to.
+ALTER TABLE "nylorun"."agents" ADD COLUMN "target_version" integer;--> statement-breakpoint
+ALTER TABLE "nylorun"."agents" ADD COLUMN "failed_version" integer;--> statement-breakpoint
+ALTER TABLE "nylorun"."agents" ADD COLUMN "start_check" json;

package/dist/store/postgres/drizzle/0034_protocol_17_session_queue.sql

@@ -0,0 +1,13 @@
+CREATE TABLE "nylorun"."session_queue" (
+	"id" text COLLATE "C" PRIMARY KEY NOT NULL,
+	"session_id" text COLLATE "C" NOT NULL,
+	"seq" bigint NOT NULL,
+	"command" json NOT NULL,
+	"input" json NOT NULL,
+	"file_artifacts" json NOT NULL,
+	"writer" json NOT NULL,
+	"trace" json,
+	"created_at" text COLLATE "C" NOT NULL
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX "session_queue_order" ON "nylorun"."session_queue" USING btree ("session_id","seq");

package/dist/store/postgres/drizzle/0035_t4_triggers.sql

@@ -0,0 +1,41 @@
+CREATE TABLE "nylorun"."agent_triggers" (
+	"agent_id" text COLLATE "C" NOT NULL,
+	"trigger_id" text COLLATE "C" NOT NULL,
+	"kind" text NOT NULL,
+	"status" text NOT NULL,
+	"paused_reason" text,
+	"generation" integer DEFAULT 0 NOT NULL,
+	"next_fire_at" text COLLATE "C",
+	"last_fire_at" text COLLATE "C",
+	"endpoint_id" text COLLATE "C",
+	"sealed_secret" json,
+	"session_id" text COLLATE "C",
+	"note" text,
+	"effect_id" text,
+	"created_at" text COLLATE "C" NOT NULL,
+	"updated_at" text COLLATE "C" NOT NULL,
+	CONSTRAINT "agent_triggers_pkey" PRIMARY KEY("agent_id","trigger_id")
+);
+--> statement-breakpoint
+CREATE TABLE "nylorun"."trigger_runs" (
+	"id" text COLLATE "C" PRIMARY KEY NOT NULL,
+	"agent_id" text COLLATE "C" NOT NULL,
+	"trigger_id" text COLLATE "C" NOT NULL,
+	"kind" text NOT NULL,
+	"run_key" text COLLATE "C" NOT NULL,
+	"due_at" text COLLATE "C" NOT NULL,
+	"fired_at" text COLLATE "C" NOT NULL,
+	"late" boolean DEFAULT false NOT NULL,
+	"status" text NOT NULL,
+	"reason" text,
+	"session_id" text COLLATE "C",
+	"turn_id" text COLLATE "C",
+	"queued_message_id" text COLLATE "C"
+);
+--> statement-breakpoint
+ALTER TABLE "nylorun"."session_queue" ADD COLUMN "cause" json;--> statement-breakpoint
+CREATE INDEX "agent_triggers_due" ON "nylorun"."agent_triggers" USING btree ("status","next_fire_at");--> statement-breakpoint
+CREATE UNIQUE INDEX "agent_triggers_endpoint" ON "nylorun"."agent_triggers" USING btree ("endpoint_id") WHERE endpoint_id IS NOT NULL;--> statement-breakpoint
+CREATE UNIQUE INDEX "trigger_runs_key" ON "nylorun"."trigger_runs" USING btree ("agent_id","run_key");--> statement-breakpoint
+CREATE INDEX "trigger_runs_agent" ON "nylorun"."trigger_runs" USING btree ("agent_id","id");--> statement-breakpoint
+CREATE INDEX "trigger_runs_fired" ON "nylorun"."trigger_runs" USING btree ("fired_at");

package/dist/store/postgres/drizzle/0036_t5_memories.sql

@@ -0,0 +1,30 @@
+CREATE TABLE "nylorun"."memories" (
+	"agent_id" text COLLATE "C" NOT NULL,
+	"path" text COLLATE "C" NOT NULL,
+	"content" text NOT NULL,
+	"content_sha256" text NOT NULL,
+	"bytes" integer NOT NULL,
+	"description" text,
+	"version" integer NOT NULL,
+	"updated_at" text COLLATE "C" NOT NULL,
+	CONSTRAINT "memories_pkey" PRIMARY KEY("agent_id","path")
+);
+--> statement-breakpoint
+CREATE TABLE "nylorun"."memory_versions" (
+	"id" text COLLATE "C" PRIMARY KEY NOT NULL,
+	"agent_id" text COLLATE "C" NOT NULL,
+	"path" text COLLATE "C" NOT NULL,
+	"from_path" text COLLATE "C",
+	"operation" text NOT NULL,
+	"content" text,
+	"content_sha256" text,
+	"bytes" integer,
+	"actor" text NOT NULL,
+	"session_id" text COLLATE "C",
+	"turn_id" text COLLATE "C",
+	"trigger_run_id" text COLLATE "C",
+	"created_at" text COLLATE "C" NOT NULL
+);
+--> statement-breakpoint
+CREATE INDEX "memory_versions_agent" ON "nylorun"."memory_versions" USING btree ("agent_id","id");--> statement-breakpoint
+CREATE INDEX "memory_versions_path" ON "nylorun"."memory_versions" USING btree ("agent_id","path","id");

package/dist/store/postgres/drizzle/0037_model_usage_cost_split.sql

@@ -0,0 +1,4 @@
+ALTER TABLE "nylorun"."model_usage" ADD COLUMN "cost_input_usd" double precision;--> statement-breakpoint
+ALTER TABLE "nylorun"."model_usage" ADD COLUMN "cost_cache_read_usd" double precision;--> statement-breakpoint
+ALTER TABLE "nylorun"."model_usage" ADD COLUMN "cost_cache_write_usd" double precision;--> statement-breakpoint
+ALTER TABLE "nylorun"."model_usage" ADD COLUMN "cost_output_usd" double precision;