@nylorun/runtime 0.46.2-beta → 0.47.1-beta

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 0.47.1-beta
+
+### Patch Changes
+
+- 3a8a080: Pods on Agent Substrate (preview): a crash that an idle suspend found now makes the Agent `failing`, and its `attention` names the crash (`compute crashed: Crashed: …`). Before, the crash appeared only in the Agent's events, and the Agent showed as sleeping. The entry stays until a turn starts the pod again, which reverts the sandbox to its last suspend.
+
+## 0.47.0-beta
+
+### Minor Changes
+
+- fe118db: The Tenant's sandbox settings round-trip, and `engine.images` comes back (#588).
+
+  - **Breaking (`@nylorun/runtime`, `@nylorun/core`, `@nylorun/admin`): `config` is the settings as stored.** `GET` and `PUT /v1/tenant/sandbox` (`admin.settings.sandbox`) answer `config` as the Tenant set it, with no defaults, in exactly the shape `PUT` takes (`limits.resources.memory: "8GiB"`), so `put(get().config)` changes nothing and saves no default as a setting. The settings in force, every default filled in and sizes in MiB (`memoryMiB`), are `effective`, which is what `config` was. Before, `PUT` refused what `GET` answered (`unrecognized_keys "memoryMiB"`). Read the settings in force from `effective` (`view.effective.limits.resources.memoryMiB`), and build a `PUT` body from `view.config`. `TenantSandboxViewSchema` has `config: TenantEnvironmentsConfigSchema` and `effective: EffectiveSandboxConfigSchema`.
+  - **`engine.images` is answered.** A `PUT` with `engine.images` was stored and used, but left out of its answer and of the next `GET`. Both now carry it, in `config` as set and in `effective` (`[]` when unset).
+  - `@nylorun/studio`: Edit compute settings puts the stored settings with only the fields it changed, so it no longer erases `engine.images` set through the API, keeps `placement`, and saves no default as a setting; clearing idle, stop grace or most Agents puts back the default. The Compute tab lists the engine images.
+  - `nylorun`: `nylorun tenant settings sandbox put` takes what `get` printed and puts back its `config`. `nylorun doctor sandbox` reads the limits in force from `effective`, or from `config` on an older Runtime.
+
+### Patch Changes
+
+- fe118db: An A2A `SendMessage` with `returnImmediately` to a busy context answers `TASK_STATE_SUBMITTED` (#586), and `CancelTask` on a queued task answers `TASK_STATE_CANCELED` (#585), instead of `TaskNotFoundError` while the session's stream still lags behind the record. Both replies now wait, up to 5 s, for the stream to hold the request's own write, and a queued task's `GetTask` answers `SUBMITTED` from its queue row until then.
+- 71c6741: Pods on Agent Substrate (preview): a crashed sandbox is now recorded in the Agent's events. A running pod whose sandbox crashed is `failed` at once, rather than after the 5-minute ready deadline. A crash that an idle suspend finds is also recorded, where before the Agent showed only `agent.suspended`. In both cases `agent.failed` gives Substrate's crash message and says that what the Agent wrote since its last suspend is lost. The next turn reverts the sandbox to that suspend, as before. The sandboxes service now reports the crash's own message in place of the whole crash record.
+- fe118db: A message's `removeTools` turns a Runtime plugin's tool off by its own name too: `memory` now does what `nylorun__memory` does, so the name events and `check --explain` showed no longer leaves the tool on without a word (#589). `nylorun check --explain` lists a plugin's tools by the names the model reads (`nylorun__memory`, `nylorun__update_plan`), the ones `removeTools` and tool policy take, and its memory note says the index is pinned again at a turn after a write from elsewhere (#590, #591).
+- Pin core to the tested release.
+- Pin harness to the tested release.
+- Updated dependencies [fe118db]
+- Updated dependencies [fe118db]
+- Updated dependencies
+  - @nylorun/core@0.41.0-beta
+  - @nylorun/harness@0.36.1-beta
+
 ## 0.46.2-beta
 
 ### Patch Changes

package/dist/api/a2a/routes.js

@@ -44,7 +44,7 @@ import { A2aError, a2aFail, checkVersion, jsonRpcError, jsonRpcResult, parseCrea
 import { configView, kickPushes, pushEnabled, pushPolicy, savePushConfig, } from "./push.js";
 import { ENDED, SETTLED_EVENTS, buildTask, callerTraceId, contextSessionId, droppedTask, endsQueued, newContextId, parseTaskId, pendingInteraction, pendingInteractions, submittedTask, taskIdOf, } from "./tasks.js";
 import { currentModelDescriptor } from "../../model/descriptor.js";
-import { decodeCursor } from "../../record/cursor.js";
+import { decodeCursor, encodeCursor } from "../../record/cursor.js";
 import { accessOf } from "../../tenant/auth.js";
 import { cancelQueuedMessage, command } from "../../tenant/commands.js";
 import { loadSession, reachesAgent, } from "../../tenant/context.js";
@@ -218,7 +218,8 @@ async function indexedTask(caller, row, session, options = {}) {
  * index keeps the queued messages each turn took) the task is that turn's, under the id the
  * caller knows. A queued message that failed or was cancelled before a turn took it (Host feature
  * `queue-recovery`) is `FAILED` or `CANCELED`, from the event that ended it. Only a message still
- * in the queue, or no longer in it and taken by no turn, is looked for in the session's history.
+ * in the queue, or no longer in it and taken by no turn, is looked for in the session's history;
+ * one still in the queue is `SUBMITTED` from its row while the stream lags behind the record.
  */
 async function ownedTask(caller, taskId, historyLength) {
     const ids = parseTaskId(taskId) ?? taskNotFound(taskId);
@@ -229,8 +230,9 @@ async function ownedTask(caller, taskId, historyLength) {
         if (turn)
             return { turn };
         // Still queued, or taken: the queue is read first, so a message taken meanwhile is found.
-        if ((await t.queuedMessages(sessionId)).some((row) => row.id === ids.turnId))
-            return { queued: true };
+        const row = (await t.queuedMessages(sessionId)).find((row) => row.id === ids.turnId);
+        if (row)
+            return { row };
         const taken = await t.turnOfQueuedMessage(sessionId, ids.turnId);
         return taken ? { turn: taken } : {};
     });
@@ -242,8 +244,10 @@ async function ownedTask(caller, taskId, historyLength) {
         const owned = { session, sessionId, contextId: ids.contextId, turnId: ids.turnId, events: [] };
         if (dropped)
             return { ...owned, task: droppedTask(ids.contextId, taskId, dropped), dropped };
-        if (queued && found.queued)
-            return { ...owned, task: submittedTask(ids.contextId, taskId, queued), queued };
+        if (found.row) {
+            const since = queued?.time ?? found.row.createdAt;
+            return { ...owned, task: submittedTask(ids.contextId, taskId, since), queued: queued ?? found.row };
+        }
     }
     const row = found.turn ?? taskNotFound(taskId);
     const built = (await indexedTask(caller, { ...row, a2aContextId: ids.contextId }, session, {
@@ -361,7 +365,10 @@ async function sendMessage(caller, params, signal) {
             nextSeq: decodeCursor(sessionId, accepted.cursor),
             ...(accepted.turnId !== undefined ? { traceId: await sendTraceId(caller, sessionId, accepted.turnId) } : {}),
         });
-    if (!send.returnImmediately)
+    // The task is read from the stream: it must hold the message this request wrote.
+    if (send.returnImmediately)
+        await caughtUp(caller.ctx, sessionId, accepted.cursor, signal);
+    else
         await settled(caller.ctx, sessionId, accepted, signal);
     const { task } = await ownedTask(caller, taskId, send.historyLength);
     return { task };
@@ -509,17 +516,30 @@ function replyTarget(owned) {
 /**
  * `CancelTask`. A queued task (`SUBMITTED`) leaves its context's queue and is `CANCELED`
  * (`queue.cancelled`, pushed), whether a task runs in the context or not (Host feature
- * `queue-recovery`); one a turn took meanwhile is cancelled as that turn. A running or waiting
- * task's turn is cancelled. An ended task is not cancelable, unless it is `CANCELED` already.
+ * `queue-recovery`); one a turn took meanwhile is cancelled as that turn. The answer waits for
+ * the stream to hold the `queue.cancelled` it wrote (`caughtUp`). A running or waiting task's turn
+ * is cancelled. An ended task is not cancelable, unless it is `CANCELED` already.
  */
 async function cancelTask(caller, taskId, again = true) {
     const owned = await ownedTask(caller, taskId);
     if (owned.queued) {
         const cancelled = await cancelQueuedMessage(caller.ctx, owned.sessionId, owned.turnId, caller.scope, "Canceled by the A2A client");
         // Gone from the queue meanwhile: a turn took it, or it failed. Answer as the task is now.
-        if (!cancelled && again)
-            return cancelTask(caller, taskId, false);
-        return (await ownedTask(caller, taskId)).task;
+        if (!cancelled)
+            return again ? cancelTask(caller, taskId, false) : (await ownedTask(caller, taskId)).task;
+        await caughtUp(caller.ctx, owned.sessionId, cancelled.cursor);
+        const after = await ownedTask(caller, taskId).catch((error) => {
+            if (error instanceof A2aError && error.kind === "taskNotFound")
+                return undefined;
+            throw error;
+        });
+        // The stream still lags behind `queue.cancelled`: the cancel committed, so it is CANCELED.
+        return (after?.task ?? {
+            id: taskId,
+            contextId: owned.contextId,
+            status: { state: "TASK_STATE_CANCELED", timestamp: new Date().toISOString() },
+            history: [],
+        });
     }
     if (owned.session.activeTurnId !== owned.turnId) {
         if (owned.task.status.state === "TASK_STATE_CANCELED")
@@ -577,7 +597,9 @@ async function createPushConfig(caller, params) {
     requirePush(caller);
     const { taskId, config } = parseCreatePushParams(params);
     const owned = await ownedTask(caller, taskId);
-    const last = owned.dropped ?? owned.queued ?? owned.events.at(-1);
+    // A queued task the stream has not caught up with is followed from the session's start.
+    const queued = owned.queued && "type" in owned.queued ? owned.queued : undefined;
+    const last = owned.dropped ?? queued ?? owned.events.at(-1);
     const ended = owned.dropped !== undefined || owned.events.some((event) => ENDED.has(event.type));
     const configId = config.id ?? createHash("sha256").update(`${config.url}\u0000${config.token ?? ""}`).digest("hex").slice(0, 16);
     return registerPush(caller, { ...config, id: configId }, {
@@ -622,6 +644,40 @@ async function deletePushConfig(caller, params) {
     await caller.ctx.store.tx((t) => t.deletePushConfig(owned.sessionId, owned.task.id, ref.id));
     return {};
 }
+/** How long a reply waits for the session's stream to hold the request's own write. */
+const OWN_WRITE_WAIT_MS = 5_000;
+/**
+ * Waits until the session's stream holds the event at `cursor`, which this request wrote: the
+ * relay copies it from the record a little after the commit, and replies are read from the
+ * stream. Ends after `OWN_WRITE_WAIT_MS`, when the caller hangs up, or when the feed ends; the
+ * reply then says what the stream and the store say.
+ */
+async function caughtUp(ctx, sessionId, cursor, signal) {
+    const seq = decodeCursor(sessionId, cursor);
+    const stop = new AbortController();
+    const timer = setTimeout(() => stop.abort(), OWN_WRITE_WAIT_MS);
+    timer.unref();
+    const hangup = () => stop.abort();
+    signal?.addEventListener("abort", hangup, { once: true });
+    if (signal?.aborted)
+        stop.abort();
+    try {
+        // The feed yields what follows a cursor: start from the event before.
+        const before = seq > 0 ? encodeCursor(sessionId, seq - 1) : undefined;
+        for await (const event of observeSession(ctx, sessionId, before, { signal: stop.signal }))
+            if (event.seq >= seq)
+                return;
+    }
+    catch (error) {
+        // A session or streams gone: the reply says so.
+        if (!(error instanceof HttpError))
+            throw error;
+    }
+    finally {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", hangup);
+    }
+}
 /**
  * Waits until the task's turn ends, pauses or has an uncertain effect, the caller hangs up, or
  * the Tenant's Runtime limit `a2aWaitMs` passes: after it, the task is returned as it is

package/dist/api/a2a/tasks.d.ts

@@ -121,10 +121,10 @@ export interface BuildTaskInput {
  */
 export declare function buildTask(input: BuildTaskInput): Task | undefined;
 /**
- * A queued message's task while it waits (profile v2 §1): `SUBMITTED`, from its `message.queued`
- * event, until a turn takes it.
+ * A queued message's task while it waits (profile v2 §1): `SUBMITTED` since `queuedAt` (its
+ * `message.queued` event's time, or its queue row's), until a turn takes it.
  */
-export declare function submittedTask(contextId: string, taskId: string, queued: LiveEvent): Task;
+export declare function submittedTask(contextId: string, taskId: string, queuedAt: string): Task;
 /**
  * A queued message's task that ended without a turn (Host feature `queue-recovery`), from the
  * `queue.failed` or `queue.cancelled` event that names it: `FAILED`, saying why it never started,

package/dist/api/a2a/tasks.js

@@ -488,14 +488,14 @@ export function buildTask(input) {
     };
 }
 /**
- * A queued message's task while it waits (profile v2 §1): `SUBMITTED`, from its `message.queued`
- * event, until a turn takes it.
+ * A queued message's task while it waits (profile v2 §1): `SUBMITTED` since `queuedAt` (its
+ * `message.queued` event's time, or its queue row's), until a turn takes it.
  */
-export function submittedTask(contextId, taskId, queued) {
+export function submittedTask(contextId, taskId, queuedAt) {
     return {
         id: taskId,
         contextId,
-        status: { state: "TASK_STATE_SUBMITTED", timestamp: queued.time },
+        status: { state: "TASK_STATE_SUBMITTED", timestamp: queuedAt },
         history: [],
     };
 }

package/dist/api/components.d.ts

@@ -15896,6 +15896,33 @@ export declare const TenantSandboxView: z.ZodObject<{
     }, z.core.$strict>>;
     defaultImage: z.ZodString;
     config: z.ZodObject<{
+        limits: z.ZodOptional<z.ZodObject<{
+            network: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            resources: z.ZodOptional<z.ZodObject<{
+                cpus: z.ZodOptional<z.ZodNumber>;
+                memory: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            defaultResources: z.ZodOptional<z.ZodObject<{
+                cpus: z.ZodOptional<z.ZodNumber>;
+                memory: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            idle: z.ZodOptional<z.ZodString>;
+            environments: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        lifecycle: z.ZodOptional<z.ZodObject<{
+            stopGrace: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        engine: z.ZodOptional<z.ZodObject<{
+            images: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        placement: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            hosts: z.ZodArray<z.ZodEnum<{
+                "harness-container": "harness-container";
+                sandbox: "sandbox";
+            }>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+    effective: z.ZodObject<{
         limits: z.ZodObject<{
             network: z.ZodArray<z.ZodString>;
             resources: z.ZodObject<{
@@ -15918,6 +15945,9 @@ export declare const TenantSandboxView: z.ZodObject<{
                 sandbox: "sandbox";
             }>>;
         }, z.core.$strict>>>;
+        engine: z.ZodOptional<z.ZodObject<{
+            images: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
     }, z.core.$strict>;
     cluster: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         namespace: z.ZodString;

package/dist/api/http/routes/tenant.js

@@ -50,15 +50,21 @@ const budgetView = (row) => ({
     ...(row.limitUsd !== null ? { limitUsd: row.limitUsd } : {}),
     ...(row.limitTokens !== null ? { limitTokens: row.limitTokens } : {}),
 });
-/** `GET /v1/tenant/sandbox`: the backend report and the configuration with defaults applied. */
+/**
+ * `GET /v1/tenant/sandbox`: the backend report, the settings as stored (`config`, what `PUT`
+ * takes, so a client can put it back changed) and the configuration in force (`effective`).
+ */
 async function sandboxView(ctx) {
     const config = await ctx.store.tx((t) => readSandboxConfig(t));
     return {
         ...(await ctx.sandbox.report()),
-        config: effectiveSandboxConfig(config),
+        config,
+        effective: effectiveSandboxConfig(config),
         cluster: await clusterOf(ctx),
     };
 }
+/** What the sandbox routes answer, for their descriptions. */
+const SANDBOX_VIEW_TEXT = "`config` is the Tenant's settings as stored: only what it set, in exactly the shape `PUT` takes, so a client changes one setting by putting `config` back with that change. `effective` is the configuration in force: `config` with every default filled in, sizes in MiB (`memoryMiB`).";
 /** The Tenant's cluster for pod sandboxes (F7.2), from the sandboxes service; null without one. */
 async function clusterOf(ctx) {
     if (!ctx.pods)
@@ -224,16 +230,21 @@ export function tenantRoutes(api) {
         path: "/v1/tenant/sandbox",
         tags: ["Tenant"],
         summary: "Get the Tenant's sandbox backend and Agent compute settings",
-        responses: { 200: json(TenantSandboxView, "The backend in use and the configuration in force") },
+        description: SANDBOX_VIEW_TEXT,
+        responses: {
+            200: json(TenantSandboxView, "The backend in use, the settings as stored and the configuration in force"),
+        },
     }, async (c) => jsonResponse(200, await sandboxView(c.env.tenant)));
     tenantRoute(api, MANAGEMENT, {
         method: "put",
         path: "/v1/tenant/sandbox",
         tags: ["Tenant"],
         summary: "Set the Tenant's Agent compute settings",
-        description: "The limits every Agent's runtime must fit, the pods' stop grace and where harnesses may run (Tenant setting `environments.config`).",
+        description: `Replaces the Tenant's settings (Tenant setting \`environments.config\`): the limits every Agent's runtime must fit, the pods' stop grace, the images that carry the engine (\`engine.images\`) and where harnesses may run. A setting left out takes its default. Answers like \`GET\`: ${SANDBOX_VIEW_TEXT}`,
         request: { body: body(PutTenantEnvironmentsRequest) },
-        responses: { 200: json(TenantSandboxView, "The configuration now in force") },
+        responses: {
+            200: json(TenantSandboxView, "The settings now stored and the configuration now in force"),
+        },
     }, async (c) => {
         const ctx = c.env.tenant;
         const { requestId: _requestId, ...config } = PutTenantEnvironmentsRequestSchema.parse(await readJson(c));

package/dist/management-openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.2.0",
   "info": {
     "title": "Nylorun Management API",
-    "version": "0.46.2-beta",
+    "version": "0.47.1-beta",
     "x-nylorun-protocol": {
       "min": 16,
       "max": 18,
@@ -2144,6 +2144,104 @@
             "type": "string"
           },
           "config": {
+            "type": "object",
+            "properties": {
+              "limits": {
+                "type": "object",
+                "properties": {
+                  "network": {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
+                  },
+                  "resources": {
+                    "type": "object",
+                    "properties": {
+                      "cpus": {
+                        "type": "integer",
+                        "minimum": 1
+                      },
+                      "memory": {
+                        "type": "string"
+                      }
+                    },
+                    "additionalProperties": false
+                  },
+                  "defaultResources": {
+                    "type": "object",
+                    "properties": {
+                      "cpus": {
+                        "type": "integer",
+                        "minimum": 1
+                      },
+                      "memory": {
+                        "type": "string"
+                      }
+                    },
+                    "additionalProperties": false
+                  },
+                  "idle": {
+                    "type": "string"
+                  },
+                  "environments": {
+                    "type": "integer",
+                    "minimum": 0
+                  }
+                },
+                "additionalProperties": false
+              },
+              "lifecycle": {
+                "type": "object",
+                "properties": {
+                  "stopGrace": {
+                    "type": "string"
+                  }
+                },
+                "additionalProperties": false
+              },
+              "engine": {
+                "type": "object",
+                "properties": {
+                  "images": {
+                    "type": "array",
+                    "items": {
+                      "type": "string",
+                      "minLength": 1,
+                      "maxLength": 256,
+                      "pattern": "^[a-z0-9]([a-z0-9._:/-]*[a-z0-9])?$"
+                    },
+                    "maxItems": 32
+                  }
+                },
+                "additionalProperties": false
+              },
+              "placement": {
+                "type": "object",
+                "additionalProperties": {
+                  "type": "object",
+                  "properties": {
+                    "hosts": {
+                      "type": "array",
+                      "items": {
+                        "type": "string",
+                        "enum": [
+                          "harness-container",
+                          "sandbox"
+                        ]
+                      }
+                    }
+                  },
+                  "required": [
+                    "hosts"
+                  ],
+                  "additionalProperties": false
+                }
+              }
+            },
+            "additionalProperties": false
+          },
+          "effective": {
             "type": "object",
             "properties": {
               "limits": {
@@ -2236,6 +2334,21 @@
                   ],
                   "additionalProperties": false
                 }
+              },
+              "engine": {
+                "type": "object",
+                "properties": {
+                  "images": {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
+                  }
+                },
+                "required": [
+                  "images"
+                ],
+                "additionalProperties": false
               }
             },
             "required": [
@@ -2300,7 +2413,8 @@
           "reason",
           "probes",
           "defaultImage",
-          "config"
+          "config",
+          "effective"
         ],
         "additionalProperties": false
       },
@@ -6841,6 +6955,7 @@
           "Settings"
         ],
         "summary": "Get the Tenant's sandbox backend and Agent compute settings",
+        "description": "`config` is the Tenant's settings as stored: only what it set, in exactly the shape `PUT` takes, so a client changes one setting by putting `config` back with that change. `effective` is the configuration in force: `config` with every default filled in, sizes in MiB (`memoryMiB`).",
         "security": [
           {
             "managementKey": []
@@ -6864,7 +6979,7 @@
         ],
         "responses": {
           "200": {
-            "description": "The backend in use and the configuration in force",
+            "description": "The backend in use, the settings as stored and the configuration in force",
             "content": {
               "application/json": {
                 "schema": {
@@ -6940,7 +7055,7 @@
           "Settings"
         ],
         "summary": "Set the Tenant's Agent compute settings",
-        "description": "The limits every Agent's runtime must fit, the pods' stop grace and where harnesses may run (Tenant setting `environments.config`).",
+        "description": "Replaces the Tenant's settings (Tenant setting `environments.config`): the limits every Agent's runtime must fit, the pods' stop grace, the images that carry the engine (`engine.images`) and where harnesses may run. A setting left out takes its default. Answers like `GET`: `config` is the Tenant's settings as stored: only what it set, in exactly the shape `PUT` takes, so a client changes one setting by putting `config` back with that change. `effective` is the configuration in force: `config` with every default filled in, sizes in MiB (`memoryMiB`).",
         "security": [
           {
             "managementKey": []
@@ -6974,7 +7089,7 @@
         },
         "responses": {
           "200": {
-            "description": "The configuration now in force",
+            "description": "The settings now stored and the configuration now in force",
             "content": {
               "application/json": {
                 "schema": {

package/dist/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.2.0",
   "info": {
     "title": "Nylorun Runtime API",
-    "version": "0.46.2-beta",
+    "version": "0.47.1-beta",
     "x-nylorun-protocol": {
       "min": 16,
       "max": 18,

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

@@ -21,6 +21,10 @@
  *   ran on for days. A timer that fires during a turn looks again one idle period later.
  *   Becoming ready moves `lastActiveAt` to that moment, so a slow start doesn't use up the
  *   idle period before the pod can take a turn.
+ * - **Crashed** (Agent Substrate): a running pod whose sandbox crashed is `failed` at once
+ *   (`agent.failed`, saying what the Agent lost); a crash an idle suspend finds is recorded the
+ *   same way. The next turn start asks for `Running`, and the sandboxes service reverts the
+ *   sandbox to its last suspend before resuming it.
  * - **Lost**: an incarnation that has run (a pod joined) whose Sandbox is gone or whose volume
  *   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
@@ -58,6 +62,14 @@ export declare function repositoryOf(reference: string): string;
 export declare function imageDigestOf(imageID: string | undefined, requested: string): string | undefined;
 /** A setup failure's `reason` starts with this (`sandbox/setup.ts`); it is sticky. */
 export declare const SETUP_FAILED = "setup:";
+/** A crash's `reason` (see `crashReasonOf`) starts with this; it stays until a turn starts the pod. */
+export declare const CRASHED = "Crashed: ";
+/**
+ * A sandbox that crashed (Agent Substrate: its worker went away, or a wake failed) lost what its
+ * Agent wrote since its last suspend; the next start reverts it to that suspend. The reason
+ * `agent.failed` records, or undefined when the sandbox has not crashed.
+ */
+export declare function crashReasonOf(status: PodStatus): string | undefined;
 /** The lifecycle settings (D36), read each time a decision is made. */
 export interface PodLifecycleConfig {
     readonly idleMs: number;

package/dist/sandbox/pods/lifecycle.js

@@ -36,6 +36,19 @@ export function imageDigestOf(imageID, requested) {
 }
 /** A setup failure's `reason` starts with this (`sandbox/setup.ts`); it is sticky. */
 export const SETUP_FAILED = "setup:";
+/** A crash's `reason` (see `crashReasonOf`) starts with this; it stays until a turn starts the pod. */
+export const CRASHED = "Crashed: ";
+/**
+ * A sandbox that crashed (Agent Substrate: its worker went away, or a wake failed) lost what its
+ * Agent wrote since its last suspend; the next start reverts it to that suspend. The reason
+ * `agent.failed` records, or undefined when the sandbox has not crashed.
+ */
+export function crashReasonOf(status) {
+    if (status.reason !== "Crashed")
+        return undefined;
+    const what = status.message?.trim() || "the sandbox stopped";
+    return `${CRASHED}${what}. What the Agent wrote since its last suspend is lost; its next turn starts it from that suspend.`;
+}
 /** The service's operation id of the row's current spec. */
 export function opIdOf(pod) {
     return `${pod.k8sName}.r${pod.rev}`;
@@ -195,9 +208,19 @@ export function decide(facts) {
         const startedAt = Date.parse(pod.startedAt ?? row.updatedAt);
         if (pod.observed === "failed")
             return done();
+        // A pod that was running and crashed will not come back by itself: failed now, not at the
+        // ready deadline. One still starting is left to its wake, which reverts a crashed sandbox.
+        const crash = crashReasonOf(status);
+        if (crash !== undefined && pod.observed === "running") {
+            patch.observed = "failed";
+            patch.reason = crash;
+            events.push(event("agent.failed", { reason: crash }));
+            return done();
+        }
         if (now - startedAt >= readyDeadlineMs) {
-            const reason = [status.reason, status.message].filter(Boolean).join(": ") ||
-                `The pod was not ready within ${Math.round(readyDeadlineMs / 1000)} s`;
+            const reason = crash ??
+                ([status.reason, status.message].filter(Boolean).join(": ") ||
+                    `The pod was not ready within ${Math.round(readyDeadlineMs / 1000)} s`);
             patch.observed = "failed";
             patch.reason = reason;
             events.push(event("agent.failed", { reason }));
@@ -212,6 +235,13 @@ export function decide(facts) {
     if (status.suspended || !status.podPhase) {
         if (pod.observed !== "suspended")
             patch.observed = "suspended";
+        // A suspend can find the sandbox already crashed (the idle timer fired before anything saw
+        // the crash): record the crash once, so its owner learns what it lost.
+        const crash = crashReasonOf(status);
+        if (crash !== undefined && pod.reason !== crash) {
+            patch.reason = crash;
+            events.push(event("agent.failed", { reason: crash }));
+        }
         return done();
     }
     again(pollMs);

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

@@ -1,7 +1,7 @@
 /**
  * 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.
+ * every Environment's recipe must fit, the pods' stop grace, the images that carry the engine and
+ * the harness placement. Unset fields take the defaults below.
  */
 import { type PlacementHost, type TenantEnvironmentsConfig } from "@nylorun/core/contracts";
 import { DEFAULT_SANDBOX_IDLE } from "./policy.js";
@@ -36,6 +36,10 @@ export interface EffectiveSandboxConfig {
     readonly placement: Readonly<Record<string, {
         readonly hosts: readonly PlacementHost[];
     }>>;
+    /** Pods: the image repositories that carry this Runtime's engine (ADR-99). */
+    readonly engine: {
+        readonly images: readonly string[];
+    };
 }
 interface SettingsReader {
     getSetting(key: string): Promise<string | undefined>;

package/dist/sandbox/tenant-config.js

@@ -1,7 +1,7 @@
 /**
  * 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.
+ * every Environment's recipe must fit, the pods' stop grace, the images that carry the engine and
+ * the harness placement. Unset fields take the defaults below.
  */
 import { TenantEnvironmentsConfigSchema, } from "@nylorun/core/contracts";
 import { parseSandboxSize } from "@nylorun/core/define";
@@ -42,6 +42,7 @@ export function effectiveSandboxConfig(config) {
         },
         lifecycle: { stopGrace: config.lifecycle?.stopGrace ?? "10s" },
         placement: config.placement ?? { "*": { hosts: ["harness-container", "sandbox"] } },
+        engine: { images: config.engine?.images ?? [] },
     };
 }
 /** The stored configuration, or `{}` when the Tenant has none. */

package/dist/tenant/agents.js

@@ -55,7 +55,7 @@ import { sandboxWorkspaceKey } from "../sandbox/records.js";
 import { effectiveSandboxConfig, readSandboxConfig } from "../sandbox/tenant-config.js";
 import { podName } from "../sandbox/pods/name.js";
 import { podLifecycleConfig } from "../sandbox/pods/spec.js";
-import { SETUP_FAILED } from "../sandbox/pods/lifecycle.js";
+import { CRASHED, SETUP_FAILED } from "../sandbox/pods/lifecycle.js";
 import { requirePods } from "../sandbox/placement.js";
 import { deleteDiskArtifact, forkSeedOf, runPendingSeed, snapshotEnvironment } from "../artifacts/disk.js";
 import { manifestChanges, manifestRecipeRequest } from "./agent-manifests.js";
@@ -128,6 +128,10 @@ export function stateOf(agent, sessions, unsetSecrets = []) {
     const pod = agent.pod;
     if (pod && (pod.observed === "failed" || pod.observed === "lost") && pod.desired !== "deleted")
         attention.push({ state: "failing", reason: `compute ${pod.observed}${pod.reason ? `: ${pod.reason}` : ""}` });
+    // A crash an idle suspend found leaves the pod suspended, not failed: what the Agent wrote since
+    // its last suspend is gone all the same, so it is named until a turn starts the pod again.
+    else if (pod && pod.reason?.startsWith(CRASHED) && pod.desired !== "deleted")
+        attention.push({ state: "failing", reason: `compute crashed: ${pod.reason}` });
     // A start on a new version failed and went back (track T3): until a start on a new one succeeds.
     if (agent.failedVersion !== undefined)
         attention.push({ state: "failing", reason: `start_failed: version ${agent.failedVersion} did not start` });

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const RUNTIME_VERSION = "0.46.2-beta";
+export declare const RUNTIME_VERSION = "0.47.1-beta";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Kept in step with package.json by runtime/server/scripts/check-package.mjs, which runs in npm run check.
 // release:prepare also rewrites this when it bumps @nylorun/runtime.
-export const RUNTIME_VERSION = "0.46.2-beta";
+export const RUNTIME_VERSION = "0.47.1-beta";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nylorun/runtime",
-  "version": "0.46.2-beta",
+  "version": "0.47.1-beta",
   "description": "Nylorun Runtime: the agent execution Host on Postgres, Restate and S2, and model providers.",
   "type": "module",
   "license": "Apache-2.0",
@@ -65,8 +65,8 @@
     "@hono/node-server": "^2.1.5",
     "@hono/zod-openapi": "^1.6.3",
     "@modelcontextprotocol/sdk": "^1.32.1",
-    "@nylorun/core": "0.40.0-beta",
-    "@nylorun/harness": "0.36.0-beta",
+    "@nylorun/core": "0.41.0-beta",
+    "@nylorun/harness": "0.36.1-beta",
     "@restatedev/restate-sdk": "1.17.3",
     "@restatedev/restate-sdk-clients": "1.17.3",
     "@s2-dev/streamstore": "0.28.0",