@nylorun/runtime 0.43.0-beta → 0.44.1-beta

package/dist/tenant/commands.d.ts

@@ -55,8 +55,8 @@ export type MessageAnswer = {
 /**
  * Takes a resolved message on session `s` (locked) in transaction `t`: it starts a turn when the
  * session takes messages and none wait, else it waits in the queue behind them (protocol 17), and
- * an idle session whose queue was left waiting (its Agent was unavailable when the last turn
- * ended) starts a turn with all of them, this one last. Past `sessionQueuedMessages` it is
+ * an idle session whose queue was left waiting (its Agent refused the start when the last turn
+ * ended, `startQueuedTurn`) tries the start again with all of them, this one last. Past `sessionQueuedMessages` it is
  * `429 queue_full`. `waiting` is the queue's length, read under the session's lock. `asked`
  * `steer` (D85) marks a waiting message so the running turn may take it before a step; a
  * workflow session can't, so it waits as `queue`.
@@ -76,16 +76,45 @@ export declare function takeSteeredMessages(t: Tx, s: Session, id: string, step:
 export declare const QUEUE_SCOPE: AuthScope;
 /**
  * Starts the next turn of session `s` (locked) from its queue, when it takes messages and messages
- * wait (protocol 17, D76): in the transaction that ended the last turn, or a cancel's. Our engine
- * takes every queued message that carries the same turn manifest as the first, a workflow one.
- * Writes `queue.taken`. Returns nothing when nothing started: an empty queue, or an Agent that
- * cannot take a turn now, whose messages wait for the next message or turn end.
+ * wait (protocol 17, D76): in the transaction that ended the last turn, a cancel's, a message's
+ * that joined a queue left waiting, or the Tenant sweep's (`retryQueuedStarts`). Our engine takes
+ * every queued message that carries the same turn manifest as the first, a workflow one. Writes
+ * `queue.taken`. Returns nothing when nothing started: an empty queue, or an Agent that refused
+ * the start.
+ *
+ * A refusal a later try may get past (`RETRIED_REFUSALS`) leaves the messages waiting, with
+ * `s.queueStalled` saying since when and why (written here); the next message, the sweep and the
+ * end of a disk copy try again. A message that has waited longer than the Runtime limit
+ * `queuedStartMs` since the stall began (or since it was queued, when later) fails with
+ * `queue.failed` (`queue.start_expired`); a refusal no retry changes fails the messages it refused
+ * at once (`queue.start_refused`). Either way the messages behind them are tried next (Host
+ * feature `queue-recovery`).
  */
-export declare function startQueuedTurn(ctx: TenantContext, t: Tx, s: Session, id: string): Promise<{
+export declare function startQueuedTurn(ctx: TenantContext, t: Tx, s: Session, id: string, now?: Date): Promise<{
     turnId: string;
     taken: string[];
     cursor: string;
 } | undefined>;
+/**
+ * Removes queued message `queuedMessageId` from session `id`'s queue, as `scope` (Host feature
+ * `queue-recovery`): `queue.cancelled`, written by the caller. A turn running or not, the message
+ * never starts one. Returns the event's cursor, or undefined when the message no longer waits (a
+ * turn took it, or it failed or was cancelled already).
+ */
+export declare function cancelQueuedMessage(ctx: TenantContext, id: string, queuedMessageId: string, scope: AuthScope, reason?: string): Promise<{
+    cursor: string;
+} | undefined>;
+/**
+ * Tries again the turn start of every queue a refused start left waiting, one transaction per
+ * session (Host feature `queue-recovery`): the Tenant sweep's step, and what the end of an Agent's
+ * disk copy runs for that Agent's sessions (`environmentId`). Each start fails its messages past
+ * `queuedStartMs` (`startQueuedTurn`). Returns the sessions whose queue started a turn.
+ */
+export declare function retryQueuedStarts(ctx: TenantContext, options?: {
+    environmentId?: string;
+    now?: Date;
+    batchSize?: number;
+}): Promise<string[]>;
 /**
  * Who sent a command (R4.9), from its credential and never its body: a client over the Runtime
  * API (an application, or a person through it or a token), or core itself.

package/dist/tenant/commands.js

@@ -19,7 +19,9 @@
  * (`session_queue`, `message.queued`) unless it asks `delivery: "reject"`, which is
  * `409 session_busy`. A turn that ends takes every queued message in the same transaction
  * (`startQueuedTurn`): client messages and queued ones start a turn through one door,
- * `beginMessageTurn`, which writes each one's `command.message`. A message that asks
+ * `beginMessageTurn`, which writes each one's `command.message`. A start the Agent refuses leaves
+ * the queue waiting, tried again by the Tenant sweep until the Runtime limit `queuedStartMs`, then
+ * failed (`queue.failed`, Host feature `queue-recovery`). A message that asks
  * `delivery: "steer"` (D85) waits marked `steer`, and the running turn takes it before a step
  * (`takeSteeredMessages`, the `inputs` effect); one it doesn't take starts the next turn like
  * any other.
@@ -300,8 +302,8 @@ export const takesMessages = (s) => TAKES_MESSAGES.includes(s.status);
 /**
  * Takes a resolved message on session `s` (locked) in transaction `t`: it starts a turn when the
  * session takes messages and none wait, else it waits in the queue behind them (protocol 17), and
- * an idle session whose queue was left waiting (its Agent was unavailable when the last turn
- * ended) starts a turn with all of them, this one last. Past `sessionQueuedMessages` it is
+ * an idle session whose queue was left waiting (its Agent refused the start when the last turn
+ * ended, `startQueuedTurn`) tries the start again with all of them, this one last. Past `sessionQueuedMessages` it is
  * `429 queue_full`. `waiting` is the queue's length, read under the session's lock. `asked`
  * `steer` (D85) marks a waiting message so the running turn may take it before a step; a
  * workflow session can't, so it waits as `queue`.
@@ -464,6 +466,8 @@ async function beginMessageTurn(t, s, id, messages) {
         });
     }
     s.turnStartState = s.state;
+    // A turn holds the session now: its queue, if any, waits for the turn, not for the Agent.
+    delete s.queueStalled;
     // A new turn folds from the latest snapshot: a cancel or failure only reverts this turn.
     if (s.history?.snapshot !== undefined)
         s.history = { ...s.history, from: s.history.snapshot };
@@ -499,52 +503,166 @@ async function beginMessageTurn(t, s, id, messages) {
 }
 /** Who checks a queued message's turn start: core, since the sender's grants were checked when it was queued. */
 export const QUEUE_SCOPE = { kind: "application", principalId: "queue" };
+/**
+ * The refusals of a queued turn's start that a later try may get past (Host feature
+ * `queue-recovery`): the Agent's disk is being copied or it is being deleted (`agent_busy`), it
+ * can't run now or was deleted and may be made again (`agent_unavailable`), its pod was lost and
+ * may be reset (`agent_lost`). Any other refusal (a turn request the version no longer resolves,
+ * another harness, another owner's Agent) fails the messages at once.
+ */
+const RETRIED_REFUSALS = new Set(["agent_busy", "agent_unavailable", "agent_lost"]);
+const retried = (error) => error.status === 429 ||
+    error.status === 503 ||
+    (error.status === 409 && RETRIED_REFUSALS.has(error.rejection.code ?? ""));
 /**
  * Starts the next turn of session `s` (locked) from its queue, when it takes messages and messages
- * wait (protocol 17, D76): in the transaction that ended the last turn, or a cancel's. Our engine
- * takes every queued message that carries the same turn manifest as the first, a workflow one.
- * Writes `queue.taken`. Returns nothing when nothing started: an empty queue, or an Agent that
- * cannot take a turn now, whose messages wait for the next message or turn end.
+ * wait (protocol 17, D76): in the transaction that ended the last turn, a cancel's, a message's
+ * that joined a queue left waiting, or the Tenant sweep's (`retryQueuedStarts`). Our engine takes
+ * every queued message that carries the same turn manifest as the first, a workflow one. Writes
+ * `queue.taken`. Returns nothing when nothing started: an empty queue, or an Agent that refused
+ * the start.
+ *
+ * A refusal a later try may get past (`RETRIED_REFUSALS`) leaves the messages waiting, with
+ * `s.queueStalled` saying since when and why (written here); the next message, the sweep and the
+ * end of a disk copy try again. A message that has waited longer than the Runtime limit
+ * `queuedStartMs` since the stall began (or since it was queued, when later) fails with
+ * `queue.failed` (`queue.start_expired`); a refusal no retry changes fails the messages it refused
+ * at once (`queue.start_refused`). Either way the messages behind them are tried next (Host
+ * feature `queue-recovery`).
  */
-export async function startQueuedTurn(ctx, t, s, id) {
+export async function startQueuedTurn(ctx, t, s, id, now = new Date()) {
     if (s.closedReason !== undefined || !takesMessages(s) || s.activeTurnId !== null)
         return undefined;
-    const queued = await t.queuedMessages(id);
-    if (queued.length === 0)
-        return undefined;
-    // Messages that ask the same of their turn's manifest (a variant, `removeTools`) share a turn.
-    const manifestOf = (row) => canonical(turnManifestRequestOf(row.command) ?? null);
-    const batch = isWorkflowManifest(s.manifest) ? [queued[0]] : [];
-    if (batch.length === 0)
-        for (const row of queued) {
-            if (manifestOf(row) !== manifestOf(queued[0]))
-                break;
-            batch.push(row);
+    for (;;) {
+        const queued = await t.queuedMessages(id);
+        if (queued.length === 0) {
+            if (s.queueStalled !== undefined) {
+                delete s.queueStalled;
+                await t.put("sessions", id, s);
+            }
+            return undefined;
         }
-    try {
-        await checkAgentTurn(t, s, QUEUE_SCOPE, ctx);
-        await beginMessageTurn(t, s, id, batch.map((row) => ({
-            command: row.command,
-            input: row.input,
-            fileArtifacts: row.fileArtifacts,
-            writer: row.writer,
-            queuedMessageId: row.id,
-            ...(row.trace ? { trace: row.trace } : {}),
-            ...(row.cause ? { cause: row.cause } : {}),
-        })));
-    }
-    catch (error) {
-        if (error instanceof HttpError)
+        // Messages that ask the same of their turn's manifest (a variant, `removeTools`) share a turn.
+        const manifestOf = (row) => canonical(turnManifestRequestOf(row.command) ?? null);
+        const batch = isWorkflowManifest(s.manifest) ? [queued[0]] : [];
+        if (batch.length === 0)
+            for (const row of queued) {
+                if (manifestOf(row) !== manifestOf(queued[0]))
+                    break;
+                batch.push(row);
+            }
+        try {
+            await checkAgentTurn(t, s, QUEUE_SCOPE, ctx);
+            await beginMessageTurn(t, s, id, batch.map((row) => ({
+                command: row.command,
+                input: row.input,
+                fileArtifacts: row.fileArtifacts,
+                writer: row.writer,
+                queuedMessageId: row.id,
+                ...(row.trace ? { trace: row.trace } : {}),
+                ...(row.cause ? { cause: row.cause } : {}),
+            })));
+        }
+        catch (error) {
+            if (!(error instanceof HttpError))
+                throw error;
+            const reason = error.rejection.code ?? "request_rejected";
+            if (!retried(error)) {
+                await failQueued(t, id, batch, {
+                    code: "queue.start_refused",
+                    message: `The Agent refused these messages' turn: ${error.message}`,
+                    reason,
+                });
+                continue;
+            }
+            const since = s.queueStalled?.since ?? now.toISOString();
+            const { queuedStartMs } = await readRuntimeLimits(t);
+            const waited = (row) => now.getTime() - Math.max(Date.parse(since), Date.parse(row.createdAt));
+            const expired = batch.filter((row) => waited(row) >= queuedStartMs);
+            if (expired[0]?.id === batch[0].id) {
+                await failQueued(t, id, expired, {
+                    code: "queue.start_expired",
+                    message: `The Agent refused these messages' turn for longer than the Runtime limit queuedStartMs (${queuedStartMs} ms): ${error.message}`,
+                    reason,
+                });
+                continue;
+            }
+            s.queueStalled = { since, code: reason, message: error.message };
+            await t.put("sessions", id, s);
             return undefined;
-        throw error;
+        }
+        const taken = batch.map((row) => row.id);
+        await t.deleteQueuedMessages(taken);
+        const event = await t.event(id, s.activeTurnId, "queue.taken", {
+            turnId: s.activeTurnId,
+            queuedMessageIds: taken,
+        });
+        return { turnId: s.activeTurnId, taken, cursor: event.cursor };
     }
-    const taken = batch.map((row) => row.id);
-    await t.deleteQueuedMessages(taken);
-    const event = await t.event(id, s.activeTurnId, "queue.taken", {
-        turnId: s.activeTurnId,
-        queuedMessageIds: taken,
+}
+/** Removes queued messages no turn will take, with `queue.failed` (Host feature `queue-recovery`). */
+async function failQueued(t, id, rows, error) {
+    const ids = rows.map((row) => row.id);
+    await t.deleteQueuedMessages(ids);
+    await t.event(id, null, "queue.failed", { queuedMessageIds: ids, error });
+}
+/**
+ * Removes queued message `queuedMessageId` from session `id`'s queue, as `scope` (Host feature
+ * `queue-recovery`): `queue.cancelled`, written by the caller. A turn running or not, the message
+ * never starts one. Returns the event's cursor, or undefined when the message no longer waits (a
+ * turn took it, or it failed or was cancelled already).
+ */
+export async function cancelQueuedMessage(ctx, id, queuedMessageId, scope, reason) {
+    return ctx.store.tx(async (t) => {
+        const s = await lockedSession(t, id, accessOf(scope));
+        const queued = await t.queuedMessages(id);
+        if (!queued.some((row) => row.id === queuedMessageId))
+            return undefined;
+        await t.deleteQueuedMessages([queuedMessageId]);
+        const event = await t.event(id, null, "queue.cancelled", { queuedMessageIds: [queuedMessageId], ...(reason === undefined ? {} : { reason }) }, commandWriter(scope));
+        if (queued.length === 1 && s.queueStalled !== undefined) {
+            delete s.queueStalled;
+            await t.put("sessions", id, s);
+        }
+        return { cursor: event.cursor };
     });
-    return { turnId: s.activeTurnId, taken, cursor: event.cursor };
+}
+/**
+ * Tries again the turn start of every queue a refused start left waiting, one transaction per
+ * session (Host feature `queue-recovery`): the Tenant sweep's step, and what the end of an Agent's
+ * disk copy runs for that Agent's sessions (`environmentId`). Each start fails its messages past
+ * `queuedStartMs` (`startQueuedTurn`). Returns the sessions whose queue started a turn.
+ */
+export async function retryQueuedStarts(ctx, options = {}) {
+    const started = [];
+    const limit = options.batchSize ?? 100;
+    let after;
+    for (;;) {
+        const ids = await ctx.store.tx((t) => t.queuedSessions({
+            statuses: TAKES_MESSAGES,
+            limit,
+            ...(after === undefined ? {} : { after }),
+            ...(options.environmentId === undefined ? {} : { environmentId: options.environmentId }),
+        }));
+        for (const id of ids) {
+            if (ctx.closing || ctx.closed)
+                return started;
+            const turn = await ctx.store.tx(async (t) => {
+                const s = await t.lockSession(id);
+                if (!s)
+                    return undefined;
+                const begun = await startQueuedTurn(ctx, t, s, id, options.now ?? new Date());
+                if (begun)
+                    await t.put("sessions", id, s);
+                return begun;
+            });
+            if (turn)
+                started.push(id);
+        }
+        if (ids.length < limit)
+            return started;
+        after = ids.at(-1);
+    }
 }
 /** Core's own commands (R4.9): the flow host's, and a drain's cancels. */
 const CORE_PRINCIPALS = { "flow-host": "flow-host", drain: "core" };

package/dist/tenant/context.d.ts

@@ -113,6 +113,17 @@ export interface Session {
         triggerId: string;
         runId: string;
     };
+    /**
+     * Set while the session's queued messages wait for an Agent that refused their turn's start
+     * (Host feature `queue-recovery`, `startQueuedTurn`): since when, and the last refusal. The
+     * Tenant sweep tries the start again, and fails them once `queuedStartMs` has passed since.
+     * Cleared when a turn starts, or when the queue empties.
+     */
+    queueStalled?: {
+        since: string;
+        code: string;
+        message: string;
+    };
     creation: unknown;
     mcpSnapshot?: McpSnapshot;
     mcpDiagnostics?: readonly McpDiagnostic[];

package/dist/tenant/sweep.js

@@ -43,7 +43,11 @@
  *    the delivery after commit, sends), and configs of tasks long finished are deleted. A push
  *    row that fails is retried with the Host tuning's `a2a.pushRetry` and dropped once it is
  *    `a2a.pushMaxAgeMs` old, never parked: the change feed covers what it said.
- * 7. **Hooks.** Callbacks registered with `ctx.onSweep`.
+ * 7. **Queued messages** (Host feature `queue-recovery`): at most every `sweep.queueRetryMs`, the
+ *    turn start of every session queue an Agent's refusal left waiting is tried again
+ *    (`retryQueuedStarts`); a message past the Runtime limit `queuedStartMs` fails
+ *    (`queue.failed`). The end of a disk copy tries its Agent's sessions at once.
+ * 8. **Hooks.** Callbacks registered with `ctx.onSweep`.
  *
  * Every step runs one transaction per session it changes (a linked agent and its workflow
  * share one, child first), so the sweep follows the lock order in `store/types.ts`. A failing
@@ -51,12 +55,14 @@
  * reports it.
  */
 import { sweepUnusedAgents } from "./agents.js";
+import { retryQueuedStarts } from "./commands.js";
 import { reconcileTriggers } from "./triggers.js";
 import { streamMissedRuns } from "./runs-stream.js";
 import { sweepPendingSeeds } from "../artifacts/disk.js";
 import { pendingAgentEffects, reconcilePendingAgentEffect, } from "../core/flow-host.js";
 import { hostTuning } from "../tuning.js";
-import { sweepStartChecks } from "./agent-versions.js";
+import { idleMsOf, sweepStartChecks } from "./agent-versions.js";
+import { readSandboxConfig } from "../sandbox/tenant-config.js";
 import { pumpPushes, pushRetry } from "../api/a2a/push.js";
 /*
  * The sweep's timings are the Host tuning's `sweep` group (`tuning.ts`):
@@ -69,6 +75,7 @@ import { pumpPushes, pushRetry } from "../api/a2a/push.js";
  * - `drainBudgetMs`: how long one pass may spend draining the outbox, and paging through
  *   orphaned sessions. A backlog is worked off over several passes rather than holding one (and
  *   with it the Tenant's sweep object in the execution) for long.
+ * - `queueRetryMs`: how often the queues an Agent's refusal left waiting are tried again.
  * - `batchSize`, `signalRetentionMs`, `outboxAttempts`, `outboxRetry`, `stalePodMs`.
  */
 /**
@@ -88,6 +95,7 @@ export async function sweep(ctx) {
         pass.orphansAfter !== undefined ||
         now.getTime() - pass.orphansAt >= hostTuning().sweep.orphanScanMs;
     const checkPods = pass.podsAt === undefined || now.getTime() - pass.podsAt >= hostTuning().sweep.orphanScanMs;
+    const retryQueues = pass.queuesAt === undefined || now.getTime() - pass.queuesAt >= hostTuning().sweep.queueRetryMs;
     const steps = [
         ["outbox", () => deliverOutbox(ctx, first ? 0 : hostTuning().sweep.outboxGraceMs)],
         ["linked", () => reconcileLinkedAgents(ctx)],
@@ -142,6 +150,17 @@ export async function sweep(ctx) {
             "signals",
             () => ctx.store.tx((t) => t.pruneSignals(new Date(now.getTime() - hostTuning().sweep.signalRetentionMs))),
         ],
+        ...(retryQueues
+            ? [
+                [
+                    "queues",
+                    async () => {
+                        pass.queuesAt = now.getTime();
+                        await retryQueuedStarts(ctx, { now, batchSize: hostTuning().sweep.batchSize });
+                    },
+                ],
+            ]
+            : []),
         ...[...ctx.sweepHooks].map((hook) => ["hook", hook]),
     ];
     let failure;
@@ -287,7 +306,8 @@ export async function wakeOrphanedSessions(ctx, now = new Date(), after, budgetM
 }
 /**
  * Pod sandboxes (F7.2) whose change has not finished (creating, deleting, an old volume still
- * to delete, an expiry not yet recorded), or that should run but whose engine is not connected,
+ * to delete, an expiry not yet recorded), that should run but whose engine is not connected, or
+ * that run past their idle limit (a wake that armed no idle timer: the reconcile arms it),
  * and whose row has not moved for `sweep.stalePodMs` (a minute), get a reconcile: a pod or volume deleted outside
  * the Runtime is found, and a change goes on whose reconcile the execution itself lost (its
  * retry timer, an invocation an operator killed, Restate's state wiped) or whose outbox row
@@ -296,18 +316,27 @@ export async function wakeOrphanedSessions(ctx, now = new Date(), after, budgetM
 async function reconcileStalePods(ctx, now) {
     if (!ctx.pods)
         return;
-    const stale = await ctx.store.tx(async (t) => (await t.listEnvironments()).filter((row) => {
-        const pod = row.pod;
-        if (!pod || now.getTime() - Date.parse(row.updatedAt) < hostTuning().sweep.stalePodMs)
-            return false;
-        return (pod.desired === "deleted" ||
-            pod.retiring !== undefined ||
-            pod.observed === "creating" ||
-            pod.observed === "deleting" ||
-            (pod.desired === "suspended" && pod.observed !== "suspended") ||
-            // Running, but its engine is not connected: the pod may be gone, or its volume.
-            (pod.desired === "running" && pod.observed === "running" && !ctx.harness.hosting(row.id)));
-    }));
+    const stale = await ctx.store.tx(async (t) => {
+        const config = await readSandboxConfig(t);
+        return (await t.listEnvironments()).filter((row) => {
+            const pod = row.pod;
+            if (!pod || now.getTime() - Date.parse(row.updatedAt) < hostTuning().sweep.stalePodMs)
+                return false;
+            return (pod.desired === "deleted" ||
+                pod.retiring !== undefined ||
+                pod.observed === "creating" ||
+                pod.observed === "deleting" ||
+                (pod.desired === "suspended" && pod.observed !== "suspended") ||
+                // Running, but its engine is not connected: the pod may be gone, or its volume.
+                (pod.desired === "running" && pod.observed === "running" && !ctx.harness.hosting(row.id)) ||
+                // Running past its idle limit: its idle timer is missing (or a turn holds it, which the
+                // reconcile leaves alone).
+                (pod.desired === "running" &&
+                    pod.observed === "running" &&
+                    now.getTime() - Date.parse(pod.lastActiveAt ?? row.createdAt) >
+                        idleMsOf(config, row) + hostTuning().sweep.stalePodMs));
+        });
+    });
     for (const row of stale)
         await ctx.sandboxSignal(row.id, { kind: "reconcile" });
 }

package/dist/tuning.d.ts

@@ -121,6 +121,7 @@ export declare const HostTuningSchema: z.ZodObject<{
             maxMs: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strict>>;
         stalePodMs: z.ZodDefault<z.ZodNumber>;
+        queueRetryMs: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strict>>;
     a2a: z.ZodPrefault<z.ZodObject<{
         pushRetry: z.ZodPrefault<z.ZodObject<{
@@ -297,6 +298,8 @@ export declare const HostTuningSchema: z.ZodObject<{
         networkProbeMs: z.ZodDefault<z.ZodNumber>;
         networkPauseMs: z.ZodDefault<z.ZodNumber>;
         networkConfirmations: z.ZodDefault<z.ZodNumber>;
+        wakeNetworkProbeMs: z.ZodDefault<z.ZodNumber>;
+        wakeNetworkConfirmations: z.ZodDefault<z.ZodNumber>;
         setupRetryPollMs: z.ZodDefault<z.ZodNumber>;
         setupAfterSeedPollMs: z.ZodDefault<z.ZodNumber>;
         setupReportTailChars: z.ZodDefault<z.ZodNumber>;

package/dist/tuning.js

@@ -207,6 +207,11 @@ export const HostTuningSchema = z
         outboxRetry: backoff(5_000, 10 * MINUTE),
         /** How long a pod row may go unchanged before the sweep checks it. */
         stalePodMs: ms(MINUTE),
+        /**
+         * How often the sweep tries again the turn start of queued messages their Agent refused
+         * (Host feature `queue-recovery`); they fail after the Runtime limit `queuedStartMs`.
+         */
+        queueRetryMs: ms(30_000),
     }),
     /** The A2A server's push notifications (Host feature `a2a-profile-v2`). */
     a2a: group({
@@ -495,6 +500,13 @@ export const HostTuningSchema = z
         networkProbeMs: ms(1_000),
         networkPauseMs: ms(250, 0),
         networkConfirmations: count(3),
+        /**
+         * The same check on a wake (the disk already holds the engine's volume id): each probe, and
+         * the failed probes in a row that prove an address blocked. A probe that connects turns the
+         * wake's check into the full one.
+         */
+        wakeNetworkProbeMs: ms(150),
+        wakeNetworkConfirmations: count(1),
         /** Environment setup: how often a failed setup is checked for a retry, and after a seed. */
         setupRetryPollMs: ms(5_000),
         setupAfterSeedPollMs: ms(1_000),

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const RUNTIME_VERSION = "0.43.0-beta";
+export declare const RUNTIME_VERSION = "0.44.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.43.0-beta";
+export const RUNTIME_VERSION = "0.44.1-beta";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nylorun/runtime",
-  "version": "0.43.0-beta",
+  "version": "0.44.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.37.0-beta",
-    "@nylorun/harness": "0.34.0-beta",
+    "@nylorun/core": "0.38.0-beta",
+    "@nylorun/harness": "0.34.1-beta",
     "@restatedev/restate-sdk": "1.17.3",
     "@restatedev/restate-sdk-clients": "1.17.3",
     "@s2-dev/streamstore": "0.28.0",