deepline 0.1.208 → 0.1.209

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

@@ -1,4 +1,5 @@
 import { Daytona } from '@daytonaio/sdk';
+import { randomUUID } from 'node:crypto';
 import type {
   PlayRunnerBackend,
   PlayRunnerPreparedExecution,
@@ -6,13 +7,8 @@ import type {
 } from '../types';
 import { RuntimeResourceFenceLostError } from '../types';
 import { buildPlayRunnerBundle } from '../bundle';
-import {
-  findPlayRunnerResult,
-  parsePlayRunnerEventLine,
-  parsePlayRunnerEvents,
-} from '../runner-events';
+import { findPlayRunnerResult, parsePlayRunnerEvents } from '../runner-events';
 import type {
-  PlayRunnerEvent,
   PlayRunnerExecutionConfig,
   PlayRunnerRuntimeTiming,
   PlayRunnerResult,
@@ -36,82 +32,17 @@ import {
   validateDaytonaExecutionContext,
 } from './daytona-lifecycle';
 import { stageDaytonaRunnerPayload } from './daytona-payload-transport';
+import { startDetachedDaytonaCommand } from './daytona-session-execution';
 
 const DAYTONA_EXECUTE_TIMEOUT_SECONDS = STANDARD_PLAY_RUNTIME_LIMIT_SECONDS;
 const STANDARD_WORKFLOW_RUNTIME_LIMIT_ERROR = `Based on this plan, max runtime is ${STANDARD_PLAY_RUNTIME_LIMIT_LABEL}. Use smaller batches; ask for runtime.`;
-const DAYTONA_OUTPUT_TAIL_CHARS = 2_000;
 const DAYTONA_COMMAND_RECOVERY_TIMEOUT_MS = 60_000;
 const DAYTONA_COMMAND_RECOVERY_POLL_MS = 2_000;
-const DAYTONA_PROGRESS_SIDECAR_POLL_MS = 1_000;
 const DAYTONA_RUNTIME_INITIALIZATION_MAX_ATTEMPTS = 2;
 const DAYTONA_INFRASTRUCTURE_MAX_ATTEMPTS = 2;
 const DAYTONA_UPLOAD_MAX_ATTEMPTS = 2;
 const DAYTONA_UPLOAD_ATTEMPT_DEADLINE_MS = 90_000;
-/**
- * Client-side wall-clock grace for `sandbox.process.executeCommand`. The
- * `timeout` argument we pass is a SERVER-side directive; the Daytona SDK's
- * underlying HTTP call has no client deadline, so a wedged socket (observed:
- * `AggregateError [ETIMEDOUT]`) leaves the await hanging forever and holds the
- * worker slot. We race the call against this deadline = server timeout + grace,
- * so a genuine server-side runtime-limit hit still returns first, but a wedged
- * client transport fails the attempt loudly and lets the engine retry ladder
- * take over instead of livelocking the slot.
- */
-const DAYTONA_EXECUTE_CLIENT_GRACE_MS = 60_000;
-const DAYTONA_EXECUTE_CLIENT_DEADLINE_MS =
-  DAYTONA_EXECUTE_TIMEOUT_SECONDS * 1_000 + DAYTONA_EXECUTE_CLIENT_GRACE_MS;
-/**
- * Bound for individual sandbox/runtime API calls that have no natural timeout
- * (e.g. recording the acquired runtime resource). A wedged one of these must
- * fail the attempt, not hold the slot.
- */
-const DAYTONA_API_CALL_DEADLINE_MS = 60_000;
-
-export class DaytonaOperationDeadlineError extends Error {
-  readonly operation: string;
-  readonly deadlineMs: number;
-
-  constructor(input: { operation: string; deadlineMs: number }) {
-    super(
-      `Daytona operation "${input.operation}" exceeded client deadline of ${input.deadlineMs}ms and was abandoned to free the worker slot.`,
-    );
-    this.name = 'DaytonaOperationDeadlineError';
-    this.operation = input.operation;
-    this.deadlineMs = input.deadlineMs;
-  }
-}
 
-/**
- * Race `promise` against a wall-clock deadline. On breach, reject loudly with a
- * `DaytonaOperationDeadlineError` (the caller's retry/failure classification
- * decides what happens next). The timer is always cleared so a fast-resolving
- * promise never leaves a dangling handle.
- */
-export async function withDaytonaOperationDeadline<T>(input: {
-  operation: string;
-  deadlineMs: number;
-  promise: Promise<T>;
-}): Promise<T> {
-  let deadlineTimer: ReturnType<typeof setTimeout> | null = null;
-  const deadlinePromise = new Promise<never>((_resolve, reject) => {
-    deadlineTimer = setTimeout(() => {
-      reject(
-        new DaytonaOperationDeadlineError({
-          operation: input.operation,
-          deadlineMs: input.deadlineMs,
-        }),
-      );
-    }, input.deadlineMs);
-    deadlineTimer.unref?.();
-  });
-  try {
-    return await Promise.race([input.promise, deadlinePromise]);
-  } finally {
-    if (deadlineTimer) {
-      clearTimeout(deadlineTimer);
-    }
-  }
-}
 const RUNTIME_POSTGRES_CONNECT_RETRY_PATTERN =
   /\bRuntime Postgres\b.*\b(connection timed out|connect timeout|ETIMEDOUT|ECONNRESET|ECONNREFUSED|Connection terminated|Connection ended unexpectedly)\b/i;
 const RUNTIME_RECEIPT_GATEWAY_TRANSPORT_RETRY_PATTERN =
@@ -153,33 +84,110 @@ class DaytonaUploadDeadlineBreachError extends Error {
   }
 }
 
-class DaytonaCommandTransportError extends Error {
-  readonly sandboxId: string;
-  readonly commandError: unknown;
-  readonly recoveryError: unknown;
-
-  constructor(input: {
-    sandboxId: string;
-    commandError: unknown;
-    recoveryError: unknown;
-  }) {
-    super(
-      `Daytona command transport failed for sandbox ${input.sandboxId}: ${formatDaytonaError(input.commandError)}. Recovery could not read the command result: ${formatDaytonaError(input.recoveryError)}.`,
-      { cause: input.commandError },
-    );
-    this.name = 'DaytonaCommandTransportError';
-    this.sandboxId = input.sandboxId;
-    this.commandError = input.commandError;
-    this.recoveryError = input.recoveryError;
-  }
-}
-
 export const daytonaSdkClientFactory = {
   create(input: ConstructorParameters<typeof Daytona>[0]): DaytonaClient {
     return new Daytona(input);
   },
+  /** Full client (get/delete by id) for best-effort GC of orphaned sandboxes. */
+  createFull(input: ConstructorParameters<typeof Daytona>[0]): Daytona {
+    return new Daytona(input);
+  },
 };
 
+/**
+ * Best-effort deletion of an orphaned Daytona sandbox by id (push-execution B4).
+ *
+ * When the scheduler's expired-claim sweeper reclaims a run whose worker was
+ * babysitting a sandbox, nothing tears that sandbox down — `ephemeral +
+ * autoStop` is the only backstop, which leaks paid compute until it fires. The
+ * worker records each acquired sandbox id under the fenced lease, so on the
+ * reclaim / terminal-failure path it can look the sandbox up by id and delete
+ * it. Failures are swallowed: the run already ended, and the autoStop backstop
+ * still applies.
+ */
+/**
+ * Timeout-wake verification for a detached push-execution runner (B2-final).
+ *
+ * When the parked attempt's ceiling timeout fires without a pushed terminal,
+ * the wake leg calls this to distinguish "runner finished but its terminal
+ * push was lost" from "runner died silently": read the session command's exit
+ * code, then salvage the structured `result` event from the captured output
+ * file. Everything is best-effort — a deleted/expired sandbox yields
+ * `{ exitCode: null, result: null }` and the attempt fails through the normal
+ * engine retry/fencing path.
+ */
+export async function inspectDetachedDaytonaRunner(input: {
+  sandboxId: string;
+  sessionId: string;
+  cmdId: string;
+  outputPath: string;
+  exitCodePath: string;
+}): Promise<{ exitCode: number | null; result: PlayRunnerResult | null }> {
+  try {
+    const { clientOptions } = loadDaytonaRequiredConfig();
+    const daytona = daytonaSdkClientFactory.createFull(clientOptions);
+    const sandbox = (await daytona.get(input.sandboxId)) as DaytonaSandbox;
+    let exitCode: number | null = null;
+    try {
+      const command = await sandbox.process.getSessionCommand(
+        input.sessionId,
+        input.cmdId,
+      );
+      exitCode = typeof command?.exitCode === 'number' ? command.exitCode : null;
+    } catch (error) {
+      console.warn('[play-runner.daytona.detached_inspect_command_failed]', {
+        sandboxId: input.sandboxId,
+        cmdId: input.cmdId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+    const recovered = await recoverDaytonaCommandExecution({
+      sandbox,
+      outputPath: input.outputPath,
+      exitCodePath: input.exitCodePath,
+      timeoutMs: 10_000,
+    });
+    if (!recovered.execution) {
+      return { exitCode, result: null };
+    }
+    const result =
+      findPlayRunnerResult(parsePlayRunnerEvents(recovered.execution.result)) ??
+      null;
+    return {
+      exitCode: exitCode ?? recovered.execution.exitCode,
+      result,
+    };
+  } catch (error) {
+    console.warn('[play-runner.daytona.detached_inspect_failed]', {
+      sandboxId: input.sandboxId,
+      cmdId: input.cmdId,
+      error: error instanceof Error ? error.message : String(error),
+    });
+    return { exitCode: null, result: null };
+  }
+}
+
+export async function deleteDaytonaSandboxById(input: {
+  sandboxId: string;
+  timeoutSeconds?: number;
+}): Promise<boolean> {
+  const sandboxId = input.sandboxId?.trim();
+  if (!sandboxId) return false;
+  try {
+    const { clientOptions } = loadDaytonaRequiredConfig();
+    const daytona = daytonaSdkClientFactory.createFull(clientOptions);
+    const sandbox = await daytona.get(sandboxId);
+    await daytona.delete(sandbox, input.timeoutSeconds ?? 30);
+    return true;
+  } catch (error) {
+    console.warn('[play-runner.daytona.reclaim_sandbox_delete_failed]', {
+      sandboxId,
+      error: error instanceof Error ? error.message : String(error),
+    });
+    return false;
+  }
+}
+
 function formatDaytonaExecutionError(error: unknown): string {
   const message = formatDaytonaError(error);
   return isConfiguredDaytonaRuntimeLimit(error)
@@ -212,14 +220,6 @@ function isConfiguredDaytonaRuntimeLimit(error: unknown): boolean {
   ).test(message);
 }
 
-function getDaytonaOutputTail(output: unknown): string | null {
-  const text = String(output ?? '').trim();
-  if (!text) {
-    return null;
-  }
-  return text.slice(-DAYTONA_OUTPUT_TAIL_CHARS);
-}
-
 function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -251,161 +251,6 @@ function emitDaytonaStage(
   console.info('[play-runner.daytona.stage]', JSON.stringify(payload));
 }
 
-function dispatchDaytonaRunnerEvent(input: {
-  event: PlayRunnerEvent;
-  callbacks: Parameters<PlayRunnerBackend['execute']>[1];
-  context: DaytonaExecutionContext;
-  sandboxId: string;
-  startedAt: number;
-}): void {
-  const { event, callbacks, context, sandboxId, startedAt } = input;
-  if (event.type === 'log') {
-    if (
-      event.line.startsWith('[perf]') ||
-      event.line.includes('Executing tool batch')
-    ) {
-      emitDaytonaStage(callbacks, context, 'runner:log', {
-        sandboxId,
-        line: event.line,
-        elapsedMs: Date.now() - startedAt,
-      });
-    }
-    callbacks?.onLog?.(event);
-    return;
-  }
-  if (event.type === 'checkpoint') {
-    callbacks?.onCheckpoint?.(event.checkpoint);
-    return;
-  }
-  if (event.type === 'row_update') {
-    callbacks?.onRowUpdate?.(event.update);
-    return;
-  }
-  if (event.type === 'execution_event') {
-    callbacks?.onExecutionEvent?.(event.event);
-  }
-}
-
-function createDaytonaProgressSidecarPoller(input: {
-  sandbox: DaytonaSandbox;
-  progressEventPath: string;
-  callbacks: Parameters<PlayRunnerBackend['execute']>[1];
-  context: DaytonaExecutionContext;
-  startedAt: number;
-  processedEventKeys: Set<string>;
-}): { start(): void; stop(flush?: boolean): Promise<void> } {
-  let timer: ReturnType<typeof setTimeout> | null = null;
-  let stopped = false;
-  let inFlight: Promise<void> = Promise.resolve();
-  let segment = 0;
-  let offsetBytes = 0;
-  let pendingLine = '';
-  let warned = false;
-
-  const processText = (text: string, flushPartial = false) => {
-    const combined = pendingLine + text;
-    const lines = combined.split(/\r?\n/);
-    const completeLines = flushPartial ? lines : lines.slice(0, -1);
-    pendingLine = flushPartial ? '' : (lines.at(-1) ?? '');
-    for (const rawLine of completeLines) {
-      const line = rawLine.trim();
-      if (!line) {
-        continue;
-      }
-      const event = parsePlayRunnerEventLine(line);
-      if (!event) {
-        continue;
-      }
-      const eventKey = JSON.stringify(event);
-      input.processedEventKeys.add(eventKey);
-      dispatchDaytonaRunnerEvent({
-        event,
-        callbacks: input.callbacks,
-        context: input.context,
-        sandboxId: input.sandbox.id,
-        startedAt: input.startedAt,
-      });
-    }
-  };
-
-  const poll = async (flushPartial = false): Promise<void> => {
-    try {
-      const manifest = await input.sandbox.fs.downloadFile(
-        input.progressEventPath,
-        5,
-      );
-      const parsedLatestSegment = Number.parseInt(
-        Buffer.isBuffer(manifest)
-          ? manifest.toString('utf-8').trim()
-          : String(manifest).trim(),
-        10,
-      );
-      const latestSegment = Number.isFinite(parsedLatestSegment)
-        ? Math.max(segment, parsedLatestSegment)
-        : segment;
-      while (segment <= latestSegment) {
-        const segmentPath = `${input.progressEventPath}.${String(
-          segment,
-        ).padStart(6, '0')}`;
-        const file = await input.sandbox.fs.downloadFile(segmentPath, 5);
-        const buffer = Buffer.isBuffer(file) ? file : Buffer.from(file);
-        if (buffer.length < offsetBytes) {
-          offsetBytes = 0;
-          pendingLine = '';
-        }
-        if (buffer.length > offsetBytes) {
-          const chunk = buffer.subarray(offsetBytes).toString('utf-8');
-          offsetBytes = buffer.length;
-          processText(chunk, flushPartial && segment === latestSegment);
-        }
-        if (segment >= latestSegment) break;
-        segment += 1;
-        offsetBytes = 0;
-      }
-      if (flushPartial && pendingLine.trim()) {
-        processText('\n', true);
-      }
-    } catch (error) {
-      if (!warned && !/not found|no such file|ENOENT/i.test(String(error))) {
-        warned = true;
-        console.warn('[play-runner.daytona.progress_sidecar_poll_failed]', {
-          sandboxId: input.sandbox.id,
-          progressEventPath: input.progressEventPath,
-          error: error instanceof Error ? error.message : String(error),
-        });
-      }
-    }
-  };
-
-  const schedule = () => {
-    if (stopped) {
-      return;
-    }
-    timer = setTimeout(() => {
-      inFlight = inFlight
-        .catch(() => {})
-        .then(() => poll())
-        .finally(schedule);
-    }, DAYTONA_PROGRESS_SIDECAR_POLL_MS);
-    timer.unref?.();
-  };
-
-  return {
-    start() {
-      inFlight = inFlight.then(() => poll()).finally(schedule);
-    },
-    async stop(flush = true) {
-      stopped = true;
-      if (timer) {
-        clearTimeout(timer);
-        timer = null;
-      }
-      await inFlight.catch(() => {});
-      if (flush) await poll(true);
-    },
-  };
-}
-
 async function downloadDaytonaTextFile(
   sandbox: DaytonaSandbox,
   remotePath: string,
@@ -451,23 +296,6 @@ async function recoverDaytonaCommandExecution(input: {
   return { execution: null, lastError };
 }
 
-async function resolveDaytonaCommandOutput(input: {
-  sandbox: DaytonaSandbox;
-  outputPath: string;
-  exitCodePath: string;
-  executionResult: unknown;
-}): Promise<string> {
-  const recovered = await recoverDaytonaCommandExecution({
-    sandbox: input.sandbox,
-    outputPath: input.outputPath,
-    exitCodePath: input.exitCodePath,
-  });
-  if (recovered.execution) {
-    return recovered.execution.result;
-  }
-  return String(input.executionResult ?? '');
-}
-
 function createDaytonaCancelledResult(
   config: PlayRunnerExecutionConfig,
 ): PlayRunnerResult {
@@ -499,7 +327,14 @@ function createDaytonaFailedResult(input: {
   };
 }
 
-function retryableRuntimeInitializationFailureReason(
+/**
+ * Classify a failed runner result as a retryable runtime-initialization /
+ * transport failure. Exported for the absurd worker's detached wake leg
+ * (B2-final): the backend no longer sees the runner result (it arrives via the
+ * gateway terminal push), so the fresh-sandbox retry decision moved to the
+ * worker, which throws a retryable error into the engine retry ladder.
+ */
+export function retryableRuntimeInitializationFailureReason(
   result: PlayRunnerResult,
 ):
   | 'runtime_postgres_connect'
@@ -525,15 +360,6 @@ function retryableRuntimeInitializationFailureReason(
 }
 
 function isRetryableDaytonaInfrastructureFailure(error: unknown): boolean {
-  if (error instanceof DaytonaCommandTransportError) {
-    return false;
-  }
-  // A client-side deadline breach is a wedged transport (hung socket / SDK call
-  // with no client timeout). Retry once on a fresh sandbox before spending an
-  // engine attempt, same as the other transport-level infrastructure failures.
-  if (error instanceof DaytonaOperationDeadlineError) {
-    return true;
-  }
   const message = error instanceof Error ? error.message : String(error);
   if (!message || /cancelled|aborted/i.test(message)) {
     return false;
@@ -587,6 +413,23 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
         tableNamespace: null,
       };
     }
+    // Push execution is THE Daytona shape (B2-final): the worker parks after
+    // the detached start and finalizes from the runner's pushed terminal.
+    // There is deliberately no worker-babysat fallback — a launch without the
+    // push config is a wiring bug, not a mode.
+    const push = config.context.runnerPushExecution;
+    if (!push) {
+      return {
+        status: 'failed',
+        error:
+          'Daytona runner backend requires push-execution config (context.runnerPushExecution). Worker-babysat Daytona execution was removed; submit through the absurd scheduler, which stamps it.',
+        logs: [],
+        stats: {},
+        steps: [],
+        checkpoint: config.checkpoint ?? null,
+        tableNamespace: null,
+      };
+    }
     let preparedExecution: DaytonaPreparedExecution;
     try {
       preparedExecution = isDaytonaPreparedExecution(prepared)
@@ -831,31 +674,24 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
           emitDaytonaStage(callbacks, config.context, 'execute:start', {
             sandboxId: sandbox.id,
             timeoutSeconds: DAYTONA_EXECUTE_TIMEOUT_SECONDS,
-            mode: 'command',
-          });
-          const executionStartedAt = Date.now();
-          const streamedEventKeys = new Set<string>();
-          const progressSidecar = createDaytonaProgressSidecarPoller({
-            sandbox,
-            progressEventPath: stagedPayload.progressEventPath,
-            callbacks,
-            context: config.context,
-            startedAt,
-            processedEventKeys: streamedEventKeys,
+            mode: 'session_detached',
           });
-          let execution: DaytonaExecution;
+          // Push execution (B2-final, park-and-wake): start the runner command
+          // DETACHED via a Daytona session and return a `detached_runner`
+          // suspension immediately — the worker parks on it (releasing its
+          // claim, freeing the slot) and wakes on the runner's pushed terminal
+          // or the ceiling timeout. Nothing here awaits completion: no held
+          // socket, no poll loop, no per-second sandbox file reads. The sandbox
+          // MUST outlive this return (the runner is executing inside it); the
+          // wake leg owns finalize + sandbox GC.
+          const sessionId = `deepline-play-${randomUUID()}`;
+          let start: Awaited<ReturnType<typeof startDetachedDaytonaCommand>>;
           try {
-            progressSidecar.start();
-            execution = await Promise.race([
-              withDaytonaOperationDeadline({
-                operation: 'sandbox.process.executeCommand',
-                deadlineMs: DAYTONA_EXECUTE_CLIENT_DEADLINE_MS,
-                promise: sandbox.process.executeCommand(
-                  stagedPayload.command,
-                  stagedPayload.workDir,
-                  undefined,
-                  DAYTONA_EXECUTE_TIMEOUT_SECONDS,
-                ),
+            start = await Promise.race([
+              startDetachedDaytonaCommand({
+                sandbox,
+                sessionId,
+                command: stagedPayload.command,
               }),
               cancellationPromise,
             ]);
@@ -867,148 +703,48 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
               onCancel();
               throw new Error(DAYTONA_CANCELLED_ERROR);
             }
-            const recovered = await recoverDaytonaCommandExecution({
-              sandbox,
-              outputPath: stagedPayload.outputPath,
-              exitCodePath: stagedPayload.exitCodePath,
-            });
-            emitDaytonaStage(
-              callbacks,
-              config.context,
-              'execute:transport_error',
-              {
-                sandboxId: sandbox.id,
-                operation: 'sandbox.process.executeCommand',
-                error: formatDaytonaError(error),
-                recovery: recovered.execution ? 'recovered' : 'unavailable',
-                recoveryError: recovered.execution
-                  ? null
-                  : formatDaytonaError(recovered.lastError),
-                elapsedMs: Date.now() - startedAt,
-              },
-            );
-            if (!recovered.execution) {
-              throw new DaytonaCommandTransportError({
-                sandboxId: sandbox.id,
-                commandError: error,
-                recoveryError: recovered.lastError,
-              });
-            }
-            emitDaytonaStage(callbacks, config.context, 'execute:recovered', {
-              sandboxId: sandbox.id,
-              error: formatDaytonaError(error),
-              exitCode: recovered.execution.exitCode,
-              outputBytes: recovered.execution.result.length,
-              elapsedMs: Date.now() - startedAt,
-            });
-            execution = recovered.execution;
-          } finally {
-            await progressSidecar.stop(
-              !cancellationRequested &&
-                callbacks?.cancellationSignal?.aborted !== true,
-            );
+            // Start never launched customer code; let the infrastructure retry
+            // classification below decide fresh-sandbox retry vs loud failure.
+            throw error;
           }
-          const runnerOutput = await resolveDaytonaCommandOutput({
-            sandbox,
-            outputPath: stagedPayload.outputPath,
-            exitCodePath: stagedPayload.exitCodePath,
-            executionResult: execution.result,
-          });
-          emitDaytonaStage(callbacks, config.context, 'execute:done', {
+          const runnerAttempt = Math.max(
+            0,
+            Math.floor(config.context.runAttempt ?? 0),
+          );
+          emitDaytonaStage(callbacks, config.context, 'execute:detached', {
             sandboxId: sandbox.id,
-            exitCode: execution.exitCode,
-            outputBytes: runnerOutput.length,
-            executeElapsedMs: Date.now() - executionStartedAt,
+            sessionId: start.sessionId,
+            cmdId: start.cmdId,
+            runnerAttempt,
+            ceilingSeconds: DAYTONA_EXECUTE_TIMEOUT_SECONDS,
             elapsedMs: Date.now() - startedAt,
           });
-          runtimeTiming.daytonaExecuteMs = Date.now() - executionStartedAt;
-          const events = parsePlayRunnerEvents(runnerOutput);
-          for (const event of events) {
-            const eventKey = JSON.stringify(event);
-            if (streamedEventKeys.has(eventKey)) {
-              continue;
-            }
-            dispatchDaytonaRunnerEvent({
-              event,
-              callbacks,
-              context: config.context,
+          return {
+            status: 'suspended',
+            suspension: {
+              kind: 'detached_runner',
+              boundaryId: `detached-runner:${push.runId}:${runnerAttempt}`,
+              runnerAttempt,
               sandboxId: sandbox.id,
-              startedAt,
-            });
-          }
-
-          const result = findPlayRunnerResult(events);
-          if (result) {
-            const initializationRetryReason =
-              retryableRuntimeInitializationFailureReason(result);
-            if (
-              result.status === 'failed' &&
-              executionAttempt < DAYTONA_RUNTIME_INITIALIZATION_MAX_ATTEMPTS &&
-              initializationRetryReason
-            ) {
-              emitDaytonaStage(callbacks, config.context, 'execute:retry', {
-                sandboxId: sandbox.id,
-                attempt: executionAttempt + 1,
-                reason: initializationRetryReason,
-                error: result.error,
-                elapsedMs: Date.now() - startedAt,
-              });
-              acquiredSandbox.billingEndedAt = Date.now();
-              await reportRetiringRuntimeResource(acquiredSandbox);
-              sandboxCleanup.stashActiveSandboxForRetry();
-              acquiredSandboxPromise = sandboxLifecycle.createFreshSandbox();
-              continue;
-            }
-            if (result.status === 'failed') {
-              emitDaytonaStage(
-                callbacks,
-                config.context,
-                'runner:failed_result',
-                {
-                  sandboxId: sandbox.id,
-                  exitCode: execution.exitCode,
-                  outputBytes: runnerOutput.length,
-                  error: result.error,
-                  outputTail: getDaytonaOutputTail(runnerOutput),
-                  elapsedMs: Date.now() - startedAt,
-                },
-              );
-            }
-            return withCleanup(result);
-          }
-
-          // executeCommand only returns the transport wrapper's captured-file
-          // path. The downloaded runner output contains the actual exception.
-          const outputTail = getDaytonaOutputTail(runnerOutput);
-          if (outputTail) {
-            emitDaytonaStage(
-              callbacks,
-              config.context,
-              'runner:missing_result',
-              {
-                sandboxId: sandbox.id,
-                exitCode: execution.exitCode,
-                outputTail,
-                elapsedMs: Date.now() - startedAt,
-              },
-            );
-          }
-
-          return withCleanup(
-            createDaytonaFailedResult({
-              config,
-              error:
-                typeof execution.exitCode === 'number' &&
-                execution.exitCode !== 0
-                  ? `Daytona play runner exited with code ${execution.exitCode}${
-                      execution.exitCode === 137
-                        ? ' (sandbox OOM or forced SIGKILL)'
-                        : ''
-                    }.${outputTail ? ` Output tail: ${outputTail}` : ''}`
-                  : 'Daytona play runner produced no result.',
-              runtimeTiming,
-            }),
-          );
+              sessionId: start.sessionId,
+              cmdId: start.cmdId,
+              outputPath: stagedPayload.outputPath,
+              exitCodePath: stagedPayload.exitCodePath,
+              startedAtMs: Date.now(),
+              ceilingMs: DAYTONA_EXECUTE_TIMEOUT_SECONDS * 1_000,
+            },
+            logs: [],
+            stats: {},
+            steps: [],
+            checkpoint: config.checkpoint ?? {
+              completedBatches: {},
+              completedToolBatches: {},
+              resolvedWaterfalls: {},
+              resolvedBoundaries: {},
+            },
+            tableNamespace: null,
+            runtimeTiming,
+          };
         } catch (error) {
           if (cancellationRequested || callbacks?.cancellationSignal?.aborted) {
             onCancel();
@@ -1053,10 +789,7 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
       emitDaytonaStage(callbacks, config.context, 'execute:error', {
         sandboxId: sandboxCleanup.currentSandbox()?.id ?? null,
         error: formatDaytonaError(error),
-        operation:
-          error instanceof DaytonaCommandTransportError
-            ? 'sandbox.process.executeCommand'
-            : 'runner_backend',
+        operation: 'runner_backend',
         elapsedMs: Date.now() - startedAt,
       });
       return withCleanup(