deepline 0.3.408 → 0.3.410

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

@@ -59,6 +59,8 @@ export interface RunnerHeartbeatLoopOptions {
   executorToken: string;
   runId: string;
   leaseSeconds: number;
+  /** Keep managed startup heartbeats active until the scheduler parks the attempt. */
+  waitForSchedulerPark?: boolean;
   /**
    * Invoked once when the loop decides the runner must self-terminate (terminal
    * cancellation channel, or gateway unreachable past the lease window). The
@@ -109,6 +111,8 @@ export const RUNNER_HEARTBEAT_REQUEST_TIMEOUT_MS = 10_000;
 // The detached startup deadline is shorter than the normal 40s cadence.
 // Retry initial transport failures while customer execution remains fenced.
 const RUNNER_STARTUP_HEARTBEAT_INTERVAL_MS = 1_000;
+const RUNNER_PARK_ACK_INTERVAL_MS = 100;
+const RUNNER_PARK_ACK_FAST_WINDOW_MS = 1_000;
 
 export async function sendRunnerHeartbeat(
   input: {
@@ -324,6 +328,8 @@ export function startRunnerHeartbeatLoop(
   let heartbeatAttempt = 0;
   let lastSuccessAt = now();
   let handle: { unref?: () => void } | null = null;
+  let intervalMs = Math.min(cadenceMs, RUNNER_STARTUP_HEARTBEAT_INTERVAL_MS);
+  let fastParkAckUntil: number | null = null;
   let resolveFirstHeartbeat: (() => void) | null = null;
   const firstHeartbeat = new Promise<void>((resolve) => {
     resolveFirstHeartbeat = resolve;
@@ -333,6 +339,15 @@ export function startRunnerHeartbeatLoop(
     resolveExecutionAcknowledged = resolve;
   });
 
+  const setCadence = (ms: number) => {
+    if (!handle || intervalMs !== ms) {
+      if (handle) clearIntervalImpl(handle);
+      intervalMs = ms;
+      handle = setIntervalImpl(tick, ms);
+    }
+    if (!resolveFirstHeartbeat) handle.unref?.();
+  };
+
   const stopLoop = () => {
     if (stopped) return;
     stopped = true;
@@ -359,6 +374,12 @@ export function startRunnerHeartbeatLoop(
       leaseSeconds: options.leaseSeconds,
       attempt: heartbeatAttempt,
     })
+      .finally(() => {
+        // A caller may request the park acknowledgement as soon as the first
+        // heartbeat resolves. Release this completed transport before exposing
+        // that fence so the immediate request is not mistaken for an overlap.
+        inFlight = false;
+      })
       .then((result) => {
         if (stopped) return;
         if (result.ok === false) {
@@ -369,10 +390,7 @@ export function startRunnerHeartbeatLoop(
         if (resolveFirstHeartbeat) {
           resolveFirstHeartbeat();
           resolveFirstHeartbeat = null;
-          // Restore the steady-state cadence only after durable startup succeeds.
-          if (handle) clearIntervalImpl(handle);
-          handle = setIntervalImpl(tick, cadenceMs);
-          handle.unref?.();
+          fastParkAckUntil = now() + RUNNER_PARK_ACK_FAST_WINDOW_MS;
         }
         if (
           result.schedulerStatus === 'waiting' &&
@@ -381,6 +399,16 @@ export function startRunnerHeartbeatLoop(
           resolveExecutionAcknowledged();
           resolveExecutionAcknowledged = null;
         }
+        // One loop owns the managed startup handshake. A healthy, unparked
+        // attempt briefly uses the fast cadence; slow/legacy acknowledgements
+        // return to startup pacing, and confirmed parking restores lease pacing.
+        setCadence(
+          options.waitForSchedulerPark && resolveExecutionAcknowledged
+            ? fastParkAckUntil !== null && now() < fastParkAckUntil
+              ? RUNNER_PARK_ACK_INTERVAL_MS
+              : RUNNER_STARTUP_HEARTBEAT_INTERVAL_MS
+            : cadenceMs,
+        );
       })
       .catch((error) => {
         if (stopped) return;
@@ -395,24 +423,21 @@ export function startRunnerHeartbeatLoop(
           });
           return;
         }
+        if (options.waitForSchedulerPark && resolveExecutionAcknowledged) {
+          setCadence(RUNNER_STARTUP_HEARTBEAT_INTERVAL_MS);
+        }
         warn('heartbeat_failed_retrying', {
           runId: options.runId,
           sinceMs,
           leaseMs,
           error: message,
         });
-      })
-      .finally(() => {
-        inFlight = false;
       });
   };
 
   // Keep this timer referenced until the first accepted heartbeat: a pending
   // Promise alone does not keep Node alive after an initial transport failure.
-  handle = setIntervalImpl(
-    tick,
-    Math.min(cadenceMs, RUNNER_STARTUP_HEARTBEAT_INTERVAL_MS),
-  );
+  setCadence(intervalMs);
   // Fire one immediately so a cancel that landed before the first interval is
   // observed within a cadence, not a full lease window.
   tick();

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

@@ -1,3 +1,4 @@
+import { readFileSync, writeFileSync } from 'node:fs';
 import {
   RUNNER_TERMINAL_CHECKPOINT_DISPOSITION,
   type PlayRunnerEvent,
@@ -551,6 +552,8 @@ export interface PushRunnerTerminalOptions {
   result: PlayRunnerResult | PlayRunnerTerminalTransportResult;
   finalProgressEvents?: PlayRunnerEvent[];
   finalProgressLogOffset?: number;
+  /** Existing per-invocation completion marker, shared with crash recovery. */
+  runtimeCompletedPath?: string;
   /** Injectable for tests. Defaults to a bearer POST to the gateway. */
   fetchImpl?: typeof fetch;
   sleepImpl?: (ms: number) => Promise<void>;
@@ -722,6 +725,38 @@ export async function pushRunnerTerminal(
       if (response.ok) {
         await response.text().catch(() => '');
         reportTransport('ok', { status: response.status });
+        if (options.runtimeCompletedPath) {
+          try {
+            const marker: unknown = JSON.parse(
+              readFileSync(options.runtimeCompletedPath, 'utf8'),
+            );
+            if (
+              !marker ||
+              typeof marker !== 'object' ||
+              Array.isArray(marker) ||
+              !('completed' in marker) ||
+              marker.completed !== true
+            ) {
+              throw new Error('Invalid runtime completion marker');
+            }
+            // Preserve the original completion timestamp: the watchdog's
+            // settlement grace still starts when customer execution ended.
+            writeFileSync(
+              options.runtimeCompletedPath,
+              JSON.stringify({
+                ...marker,
+                terminalAcknowledgedRunId: options.runId,
+              }),
+              'utf8',
+            );
+          } catch {
+            // The terminal is already durable. Failure to record this local
+            // handoff retains the existing first-write-wins epilogue POST.
+            warn('terminal_acknowledgement_marker_unavailable', {
+              runId: options.runId,
+            });
+          }
+        }
         return true;
       }
       const body = await response.text().catch(() => '');

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

@@ -361,6 +361,10 @@ function deadline(timeoutMs: number, signal?: AbortSignal) {
 export function createDaytonaLaunchClient(
   options: DaytonaClientOptions,
   cancellation?: AbortSignal,
+  onCreateStage?: (
+    stage: 'create:response' | 'create:started',
+    timing: Record<string, unknown>,
+  ) => void,
 ) {
   if (!options.apiKey?.trim())
     throw new Error('Daytona launch requires the configured API key.');
@@ -421,6 +425,7 @@ export function createDaytonaLaunchClient(
           }),
         );
         sent = true;
+        const requestStartedAt = performance.now();
         const response = await api.createSandbox(
           {
             name: params.name,
@@ -447,9 +452,25 @@ export function createDaytonaLaunchClient(
           { timeout: timeoutMs },
         );
         data = response.data;
+        try {
+          onCreateStage?.('create:response', {
+            createRequestMs: performance.now() - requestStartedAt,
+            initialState: daytonaSandboxStateForLog(data.state),
+          });
+        } catch {
+          // An advisory observer cannot select provider recovery or skip readiness.
+        }
         const sandbox = makeSandbox(data, () => phase.signal);
         waiting = sandbox;
+        const readyStartedAt = performance.now();
         await sandbox.waitUntilStarted(options.timeout ?? 60);
+        try {
+          onCreateStage?.('create:started', {
+            providerReadyWaitMs: performance.now() - readyStartedAt,
+          });
+        } catch {
+          // Provider success remains authoritative if its observer fails.
+        }
         // Future phases own fresh deadlines; none inherits this create scope.
         return makeSandbox(
           {

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

@@ -157,9 +157,10 @@ function nodeMaterializePayloadCommand(input: {
  *  2. push it — or a synthesized crash failure naming the exit code — to the
  *     gateway's `runner_terminal` action.
  *
- * The gateway records terminals FIRST-WRITE-WINS and absurd wake events are
- * first-emit-wins, so a duplicate push after a successful in-runner push is a
- * no-op; this needs no coordination with the runner.
+ * A successful in-runner push records its acknowledgement in the existing
+ * per-invocation completion marker. Only that positive acknowledgement skips
+ * the epilogue POST. Older runners and missing/ambiguous acknowledgements
+ * retain the gateway's first-write-wins recovery.
  *
  * Exported (with the builder) for the unit test that executes the script
  * against a real local HTTP server.
@@ -178,6 +179,7 @@ const runtimeLimitMarkerPath = process.argv[5] || '';
 const oomKillBaselinePath = process.argv[6] || '';
 const memoryEventsPath = process.argv[7] || '/sys/fs/cgroup/memory.events';
 const terminationDiagnosticPath = process.argv[8] || '';
+const runtimeCompletedPath = process.argv[9] || '';
 const exitCode = Number.isFinite(exitCodeRaw) ? exitCodeRaw : null;
 const MAX_OUTPUT_BYTES = ${DAYTONA_CRASH_PUSHER_OUTPUT_TAIL_MAX_BYTES};
 const MAX_POST_TERMINAL_DIAGNOSTIC_BYTES = ${RUNNER_POST_TERMINAL_DIAGNOSTIC_MAX_BYTES};
@@ -360,6 +362,19 @@ async function main() {
     writeDiagnostic('[crash-terminal] no push config; skipping');
     return;
   }
+  if (runtimeCompletedPath) {
+    try {
+      const marker = JSON.parse(fs.readFileSync(runtimeCompletedPath, 'utf8'));
+      if (
+        marker &&
+        marker.completed === true &&
+        marker.terminalAcknowledgedRunId === push.runId
+      ) {
+        writeDiagnostic('[crash-terminal] terminal already acknowledged; skipping');
+        return;
+      }
+    } catch {}
+  }
   const parsedResultEvent = readResultEventFromOutput();
   const parsedResult = parsedResultEvent && parsedResultEvent.result;
   // Exit codes are authored-program output too: a play may intentionally call
@@ -725,14 +740,14 @@ export async function stageRunnerPayload(input: {
     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 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
+  // pushes an unacknowledged parsed (or synthesized) terminal so the parked
   // worker wakes within seconds of ANY runner death — process.exit abuse, OOM
   // SIGKILL, or a crash before the in-process push. Idempotent against a
-  // successful in-runner push (terminals are first-write-wins).
+  // successful in-runner push when its local acknowledgement was lost.
   // 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(runnerPidPath)} ${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"`;
+  const command = `rm -f ${shellQuote(outputPath)} ${shellQuote(crashPusherLogPath)} ${shellQuote(exitCodePath)} ${shellQuote(oomKillBaselinePath)} ${shellQuote(runnerPidPath)} ${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(runtimeCompletedPath)} > ${shellQuote(crashPusherLogPath)} 2>&1 || true; printf 'deepline runner output captured: %s\\n' ${shellQuote(outputPath)}; exit "$code"`;
 
   return {
     workDir: input.workDir,

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

@@ -233,6 +233,7 @@ export type DetachedDaytonaRunnerSupervisor = {
 export const DAYTONA_RUNNER_READY_TIMEOUT_MS =
   RUNTIME_RELIABILITY_POLICY.sandbox.runnerReadyTimeoutMs;
 const DAYTONA_RUNNER_READY_POLL_MS = 50;
+const DAYTONA_RUNNER_READY_FAST_WINDOW_MS = 250;
 
 export type DetachedRunnerReadinessPort = (
   baselineHeartbeatAt?: string | null,
@@ -474,6 +475,7 @@ export async function confirmDetachedDaytonaRunnerReady(input: {
   );
   const pollMs = Math.max(1, input.pollMs ?? DAYTONA_RUNNER_READY_POLL_MS);
   const deadline = now() + timeoutMs;
+  const fastStartupDeadline = now() + DAYTONA_RUNNER_READY_FAST_WINDOW_MS;
   let schedulerDiagnosis = 'no_readiness_response';
   let schedulerReadinessResponses = 0;
   let retryDelayMs = pollMs;
@@ -491,8 +493,15 @@ export async function confirmDetachedDaytonaRunnerReady(input: {
       schedulerDiagnosis = 'runner_heartbeat_not_observed';
     }
     if (read.timedOut) break;
-    await sleep(Math.min(retryDelayMs, Math.max(1, deadline - now())));
-    retryDelayMs = Math.min(1_000, retryDelayMs * 2);
+    // A healthy store is waiting for a fresh heartbeat, not recovering from
+    // an outage. Avoid compounding its startup delay with the runner's own
+    // park-acknowledgement backoff. Only the first 250ms keeps the 50ms cadence;
+    // unavailable reads and longer initialization retain exponential backoff.
+    const fastStartupRead =
+      read.response !== null && now() < fastStartupDeadline;
+    const delayMs = fastStartupRead ? pollMs : retryDelayMs;
+    await sleep(Math.min(delayMs, Math.max(1, deadline - now())));
+    retryDelayMs = fastStartupRead ? pollMs : Math.min(1_000, retryDelayMs * 2);
   }
 
   const inspect = (sandbox: DaytonaSandbox) =>

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

@@ -308,8 +308,12 @@ class DaytonaUploadDeadlineBreachError extends Error {
 }
 
 export const daytonaSdkClientFactory = {
-  create(input: DaytonaClientOptions, signal?: AbortSignal): DaytonaClient {
-    return createDaytonaLaunchClient(input, signal);
+  create(
+    input: DaytonaClientOptions,
+    signal?: AbortSignal,
+    onCreateStage?: Parameters<typeof createDaytonaLaunchClient>[2],
+  ): DaytonaClient {
+    return createDaytonaLaunchClient(input, signal, onCreateStage);
   },
   /** Request-scoped native deadlines for detached recovery and cleanup. */
   createControl: createDaytonaControlClient,
@@ -1153,7 +1157,16 @@ function emitDaytonaStage(
     stage,
     ...extra,
   };
-  console.info('[play-runner.daytona.stage]', JSON.stringify(payload));
+  try {
+    console.info('[play-runner.daytona.stage]', JSON.stringify(payload));
+  } catch {
+    // Diagnostic delivery never changes resource ownership or command acknowledgement.
+    try {
+      console.error('[play-runner.daytona.stage.failed]', stage);
+    } catch {
+      // No log sink is available; execution still owns its normal lifecycle fences.
+    }
+  }
 }
 
 async function downloadDaytonaTextFile(
@@ -1326,6 +1339,8 @@ function prepareDaytonaExecution(
   const daytona = daytonaSdkClientFactory.create(
     daytonaOptions,
     callbacks?.cancellationSignal,
+    (stage, timing) =>
+      emitDaytonaStage(callbacks, input.context, stage, timing),
   );
   const bundlePromise = buildPlayRunnerBundle();
   const sandboxLifecycle = createOneShotDaytonaSandboxLifecycle({
@@ -1453,6 +1468,8 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
     let cancellationRequested = false;
     let cancellationCleanupStarted = false;
     let activeAcquiredResource: AcquiredDaytonaSandbox | null = null;
+    let resourceAccountingPending = false;
+    let resourceAccountingFailed = false;
     const uploadDeadlineBreaches: DaytonaUploadAttemptTiming[] = [];
     const reportedSandboxIds = new Set<string>();
     const reportedSandboxEndTimes = new Map<string, number | null>();
@@ -1521,6 +1538,12 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
       if (activeAcquiredResource && !activeAcquiredResource.billingEndedAt) {
         activeAcquiredResource.billingEndedAt = Date.now();
       }
+      // Publication may commit after a lost response or lose its attempt fence.
+      // Join it before deciding whether this backend still owns deletion.
+      if (resourceAccountingPending || resourceAccountingFailed) {
+        cancelExecution(new Error(DAYTONA_CANCELLED_ERROR));
+        return;
+      }
       if (cancellationCleanupStarted) {
         cancelExecution(new Error(DAYTONA_CANCELLED_ERROR));
         return;
@@ -1550,6 +1573,7 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
         executionAttempt += 1
       ) {
         let sandboxForAttempt: DaytonaSandbox | null = null;
+        let resourceAccounting: Promise<void> | null = null;
         const attemptStartedAt = Date.now();
         try {
           const acquiredSandbox = await Promise.race([
@@ -1562,15 +1586,27 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
             acquiredSandbox.billingStartedAt - startedAt;
           const sandbox = acquiredSandbox.sandbox;
           sandboxForAttempt = sandbox;
-          await reportRuntimeResource(acquiredSandbox);
-          // Account for every acquired retry sandbox before customer code runs.
-          // This keeps resource persistence failures on the pre-side-effect
-          // side of the execution boundary and makes cancellation billing
-          // complete without a post-terminal write race.
-          await sandboxLifecycle.settlePendingCreates();
-          for (const acquired of sandboxLifecycle.acquiredSandboxes()) {
-            await reportRuntimeResource(acquired);
-          }
+          // Payload upload and session allocation do not execute customer code.
+          // Overlap them with accounting, but join every resource ACK before
+          // command dispatch, retry, or cancellation cleanup.
+          resourceAccountingPending = true;
+          resourceAccounting = (async () => {
+            await reportRuntimeResource(acquiredSandbox);
+            await sandboxLifecycle.settlePendingCreates();
+            for (const acquired of sandboxLifecycle.acquiredSandboxes()) {
+              await reportRuntimeResource(acquired);
+            }
+          })();
+          // Observe settlement immediately; the joins below propagate failures.
+          void resourceAccounting.then(
+            () => {
+              resourceAccountingPending = false;
+            },
+            () => {
+              resourceAccountingPending = false;
+              resourceAccountingFailed = true;
+            },
+          );
           throwIfCancellationRequested();
 
           const { workdir: workDir } = loadDaytonaRunnerPathsConfig();
@@ -1586,6 +1622,7 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
             0,
             Math.floor(config.context.runAttempt ?? 0),
           );
+          let commandAcceptedAtMs: number | null = null;
           const detachedRunner = prepareDetachedDaytonaRunner({
             sandbox,
             sessionId,
@@ -1603,12 +1640,29 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
             },
             cancellation: cancellationPromise,
             onCommandAccepted: async () => {
+              commandAcceptedAtMs = Date.now();
+              emitDaytonaStage(callbacks, config.context, 'execute:accepted', {
+                elapsedMs: commandAcceptedAtMs - startedAt,
+              });
               await callbacks?.onRunnerCommandAccepted?.({
                 provider: 'daytona',
                 sandboxId: sandbox.id,
               });
             },
             onReady: async (ready) => {
+              const heartbeatReadyAtMs = Date.now();
+              emitDaytonaStage(
+                callbacks,
+                config.context,
+                'execute:heartbeat_ready',
+                {
+                  elapsedMs: heartbeatReadyAtMs - startedAt,
+                  commandAcceptedToHeartbeatMs:
+                    commandAcceptedAtMs === null
+                      ? null
+                      : heartbeatReadyAtMs - commandAcceptedAtMs,
+                },
+              );
               await callbacks?.onDetachedRunnerReady?.({
                 provider: 'daytona',
                 sandboxId: sandbox.id,
@@ -1649,8 +1703,13 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
             sandbox,
             DAYTONA_UPLOAD_ATTEMPT_DEADLINE_MS,
           );
+          const finishUpload = () => {
+            uploadScope.dispose();
+            if (uploadDeadlineTimer) clearTimeout(uploadDeadlineTimer);
+            uploadDeadlineTimer = null;
+          };
           try {
-            stagedPayload = await Promise.race([
+            const upload = Promise.race([
               stageDaytonaRunnerPayload({
                 sandbox: uploadScope.sandbox,
                 bundlePromise,
@@ -1662,8 +1721,17 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
               }),
               uploadDeadlinePromise,
               cancellationPromise,
-            ]);
+            ])
+              .then((payload) => {
+                runtimeTiming.daytonaUploadMs = Date.now() - uploadStartedAt;
+                return payload;
+              })
+              .finally(finishUpload);
+            [stagedPayload] = await Promise.all([upload, resourceAccounting]);
           } catch (error) {
+            // A failed or lost publication response keeps cleanup with the
+            // scheduler, even when upload or cancellation failed first.
+            await resourceAccounting;
             if (error instanceof DaytonaUploadDeadlineBreachError) {
               const latestTiming =
                 error.attemptTimings[error.attemptTimings.length - 1];
@@ -1691,12 +1759,8 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
             }
             throw error;
           } finally {
-            uploadScope.dispose();
-            if (uploadDeadlineTimer) {
-              clearTimeout(uploadDeadlineTimer);
-            }
+            finishUpload();
           }
-          runtimeTiming.daytonaUploadMs = Date.now() - uploadStartedAt;
           throwIfCancellationRequested();
 
           emitDaytonaStage(callbacks, config.context, 'execute:start', {
@@ -1785,6 +1849,7 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
             runtimeTiming,
           };
         } catch (error) {
+          if (resourceAccounting) await resourceAccounting;
           if (cancellationRequested || callbacks?.cancellationSignal?.aborted) {
             onCancel();
             throw new Error(DAYTONA_CANCELLED_ERROR);
@@ -1862,7 +1927,7 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
       );
     } finally {
       callbacks?.cancellationSignal?.removeEventListener('abort', onCancel);
-      if (cancellationRequested) {
+      if (cancellationRequested && !resourceAccountingFailed) {
         await sandboxLifecycle.settlePendingCreates();
         for (const acquired of sandboxLifecycle.acquiredSandboxes()) {
           try {