deepline 0.3.128 → 0.3.129

package/dist/bundling-sources/shared_libs/play-runtime/runner-app/runtime-progress-push.ts

@@ -1,7 +1,6 @@
 import type { PlayRunnerEvent } from '../protocol';
-import {
-  RUNTIME_RUNNER_TERMINAL_PROGRESS_MAX_EVENTS,
-} from '../runtime-contract';
+import { jsonByteLengthUpTo } from '../output-size-limits';
+import { RUNTIME_RUNNER_TERMINAL_PROGRESS_MAX_EVENTS } from '../runtime-contract';
 
 /**
  * Push-execution live progress channel (runs INSIDE the Daytona sandbox).
@@ -31,6 +30,11 @@ export const RUNNER_PROGRESS_PUSH_STOP_TIMEOUT_MS = 5_000;
 const APP_RUNTIME_COMPAT_PATH = '/api/v2/plays/runtime';
 
 export interface RunnerProgressPusher {
+  snapshot: () => {
+    retainedBytes: number;
+    retainedEvents: number;
+    omittedEvents: number;
+  };
   /** Enqueue one progress event for the next batch flush. */
   enqueue: (event: PlayRunnerEvent) => void;
   /** Stop delivery and return all observations not known to be delivered. */
@@ -100,19 +104,20 @@ async function defaultSendBatch(input: {
   await response.text().catch(() => '');
 }
 
-type ProgressBatch = {
-  events: PlayRunnerEvent[];
-  /** Number of durable play-authored log lines before this batch. */
-  liveLogOffset: number;
+export const RUNNER_PROGRESS_MAX_RETAINED_BYTES = 2 * 1024 * 1024;
+export const RUNNER_PROGRESS_MAX_RETAINED_EVENTS = 4_000;
+const RUNNER_PROGRESS_BATCH_MAX_BYTES = 128 * 1024;
+const RUNNER_PROGRESS_SEND_TIMEOUT_MS = 5_000;
+
+type PendingEvent = {
+  event: PlayRunnerEvent;
+  bytes: number;
+  logOffset: number;
 };
 
-function durableLogCount(events: readonly PlayRunnerEvent[]): number {
-  return events.reduce(
-    (count, event) =>
-      event.type === 'log' && event.source !== 'worker' && event.line.length > 0
-        ? count + 1
-        : count,
-    0,
+function isDurableLog(event: PlayRunnerEvent): boolean {
+  return (
+    event.type === 'log' && event.source !== 'worker' && event.line.length > 0
   );
 }
 
@@ -120,202 +125,224 @@ export function createRunnerProgressPusher(
   options: RunnerProgressPushOptions,
 ): RunnerProgressPusher {
   const sendBatch = options.sendBatch ?? defaultSendBatch;
+  const warn =
+    options.warn ??
+    ((message, detail) =>
+      console.warn('[play-runner.progress-push]', message, detail));
   const setIntervalImpl =
-    options.setIntervalImpl ??
-    ((fn, ms) => setInterval(fn, ms) as unknown as { unref?: () => void });
+    options.setIntervalImpl ?? ((fn, ms) => setInterval(fn, ms));
   const clearIntervalImpl =
     options.clearIntervalImpl ??
     ((handle) => clearInterval(handle as ReturnType<typeof setInterval>));
-  const warn =
-    options.warn ??
-    ((message, detail) =>
-      console.warn(`[play-runner.progress-push] ${message}`, detail));
-  const batchMs = options.batchMs ?? RUNNER_PROGRESS_PUSH_BATCH_MS;
   const maxBatch = options.maxBatch ?? RUNNER_PROGRESS_PUSH_MAX_BATCH;
-  const stopTimeoutMs =
-    options.stopTimeoutMs ?? RUNNER_PROGRESS_PUSH_STOP_TIMEOUT_MS;
-
-  const pending: PlayRunnerEvent[] = [];
-  const queuedBatches: ProgressBatch[] = [];
-  // A gateway acknowledgement is the durability boundary. Preserve any batch
-  // that failed before that boundary so the terminal request can
-  // carry it to whichever healthy replica Fly selects next.
-  const failedBatches: ProgressBatch[] = [];
-  const activeBatches = new Map<AbortController, ProgressBatch>();
-  let nextBatchLiveLogOffset = 0;
-  let deliveryBroken = false;
+  const pending: PendingEvent[] = [];
+  let active: PendingEvent[] = [];
+  let failed: PendingEvent[] = [];
+  let retainedBytes = 0;
+  let nextLogOffset = 0;
+  let omittedEvents = 0;
   let stopped = false;
   let abandoned = false;
-  let suppressWarnings = false;
-  let inFlight: Promise<void> = Promise.resolve();
-  let handle: { unref?: () => void } | null = null;
+  let deliveryBroken = false;
+  let controller: AbortController | null = null;
+  let inFlight: Promise<void> | null = null;
+
+  const forget = (entries: PendingEvent[]) => {
+    for (const entry of entries) retainedBytes -= entry.bytes;
+  };
+  const enforceBudget = () => {
+    let dropped = 0;
+    // Never evict the active request: its ambiguous outcome must remain owned.
+    // Evict only a prefix, preserving absolute log offsets for the existing
+    // durable ingestion gap marker.
+    while (
+      retainedBytes > RUNNER_PROGRESS_MAX_RETAINED_BYTES ||
+      active.length + failed.length + pending.length >
+        RUNNER_PROGRESS_MAX_RETAINED_EVENTS
+    ) {
+      const entry = failed.shift() ?? pending.shift();
+      if (!entry) break;
+      retainedBytes -= entry.bytes;
+      dropped++;
+    }
+    if (dropped) {
+      omittedEvents += dropped;
+      if (omittedEvents === dropped)
+        warn('progress_buffer_limited', {
+          runId: options.runId,
+          omittedEvents,
+        });
+    }
+  };
 
   const flush = (): Promise<void> => {
-    if (abandoned) {
-      pending.length = 0;
-      return inFlight;
+    if (inFlight) return inFlight;
+    if (abandoned || deliveryBroken || !pending.length)
+      return Promise.resolve();
+    let bytes = 0;
+    let count = 0;
+    while (count < pending.length && count < maxBatch) {
+      const next = pending[count]!;
+      const previous = pending[count - 1];
+      if (
+        previous &&
+        next.logOffset !==
+          previous.logOffset + Number(isDurableLog(previous.event))
+      )
+        break;
+      if (count && bytes + next.bytes > RUNNER_PROGRESS_BATCH_MAX_BYTES) break;
+      bytes += next.bytes;
+      count++;
     }
-    if (pending.length === 0 || deliveryBroken) return inFlight;
-    const events = pending.splice(0, Math.min(pending.length, maxBatch));
-    const batch: ProgressBatch = {
-      events,
-      liveLogOffset: nextBatchLiveLogOffset,
-    };
-    nextBatchLiveLogOffset += durableLogCount(events);
-    queuedBatches.push(batch);
-    inFlight = inFlight
-      .catch(() => {})
-      .then(async () => {
-        // stop() can time out while this batch waits behind an earlier upload.
-        // Do not start it after the authoritative terminal has been emitted.
-        if (abandoned) return;
-        if (deliveryBroken) {
-          const queuedIndex = queuedBatches.indexOf(batch);
-          if (queuedIndex >= 0) queuedBatches.splice(queuedIndex, 1);
-          failedBatches.push(batch);
-          return;
-        }
-        const controller = new AbortController();
-        const queuedIndex = queuedBatches.indexOf(batch);
-        if (queuedIndex >= 0) queuedBatches.splice(queuedIndex, 1);
-        activeBatches.set(controller, batch);
-        try {
-          await sendBatch({
+    active = pending.splice(0, count);
+    const batch = active;
+    const requestController = new AbortController();
+    controller = requestController;
+    let timeout: ReturnType<typeof setTimeout> | undefined;
+    inFlight = Promise.resolve().then(async () => {
+      if (abandoned) return;
+      try {
+        await Promise.race([
+          sendBatch({
             gatewayBaseUrl: options.gatewayBaseUrl,
             executorToken: options.executorToken,
             runId: options.runId,
             playName: options.playName,
-            events: batch.events,
-            liveLogOffset: batch.liveLogOffset,
-            signal: controller.signal,
+            events: batch.map(({ event }) => event),
+            liveLogOffset: batch[0]!.logOffset,
+            signal: requestController.signal,
+          }),
+          new Promise<never>((_, reject) => {
+            timeout = setTimeout(() => {
+              requestController.abort();
+              reject(new Error('Progress delivery timed out.'));
+            }, RUNNER_PROGRESS_SEND_TIMEOUT_MS);
+          }),
+        ]);
+        if (!abandoned) forget(batch);
+      } catch (error) {
+        if (!abandoned) {
+          failed = batch;
+          deliveryBroken = true;
+          warn('batch_failed', {
+            runId: options.runId,
+            count: batch.length,
+            error: error instanceof Error ? error.message : String(error),
           });
-        } catch (error) {
-          if (!abandoned) {
-            failedBatches.push(batch);
-            // Offsets are positional. After one unknown delivery outcome, keep
-            // the remaining contiguous suffix for the terminal request rather
-            // than sending holes that another replica could misinterpret.
-            deliveryBroken = true;
-          }
-          if (!suppressWarnings) {
-            warn('batch_failed', {
-              runId: options.runId,
-              count: batch.events.length,
-              error: error instanceof Error ? error.message : String(error),
-            });
-          }
-        } finally {
-          activeBatches.delete(controller);
         }
-      });
+      } finally {
+        if (timeout) clearTimeout(timeout);
+        active = [];
+        controller = null;
+        inFlight = null;
+        enforceBudget();
+        if (!stopped && pending.length >= maxBatch) void flush();
+      }
+    });
     return inFlight;
   };
-
-  handle = setIntervalImpl(() => {
+  const timer = setIntervalImpl(() => {
     void flush();
-  }, batchMs);
-  handle.unref?.();
+  }, options.batchMs ?? RUNNER_PROGRESS_PUSH_BATCH_MS);
+  timer.unref?.();
 
+  const abandon = () => {
+    abandoned = true;
+    controller?.abort();
+    pending.length = 0;
+    failed = [];
+    active = [];
+    retainedBytes = 0;
+  };
   return {
     enqueue(event) {
       if (stopped) return;
-      pending.push(event);
-      if (pending.length >= maxBatch) {
-        void flush();
+      const logOffset = nextLogOffset;
+      if (isDurableLog(event)) nextLogOffset++;
+      // Short-circuit size inspection avoids serializing an arbitrarily large
+      // row-update merely to decide it cannot fit observability.
+      const measured = jsonByteLengthUpTo(
+        event,
+        RUNNER_PROGRESS_BATCH_MAX_BYTES,
+      );
+      if (measured.exceeded) {
+        omittedEvents++;
+        if (omittedEvents === 1)
+          warn('progress_event_too_large', { runId: options.runId });
+        return;
       }
+      const bytes = measured.bytes;
+      pending.push({ event, bytes, logOffset });
+      retainedBytes += bytes;
+      enforceBudget();
+      if (pending.length >= maxBatch) void flush();
+    },
+    snapshot() {
+      return {
+        retainedBytes,
+        retainedEvents: active.length + failed.length + pending.length,
+        omittedEvents,
+      };
     },
     sealForTerminal() {
-      if (stopped) return { events: [], liveLogOffset: nextBatchLiveLogOffset };
+      if (stopped) return { events: [], liveLogOffset: nextLogOffset };
       stopped = true;
-      if (handle) {
-        clearIntervalImpl(handle);
-        handle = null;
-      }
-      // Preserve every batch removed from `pending`, including batches queued
-      // behind an earlier upload. The terminal request is the final owner of
-      // these observations; do not drop a burst merely because it has not yet
-      // acquired an AbortController.
-      const retainedBatches: ProgressBatch[] = [
-        ...failedBatches,
-        ...activeBatches.values(),
-        ...queuedBatches,
-        ...(pending.length
-          ? [{ events: [...pending], liveLogOffset: nextBatchLiveLogOffset }]
-          : []),
-      ];
-      const unboundedTail = retainedBatches.flatMap((batch) => batch.events);
-      const droppedEvents = Math.max(
+      clearIntervalImpl(timer);
+      const retained = [...failed, ...active, ...pending];
+      let start = Math.max(
         0,
-        unboundedTail.length - RUNTIME_RUNNER_TERMINAL_PROGRESS_MAX_EVENTS,
-      );
-      const droppedPrefix = unboundedTail.slice(0, droppedEvents);
-      const tail = unboundedTail.slice(
-        -RUNTIME_RUNNER_TERMINAL_PROGRESS_MAX_EVENTS,
+        retained.length - RUNTIME_RUNNER_TERMINAL_PROGRESS_MAX_EVENTS,
       );
-      const liveLogOffset =
-        (retainedBatches[0]?.liveLogOffset ?? nextBatchLiveLogOffset) +
-        durableLogCount(droppedPrefix);
-      if (tail.length < unboundedTail.length) {
+      for (let index = start + 1; index < retained.length; index++) {
+        const previous = retained[index - 1]!;
+        if (
+          retained[index]!.logOffset !==
+          previous.logOffset + Number(isDurableLog(previous.event))
+        )
+          start = index;
+      }
+      const tail = retained.slice(start);
+      if (tail.length < retained.length || omittedEvents)
         warn('terminal_tail_truncated', {
           runId: options.runId,
           retainedEvents: tail.length,
-          droppedEvents: unboundedTail.length - tail.length,
+          droppedEvents: retained.length - tail.length + omittedEvents,
         });
-      }
-      failedBatches.length = 0;
-      queuedBatches.length = 0;
-      pending.length = 0;
-      abandoned = true;
-      suppressWarnings = true;
-      for (const controller of activeBatches.keys()) controller.abort();
-      return { events: tail, liveLogOffset };
+      const result = {
+        events: tail.map(({ event }) => event),
+        liveLogOffset: tail[0]?.logOffset ?? nextLogOffset,
+      };
+      abandon();
+      return result;
     },
     async stop() {
       if (stopped) return;
       stopped = true;
-      if (handle) {
-        clearIntervalImpl(handle);
-        handle = null;
-      }
+      clearIntervalImpl(timer);
+      let timeout: ReturnType<typeof setTimeout> | undefined;
       const drain = async () => {
-        // Drain everything still buffered.
-        while (pending.length > 0 && !deliveryBroken) {
+        while (!abandoned && !deliveryBroken && (pending.length || inFlight))
           await flush();
-        }
-        await inFlight.catch(() => {});
-        if (deliveryBroken) pending.length = 0;
       };
-      let stopTimeoutHandle: ReturnType<typeof setTimeout> | null = null;
       const outcome = await Promise.race([
-        drain().then(() => 'drained' as const),
-        new Promise<'timed_out'>((resolve) => {
-          stopTimeoutHandle = setTimeout(
+        drain().then(() => 'drained'),
+        new Promise<string>((resolve) => {
+          timeout = setTimeout(
             () => resolve('timed_out'),
-            stopTimeoutMs,
+            options.stopTimeoutMs ?? RUNNER_PROGRESS_PUSH_STOP_TIMEOUT_MS,
           );
         }),
       ]);
-      if (stopTimeoutHandle) clearTimeout(stopTimeoutHandle);
-      if (outcome === 'drained') return;
-
-      // The authoritative terminal follows this method. Abort ordinary fetches
-      // and drop non-cooperative test/transport promises without letting their
-      // later rejection write a post-terminal diagnostic.
-      abandoned = true;
-      suppressWarnings = true;
-      const pendingEvents = pending.length;
-      pending.length = 0;
-      const inFlightEvents = [...activeBatches.values()].reduce(
-        (sum, batch) => sum + batch.events.length,
-        0,
-      );
-      for (const controller of activeBatches.keys()) controller.abort();
-      warn('drain_timed_out', {
-        runId: options.runId,
-        timeoutMs: stopTimeoutMs,
-        pendingEvents,
-        inFlightEvents,
-      });
+      if (timeout) clearTimeout(timeout);
+      if (outcome === 'timed_out')
+        warn('drain_timed_out', {
+          runId: options.runId,
+          timeoutMs:
+            options.stopTimeoutMs ?? RUNNER_PROGRESS_PUSH_STOP_TIMEOUT_MS,
+          pendingEvents: pending.length,
+          inFlightEvents: active.length,
+        });
+      abandon();
     },
   };
 }

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona-lifecycle.ts

@@ -657,6 +657,12 @@ async function acquireOneShotDaytonaSandbox(input: {
         createRetriedOneShotDaytonaSandbox(input),
       )
     : await createRetriedOneShotDaytonaSandbox(input);
+  // The runner's egress probe measures the sandbox-to-estate round trip; the
+  // sandbox's target names the region that round trip crosses.
+  console.info('[play-runner.daytona.sandbox_acquired]', {
+    sandboxId: result.sandbox.id,
+    target: (result.sandbox as { target?: unknown }).target ?? null,
+  });
   const granted = {
     cpu: result.sandbox.cpu,
     memoryGiB: result.sandbox.memory,

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona-payload-transport.ts

@@ -24,6 +24,8 @@ import {
 } from '../../output-size-limits';
 import {
   RUNTIME_SANDBOX_KILLED_MESSAGE,
+  RUNTIME_SANDBOX_MEMORY_ABORT_CODE,
+  RUNTIME_SANDBOX_MEMORY_ABORT_MESSAGE,
   RUNTIME_SANDBOX_OOM_MESSAGE,
 } from '../../run-failure';
 import {
@@ -37,7 +39,11 @@ import type {
   DaytonaSandbox,
   DaytonaStageEmitter,
 } from './daytona-lifecycle';
-import { buildDaytonaRuntimeWatchdogSource } from './daytona-runtime-watchdog';
+import {
+  buildDaytonaRuntimeWatchdogSource,
+  PLAY_RUNNER_UV_THREADPOOL_SIZE,
+  RUNTIME_SANDBOX_MEMORY_ABORT_REASON,
+} from './daytona-runtime-watchdog';
 
 type DaytonaRemoteRuntimeContext = PlayRunnerExecutionConfig['context'];
 
@@ -51,6 +57,12 @@ type DaytonaRemoteRuntimeContext = PlayRunnerExecutionConfig['context'];
  */
 export const DAYTONA_CRASH_PUSHER_POST_EVENT_DIAGNOSTIC_HEADROOM_BYTES =
   RUNNER_POST_TERMINAL_DIAGNOSTIC_MAX_BYTES;
+
+/**
+ * Ledger evidence carried on a memory-abort cause. The ledger is diagnostic,
+ * not the terminal itself, so it is bounded well below the terminal envelope.
+ */
+export const DAYTONA_CRASH_PUSHER_MEMORY_LEDGER_MAX_BYTES = 8 * 1024;
 export const DAYTONA_CRASH_PUSHER_OUTPUT_TAIL_MAX_BYTES =
   RUNNER_TERMINAL_PUSH_MAX_BODY_BYTES +
   DAYTONA_CRASH_PUSHER_POST_EVENT_DIAGNOSTIC_HEADROOM_BYTES;
@@ -68,6 +80,8 @@ export type StagedDaytonaPayload = {
 
 export type RemoteRunnerPayloadSandbox = {
   id: string;
+  /** Daytona target (region) the sandbox runs in, when the provider reports it. */
+  target?: string;
   uploadFile(content: Buffer, path: string): Promise<void>;
 };
 
@@ -255,6 +269,48 @@ function watchdogObservedChildSigkill() {
   return false;
 }
 
+// The watchdog stopped the runner at the memory abort threshold. Its
+// diagnostic is the only place the observed usage/limit and the runtime's byte
+// ledger survive the child's death, so the terminal is synthesized from it.
+function watchdogMemoryAbortDiagnostic() {
+  try {
+    if (!terminationDiagnosticPath) return null;
+    const diagnostic = JSON.parse(
+      fs.readFileSync(terminationDiagnosticPath, 'utf8'),
+    );
+    if (
+      diagnostic &&
+      diagnostic.schemaVersion === 1 &&
+      diagnostic.reason === ${JSON.stringify(RUNTIME_SANDBOX_MEMORY_ABORT_REASON)}
+    ) {
+      return diagnostic;
+    }
+  } catch {}
+  return null;
+}
+
+function memoryAbortCause(diagnostic) {
+  const parts = [
+    ${JSON.stringify(`${RUNTIME_SANDBOX_MEMORY_ABORT_CODE}: ${RUNTIME_SANDBOX_MEMORY_ABORT_MESSAGE}`)},
+    'usage=' + String(diagnostic.memoryUsageBytes),
+    'limit=' + String(diagnostic.memoryLimitBytes),
+    'ratio=' + String(diagnostic.memoryUsageRatio),
+    'source=' + String(diagnostic.memorySource),
+  ];
+  if (diagnostic.memoryLedger !== null && diagnostic.memoryLedger !== undefined) {
+    try {
+      parts.push(
+        'ledger=' +
+          truncateUtf8(
+            JSON.stringify(diagnostic.memoryLedger),
+            ${DAYTONA_CRASH_PUSHER_MEMORY_LEDGER_MAX_BYTES},
+          ),
+      );
+    } catch {}
+  }
+  return parts.join(' ');
+}
+
 function terminalResultForTransport(result) {
   if (
     result &&
@@ -312,10 +368,15 @@ async function main() {
   // runner child's signal. Read the watchdog's strict marker so a child
   // SIGKILL does not collapse into the wrapper's generic exit code 1.
   const sandboxKilled = exitCode === 137 || watchdogObservedChildSigkill();
+  const memoryAbort = watchdogMemoryAbortDiagnostic();
   const sandboxOom =
-    sandboxKilled && (outputHasExplicitOomSignature() || cgroupOomKillObserved());
+    !memoryAbort &&
+    sandboxKilled &&
+    (outputHasExplicitOomSignature() || cgroupOomKillObserved());
   const synthesizedError = runtimeLimitExceeded
     ? 'RUNTIME_LIMIT_EXCEEDED: ' + ${JSON.stringify(runtimeLimitMessage)}
+    : memoryAbort
+      ? memoryAbortCause(memoryAbort)
     : sandboxOom
       ? 'RUNTIME_SANDBOX_OOM: ' + ${JSON.stringify(RUNTIME_SANDBOX_OOM_MESSAGE)}
       : sandboxKilled
@@ -336,6 +397,15 @@ async function main() {
           cause: synthesizedError,
         }]
       : undefined,
+    ...(memoryAbort && !runtimeLimitExceeded
+      ? { errors: [{
+          code: ${JSON.stringify(RUNTIME_SANDBOX_MEMORY_ABORT_CODE)},
+          phase: 'infrastructure',
+          message: ${JSON.stringify(RUNTIME_SANDBOX_MEMORY_ABORT_MESSAGE)},
+          retryable: false,
+          cause: synthesizedError,
+        }] }
+      : {}),
     ...(sandboxOom
       ? { errors: [{
           code: 'RUNTIME_SANDBOX_OOM',
@@ -345,7 +415,7 @@ async function main() {
           cause: synthesizedError,
         }] }
       : {}),
-    ...(sandboxKilled && !sandboxOom
+    ...(sandboxKilled && !sandboxOom && !memoryAbort
       ? { errors: [{
           code: 'RUNTIME_SANDBOX_KILLED',
           phase: 'infrastructure',
@@ -590,6 +660,8 @@ export async function stageRunnerPayload(input: {
   const runtimeCompletedPath = `${workDir}/deepline-play-runtime-completed-${randomUUID()}.json`;
   const runtimeLimitMarkerPath = `${workDir}/deepline-play-runtime-limit-${randomUUID()}.txt`;
   const terminationDiagnosticPath = `${workDir}/deepline-play-termination-${randomUUID()}.json`;
+  const memoryLedgerPath = `${workDir}/deepline-play-memory-ledger-${randomUUID()}.json`;
+  const memoryPressurePath = `${workDir}/deepline-play-memory-pressure-${randomUUID()}.json`;
   const progressEventPath = `${workDir}/deepline-play-progress-${randomUUID()}.jsonl`;
   const startupDiagnosticPath = `${workDir}/deepline-play-startup-${randomUUID()}.json`;
   const runnerTraceEnv =
@@ -597,6 +669,13 @@ export async function stageRunnerPayload(input: {
       ? 'DEEPLINE_RUNTIME_RECEIPT_TRACE=1 '
       : '';
   const runtimeReliabilityEnv = runtimeReliabilityEnvironmentPrefix();
+  // The runner's egress probe prints this next to its round-trip timings so
+  // a slow sandbox-to-estate path can be read against the region it crosses.
+  const sandboxTarget = input.sandbox.target;
+  const sandboxTargetEnv =
+    typeof sandboxTarget === 'string' && sandboxTarget.trim()
+      ? `DEEPLINE_SANDBOX_TARGET=${shellQuote(sandboxTarget.trim())} `
+      : '';
   const watchedRunnerCommand = [
     'node',
     '-e',
@@ -610,6 +689,8 @@ export async function stageRunnerPayload(input: {
     String(PLAY_RUNNER_TERMINAL_GRACE_SECONDS * 1_000),
     shellQuote(runtimeLimitMarkerPath),
     shellQuote(terminationDiagnosticPath),
+    shellQuote(memoryLedgerPath),
+    shellQuote(memoryPressurePath),
   ].join(' ');
   const runnerCommand = `${nodeMaterializePayloadCommand({
     envelopePath,
@@ -618,7 +699,7 @@ export async function stageRunnerPayload(input: {
     artifactCodePath,
     artifactSourceMapPath,
     crashPusherPath,
-  })} && DEEPLINE_PLAY_RUNNER_RUNTIME_STARTED_PATH=${shellQuote(runtimeStartedPath)} DEEPLINE_PLAY_RUNNER_RUNTIME_COMPLETED_PATH=${shellQuote(runtimeCompletedPath)} DEEPLINE_PLAY_RUNNER_PROGRESS_EVENT_PATH=${shellQuote(progressEventPath)} DEEPLINE_PLAY_RUNNER_STARTUP_DIAGNOSTIC_PATH=${shellQuote(startupDiagnosticPath)} DEEPLINE_PLAY_RUNNER_STDOUT_EVENT_MODE=compact ${runtimeReliabilityEnv}${runnerTraceEnv}${watchedRunnerCommand}`;
+  })} && DEEPLINE_PLAY_RUNNER_RUNTIME_STARTED_PATH=${shellQuote(runtimeStartedPath)} DEEPLINE_PLAY_RUNNER_RUNTIME_COMPLETED_PATH=${shellQuote(runtimeCompletedPath)} DEEPLINE_PLAY_RUNNER_PROGRESS_EVENT_PATH=${shellQuote(progressEventPath)} DEEPLINE_PLAY_RUNNER_STARTUP_DIAGNOSTIC_PATH=${shellQuote(startupDiagnosticPath)} DEEPLINE_PLAY_RUNNER_STDOUT_EVENT_MODE=compact UV_THREADPOOL_SIZE=${PLAY_RUNNER_UV_THREADPOOL_SIZE} ${runtimeReliabilityEnv}${runnerTraceEnv}${sandboxTargetEnv}${watchedRunnerCommand}`;
   // Crash-containment epilogue: runs UNCONDITIONALLY after the runner exits and
   // pushes the parsed (or synthesized) terminal to the gateway so the parked
   // worker wakes within seconds of ANY runner death — process.exit abuse, OOM
@@ -627,7 +708,7 @@ export async function stageRunnerPayload(input: {
   // Its own retry diagnostics are kept in a separate log: appending them to
   // `outputPath` after a near-gateway-sized result could hide that result from
   // a later bounded-tail recovery read.
-  const command = `rm -f ${shellQuote(outputPath)} ${shellQuote(crashPusherLogPath)} ${shellQuote(exitCodePath)} ${shellQuote(oomKillBaselinePath)} ${shellQuote(runtimeStartedPath)} ${shellQuote(runtimeCompletedPath)} ${shellQuote(runtimeLimitMarkerPath)} ${shellQuote(terminationDiagnosticPath)} ${shellQuote(progressEventPath)} ${shellQuote(`${progressEventPath}.*`)} ${shellQuote(startupDiagnosticPath)}; ( awk '$1 == "oom_kill" { print $2 }' /sys/fs/cgroup/memory.events 2>/dev/null || true ) > ${shellQuote(oomKillBaselinePath)}; ( ${runnerCommand} ) > ${shellQuote(outputPath)} 2>&1; code=$?; printf '%s' "$code" > ${shellQuote(exitCodePath)}; ${runtimeReliabilityEnv}node ${shellQuote(crashPusherPath)} ${shellQuote(configPath)} "$code" ${shellQuote(outputPath)} ${shellQuote(runtimeLimitMarkerPath)} ${shellQuote(oomKillBaselinePath)} /sys/fs/cgroup/memory.events ${shellQuote(terminationDiagnosticPath)} > ${shellQuote(crashPusherLogPath)} 2>&1 || true; printf 'deepline runner output captured: %s\\n' ${shellQuote(outputPath)}; exit "$code"`;
+  const command = `rm -f ${shellQuote(outputPath)} ${shellQuote(crashPusherLogPath)} ${shellQuote(exitCodePath)} ${shellQuote(oomKillBaselinePath)} ${shellQuote(runtimeStartedPath)} ${shellQuote(runtimeCompletedPath)} ${shellQuote(runtimeLimitMarkerPath)} ${shellQuote(terminationDiagnosticPath)} ${shellQuote(memoryLedgerPath)} ${shellQuote(`${memoryLedgerPath}.tmp`)} ${shellQuote(memoryPressurePath)} ${shellQuote(progressEventPath)} ${shellQuote(`${progressEventPath}.*`)} ${shellQuote(startupDiagnosticPath)}; ( awk '$1 == "oom_kill" { print $2 }' /sys/fs/cgroup/memory.events 2>/dev/null || true ) > ${shellQuote(oomKillBaselinePath)}; ( ${runnerCommand} ) > ${shellQuote(outputPath)} 2>&1; code=$?; printf '%s' "$code" > ${shellQuote(exitCodePath)}; ${runtimeReliabilityEnv}node ${shellQuote(crashPusherPath)} ${shellQuote(configPath)} "$code" ${shellQuote(outputPath)} ${shellQuote(runtimeLimitMarkerPath)} ${shellQuote(oomKillBaselinePath)} /sys/fs/cgroup/memory.events ${shellQuote(terminationDiagnosticPath)} > ${shellQuote(crashPusherLogPath)} 2>&1 || true; printf 'deepline runner output captured: %s\\n' ${shellQuote(outputPath)}; exit "$code"`;
 
   return {
     workDir: input.workDir,
@@ -650,6 +731,10 @@ export async function stageDaytonaRunnerPayload(
     ...input,
     sandbox: {
       id: input.sandbox.id,
+      target:
+        typeof (input.sandbox as { target?: unknown }).target === 'string'
+          ? ((input.sandbox as { target: string }).target ?? undefined)
+          : undefined,
       uploadFile: (content, path) => input.sandbox.fs.uploadFile(content, path),
     },
   });