deepline 0.1.260 → 0.1.261

package/dist/bundling-sources/sdk/src/release.ts

@@ -123,7 +123,7 @@ export const SDK_RELEASE = {
   // Deepline-native radars. Older clients must update before discovering,
   // checking, or deploying an unlaunched monitor integration.
   // 0.1.253 makes play-page browser opening opt-in and retires --no-open.
-  version: '0.1.260',
+  version: '0.1.261',
   apiContract: '2026-07-native-monitor-launch-hard-cutover',
   supportPolicy: {
     minimumSupported: '0.1.53',

package/dist/bundling-sources/shared_libs/play-runtime/gateway-auth-session.ts

@@ -8,6 +8,12 @@ export type GatewayAuthSession<TAuth, TLaunch> = {
   source: 'hit' | 'miss' | 'coalesced';
 };
 
+/**
+ * Launch rows are immutable for an executor token's lifetime. The cache still
+ * caps each entry at the token expiry in getOrEstablish.
+ */
+export const GATEWAY_IMMUTABLE_SESSION_TTL_MS = 45_000;
+
 type StoredSession<TAuth, TLaunch> = {
   auth: TAuth;
   launch: TLaunch;

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

@@ -55,8 +55,6 @@ export const DAYTONA_CRASH_PUSHER_OUTPUT_TAIL_MAX_BYTES =
 export type StagedDaytonaPayload = {
   workDir: string;
   command: string;
-  readyPath: string;
-  startAckPath: string;
   outputPath: string;
   exitCodePath: string;
   progressEventPath: string;
@@ -456,8 +454,6 @@ export async function stageDaytonaRunnerPayload(input: {
   const outputPath = `${workDir}/deepline-play-output-${randomUUID()}.log`;
   const crashPusherLogPath = `${workDir}/deepline-play-crash-terminal-${randomUUID()}.log`;
   const exitCodePath = `${workDir}/deepline-play-exit-${randomUUID()}.txt`;
-  const readyPath = `${workDir}/deepline-play-ready-${randomUUID()}.json`;
-  const startAckPath = `${workDir}/deepline-play-start-ack-${randomUUID()}.json`;
   const runtimeStartedPath = `${workDir}/deepline-play-runtime-started-${randomUUID()}.json`;
   const runtimeCompletedPath = `${workDir}/deepline-play-runtime-completed-${randomUUID()}.json`;
   const runtimeLimitMarkerPath = `${workDir}/deepline-play-runtime-limit-${randomUUID()}.txt`;
@@ -486,7 +482,7 @@ export async function stageDaytonaRunnerPayload(input: {
     artifactCodePath,
     artifactSourceMapPath,
     crashPusherPath,
-  })} && DEEPLINE_PLAY_RUNNER_READY_PATH=${shellQuote(readyPath)} DEEPLINE_PLAY_RUNNER_START_ACK_PATH=${shellQuote(startAckPath)} 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_STDOUT_EVENT_MODE=compact ${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_STDOUT_EVENT_MODE=compact ${runnerTraceEnv}${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
@@ -495,13 +491,11 @@ export async function stageDaytonaRunnerPayload(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(readyPath)} ${shellQuote(startAckPath)} ${shellQuote(runtimeStartedPath)} ${shellQuote(runtimeCompletedPath)} ${shellQuote(runtimeLimitMarkerPath)} ${shellQuote(progressEventPath)} ${shellQuote(`${progressEventPath}.*`)}; ( ${runnerCommand} ) > ${shellQuote(outputPath)} 2>&1; code=$?; printf '%s' "$code" > ${shellQuote(exitCodePath)}; node ${shellQuote(crashPusherPath)} ${shellQuote(configPath)} "$code" ${shellQuote(outputPath)} ${shellQuote(runtimeLimitMarkerPath)} > ${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(runtimeStartedPath)} ${shellQuote(runtimeCompletedPath)} ${shellQuote(runtimeLimitMarkerPath)} ${shellQuote(progressEventPath)} ${shellQuote(`${progressEventPath}.*`)}; ( ${runnerCommand} ) > ${shellQuote(outputPath)} 2>&1; code=$?; printf '%s' "$code" > ${shellQuote(exitCodePath)}; node ${shellQuote(crashPusherPath)} ${shellQuote(configPath)} "$code" ${shellQuote(outputPath)} ${shellQuote(runtimeLimitMarkerPath)} > ${shellQuote(crashPusherLogPath)} 2>&1 || true; printf 'deepline runner output captured: %s\\n' ${shellQuote(outputPath)}; exit "$code"`;
 
   return {
     workDir: input.workDir,
     command,
-    readyPath,
-    startAckPath,
     outputPath,
     exitCodePath,
     progressEventPath,

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

@@ -1,8 +1,8 @@
 import type { DaytonaSandbox } from './daytona-lifecycle';
 
 export type DetachedDaytonaStartupDiagnostic = {
-  readyMarkerObserved: boolean;
-  startAcknowledgementAttempted: boolean;
+  schedulerReadinessObserved: boolean;
+  schedulerReadinessResponses: number;
   commandFound: boolean;
   exitCode: number | null;
   sessionFound: boolean;
@@ -53,8 +53,8 @@ export async function inspectDetachedDaytonaStartup(input: {
 }): Promise<DetachedDaytonaStartupDiagnostic> {
   const errors: string[] = [];
   const diagnostic: DetachedDaytonaStartupDiagnostic = {
-    readyMarkerObserved: false,
-    startAcknowledgementAttempted: false,
+    schedulerReadinessObserved: false,
+    schedulerReadinessResponses: 0,
     commandFound: false,
     exitCode: null,
     sessionFound: false,
@@ -116,11 +116,113 @@ export type DetachedDaytonaCommandStart = {
   cmdId: string;
 };
 
-// The marker now proves artifact materialization plus an accepted gateway
-// heartbeat. Keep the handoff bounded, while allowing a cold Fly gateway and
-// one timed-out heartbeat request to recover before the worker rejects it.
-export const DAYTONA_RUNNER_READY_TIMEOUT_MS = 60_000;
-const DAYTONA_RUNNER_READY_POLL_MS = 250;
+// The durable heartbeat proves runner-process liveness plus gateway reachability.
+// Keep the handoff bounded while allowing a cold gateway to recover.
+export const DAYTONA_RUNNER_READY_TIMEOUT_MS = 30_000;
+const DAYTONA_RUNNER_READY_POLL_MS = 50;
+
+export type DetachedRunnerReadinessPort = (
+  baselineHeartbeatAt?: string | null,
+) => Promise<RunnerReadinessResponse | null>;
+
+type RunnerReadinessResponse = {
+  ready: boolean;
+  heartbeatAt: string | null;
+};
+
+async function requestRunnerReadiness(input: {
+  readiness: DetachedRunnerReadinessPort;
+  baselineHeartbeatAt?: string | null;
+  timeoutMs: number;
+}): Promise<{
+  response: RunnerReadinessResponse | null;
+  diagnosis: string;
+  timedOut: boolean;
+}> {
+  const timedOut = Symbol('readiness_timeout');
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    // Bound the only in-flight scheduler-store read by the remaining startup
+    // budget. If it times out, callers stop polling instead of layering a new
+    // query over the abandoned one and amplifying a degraded connection pool.
+    const response = await Promise.race([
+      input.readiness(input.baselineHeartbeatAt),
+      new Promise<typeof timedOut>((resolve) => {
+        timeout = setTimeout(
+          () => resolve(timedOut),
+          Math.max(1, input.timeoutMs),
+        );
+      }),
+    ]);
+    if (response === timedOut) {
+      return {
+        response: null,
+        diagnosis: 'readiness_timeout',
+        timedOut: true,
+      };
+    }
+    if (!response)
+      return {
+        response: null,
+        diagnosis: 'readiness_unavailable',
+        timedOut: false,
+      };
+    return {
+      response,
+      diagnosis: 'ok',
+      timedOut: false,
+    };
+  } catch {
+    return {
+      response: null,
+      diagnosis: 'readiness_unavailable',
+      timedOut: false,
+    };
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+
+/**
+ * Capture the attempt heartbeat using the scheduler's Postgres clock before
+ * launching customer code. The post-launch readiness poll waits for this exact
+ * database value to advance, avoiding both a gateway protocol dependency and
+ * any comparison with the worker host clock.
+ */
+export async function captureDetachedDaytonaRunnerReadinessBaseline(input: {
+  readiness: DetachedRunnerReadinessPort;
+  timeoutMs?: number;
+  pollMs?: number;
+  now?: () => number;
+  sleep?: (ms: number) => Promise<void>;
+}): Promise<string | null> {
+  const now = input.now ?? Date.now;
+  const sleep =
+    input.sleep ??
+    ((ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms)));
+  const timeoutMs = Math.max(
+    1,
+    input.timeoutMs ?? DAYTONA_RUNNER_READY_TIMEOUT_MS,
+  );
+  const pollMs = Math.max(1, input.pollMs ?? DAYTONA_RUNNER_READY_POLL_MS);
+  const deadline = now() + timeoutMs;
+  let diagnosis = 'no_readiness_response';
+  let retryDelayMs = pollMs;
+  while (now() < deadline) {
+    const read = await requestRunnerReadiness({
+      readiness: input.readiness,
+      timeoutMs: Math.max(1, deadline - now()),
+    });
+    diagnosis = read.diagnosis;
+    if (read.response) return read.response.heartbeatAt;
+    if (read.timedOut) break;
+    await sleep(Math.min(retryDelayMs, Math.max(1, deadline - now())));
+    retryDelayMs = Math.min(1_000, retryDelayMs * 2);
+  }
+  throw new Error(
+    `Daytona readiness baseline could not reach the scheduler store before command launch within ${timeoutMs}ms (${diagnosis}). Customer play code was not started.`,
+  );
+}
 
 export class DaytonaRunnerInitializationError extends Error {
   constructor(
@@ -141,7 +243,22 @@ export async function startDetachedDaytonaCommand(input: {
   sessionId: string;
   command: string;
 }): Promise<DetachedDaytonaCommandStart> {
+  await createDetachedDaytonaSession(input);
+  return executeDetachedDaytonaSessionCommand(input);
+}
+
+export async function createDetachedDaytonaSession(input: {
+  sandbox: DaytonaSandbox;
+  sessionId: string;
+}): Promise<void> {
   await input.sandbox.process.createSession(input.sessionId);
+}
+
+export async function executeDetachedDaytonaSessionCommand(input: {
+  sandbox: DaytonaSandbox;
+  sessionId: string;
+  command: string;
+}): Promise<DetachedDaytonaCommandStart> {
   const response = await input.sandbox.process.executeSessionCommand(
     input.sessionId,
     {
@@ -169,9 +286,9 @@ export async function confirmDetachedDaytonaRunnerReady(input: {
   sandbox: DaytonaSandbox;
   sessionId: string;
   cmdId: string;
-  readyPath: string;
-  startAckPath: string;
   exitCodePath: string;
+  readiness: DetachedRunnerReadinessPort;
+  baselineHeartbeatAt: string | null;
   timeoutMs?: number;
   pollMs?: number;
   now?: () => number;
@@ -187,35 +304,25 @@ export async function confirmDetachedDaytonaRunnerReady(input: {
   );
   const pollMs = Math.max(1, input.pollMs ?? DAYTONA_RUNNER_READY_POLL_MS);
   const deadline = now() + timeoutMs;
-  let markerDiagnosis = 'ready_marker_unavailable';
-  let readyMarkerObserved = false;
-  let startAcknowledgementAttempted = false;
+  let schedulerDiagnosis = 'no_readiness_response';
+  let schedulerReadinessResponses = 0;
+  let retryDelayMs = pollMs;
 
   while (now() < deadline) {
-    try {
-      const marker = await input.sandbox.fs.downloadFile(input.readyPath, 2);
-      const parsed = JSON.parse(marker.toString('utf-8')) as {
-        ready?: unknown;
-      };
-      if (parsed.ready === true) {
-        readyMarkerObserved = true;
-        startAcknowledgementAttempted = true;
-        try {
-          await input.sandbox.fs.uploadFile(
-            Buffer.from('{"start":true}', 'utf-8'),
-            input.startAckPath,
-          );
-          return;
-        } catch {
-          markerDiagnosis = 'start_ack_unavailable';
-        }
-      } else {
-        markerDiagnosis = 'ready_marker_invalid';
-      }
-    } catch {
-      markerDiagnosis = 'ready_marker_unavailable';
+    const read = await requestRunnerReadiness({
+      readiness: input.readiness,
+      baselineHeartbeatAt: input.baselineHeartbeatAt,
+      timeoutMs: Math.max(1, deadline - now()),
+    });
+    schedulerDiagnosis = read.diagnosis;
+    if (read.response) {
+      schedulerReadinessResponses += 1;
+      if (read.response.ready) return;
+      schedulerDiagnosis = 'runner_heartbeat_not_observed';
     }
-    await sleep(Math.min(pollMs, Math.max(1, deadline - now())));
+    if (read.timedOut) break;
+    await sleep(Math.min(retryDelayMs, Math.max(1, deadline - now())));
+    retryDelayMs = Math.min(1_000, retryDelayMs * 2);
   }
 
   const diagnostic = await inspectDetachedDaytonaStartup({
@@ -224,12 +331,12 @@ export async function confirmDetachedDaytonaRunnerReady(input: {
     cmdId: input.cmdId,
     exitCodePath: input.exitCodePath,
   });
-  diagnostic.readyMarkerObserved = readyMarkerObserved;
-  diagnostic.startAcknowledgementAttempted = startAcknowledgementAttempted;
+  diagnostic.schedulerReadinessObserved = false;
+  diagnostic.schedulerReadinessResponses = schedulerReadinessResponses;
   const oomIndicated =
     diagnostic.exitCode === 137 || diagnostic.exitCodeFile === 137;
   throw new DaytonaRunnerInitializationError(
-    `RUNTIME_SANDBOX_START_FAILED: Daytona accepted detached command ${input.cmdId} in sandbox ${input.sandbox.id}, but the play runner did not materialize and establish receipt-gateway liveness within ${timeoutMs}ms. Marker diagnosis: ${markerDiagnosis}. Daytona diagnosis: ${JSON.stringify(diagnostic)}. OOM is ${oomIndicated ? 'indicated by exit code 137' : 'not confirmed by the available Daytona evidence'}. The worker will not park this runner; the failed runner was stopped and was not retried in place.`,
+    `RUNTIME_SANDBOX_START_FAILED: Daytona accepted detached command ${input.cmdId} in sandbox ${input.sandbox.id}, but the scheduler did not observe play-runner liveness within ${timeoutMs}ms. Scheduler diagnosis: ${schedulerDiagnosis}. Daytona diagnosis: ${JSON.stringify(diagnostic)}. OOM is ${oomIndicated ? 'indicated by exit code 137' : 'not confirmed by the available Daytona evidence'}. The worker will not park this runner; the failed runner was stopped and was not retried in place.`,
     diagnostic,
   );
 }

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

@@ -34,9 +34,11 @@ import {
 } from './daytona-lifecycle';
 import { stageDaytonaRunnerPayload } from './daytona-payload-transport';
 import {
+  captureDetachedDaytonaRunnerReadinessBaseline,
   confirmDetachedDaytonaRunnerReady,
+  createDetachedDaytonaSession,
   DaytonaRunnerInitializationError,
-  startDetachedDaytonaCommand,
+  executeDetachedDaytonaSessionCommand,
 } from './daytona-session-execution';
 
 const DAYTONA_EXECUTE_TIMEOUT_SECONDS = STANDARD_PLAY_RUNTIME_LIMIT_SECONDS;
@@ -45,7 +47,6 @@ const DAYTONA_DETACHED_CEILING_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_COMMAND_RECOVERY_TIMEOUT_MS = 60_000;
 const DAYTONA_COMMAND_RECOVERY_POLL_MS = 2_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;
@@ -56,15 +57,8 @@ const RUNTIME_RECEIPT_GATEWAY_TRANSPORT_RETRY_PATTERN =
   /AppRuntimeApiTransportError: App runtime API transport exhausted action=(?:get|claim|mark|complete|fail|heartbeat|release|skip)_runtime_step_receipts?/i;
 const RUNTIME_API_TRANSPORT_RETRY_PATTERN =
   /\bRuntime API request to .+ failed before receiving a response:\s*(?:fetch failed|connection (?:terminated|timed out|closed|reset)|ECONNRESET|ETIMEDOUT|ECONNREFUSED)\b/i;
-// The ready fence precedes customer play execution. A failed detached start is
-// safe to retry only when the runner never wrote its ready marker or attempted
-// the start acknowledgement, and Daytona has no exit evidence. This covers a
-// transient Daytona control-plane blind spot where the accepted command cannot
-// be inspected, while keeping post-start and crash failures terminal.
-const RUNTIME_SANDBOX_UNSTARTED_RETRY_PATTERN =
-  /DaytonaRunnerInitializationError:\s*RUNTIME_SANDBOX_START_FAILED[\s\S]*Marker diagnosis:\s*ready_marker_unavailable[\s\S]*"readyMarkerObserved"\s*:\s*false[\s\S]*"startAcknowledgementAttempted"\s*:\s*false[\s\S]*"exitCode"\s*:\s*null[\s\S]*"exitCodeFile"\s*:\s*null/i;
 const DAYTONA_INFRASTRUCTURE_RETRY_PATTERN =
-  /\b(?:Request failed with status code (?:408|429|500|502|503|504)|ECONNRESET|ECONNREFUSED|ETIMEDOUT|UND_ERR_CONNECT_TIMEOUT|fetch failed|socket hang up|Daytona sandbox create failed across|Daytona sandbox create did not complete)\b/i;
+  /\b(?:Request failed with status code (?:408|429|500|502|503|504)|ECONNRESET|ECONNREFUSED|ETIMEDOUT|UND_ERR_CONNECT_TIMEOUT|fetch failed|socket hang up|Daytona sandbox create failed across|Daytona sandbox create did not complete|Daytona readiness baseline)\b/i;
 
 type DaytonaExecution = { exitCode: number | null; result: string };
 type DaytonaLookupFailure = {
@@ -468,7 +462,6 @@ export function retryableRuntimeInitializationFailureReason(
   | 'runtime_postgres_connect'
   | 'runtime_api_transport'
   | 'runtime_receipt_gateway_transport'
-  | 'runtime_sandbox_unstarted'
   | null {
   if (result.status !== 'failed') return null;
   if (RUNTIME_POSTGRES_CONNECT_RETRY_PATTERN.test(result.error)) {
@@ -478,13 +471,6 @@ export function retryableRuntimeInitializationFailureReason(
     return 'runtime_receipt_gateway_transport';
   }
   const rowsProcessed = Number(result.stats?.rowsProcessed ?? 0);
-  if (
-    rowsProcessed === 0 &&
-    result.steps.length === 0 &&
-    RUNTIME_SANDBOX_UNSTARTED_RETRY_PATTERN.test(result.error)
-  ) {
-    return 'runtime_sandbox_unstarted';
-  }
   if (
     rowsProcessed === 0 &&
     result.steps.length === 0 &&
@@ -504,27 +490,6 @@ function isRetryableDaytonaInfrastructureFailure(error: unknown): boolean {
   return DAYTONA_INFRASTRUCTURE_RETRY_PATTERN.test(message);
 }
 
-function isRetryableUnstartedDaytonaRunner(
-  error: unknown,
-): error is DaytonaRunnerInitializationError {
-  if (!(error instanceof DaytonaRunnerInitializationError)) return false;
-  const diagnostic = error.startupDiagnostic;
-  // The ready fence runs before any customer play code. If Daytona accepted
-  // the command but the worker never observed its ready marker, the runner
-  // cannot pass the reverse start-ack fence and customer code cannot begin.
-  // Terminate that sandbox and retry once on a fresh one even when its Node
-  // process is still alive. Do not retry after a start acknowledgement was
-  // attempted (its write outcome may be ambiguous), or after a runner exit.
-  return (
-    diagnostic.commandFound &&
-    diagnostic.sessionFound &&
-    diagnostic.exitCode === null &&
-    diagnostic.exitCodeFile === null &&
-    !diagnostic.readyMarkerObserved &&
-    !diagnostic.startAcknowledgementAttempted
-  );
-}
-
 function prepareDaytonaExecution(
   input: PlayRunnerPrepareInput,
   callbacks: Parameters<PlayRunnerBackend['execute']>[1],
@@ -588,6 +553,22 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
         tableNamespace: null,
       };
     }
+    const readRunnerReadiness = callbacks?.readDetachedRunnerReadiness;
+    if (!readRunnerReadiness) {
+      if (isDaytonaPreparedExecution(prepared)) {
+        await prepared.dispose?.();
+      }
+      return {
+        status: 'failed',
+        error:
+          'Daytona runner backend requires the scheduler-owned detached-runner readiness port.',
+        logs: [],
+        stats: {},
+        steps: [],
+        checkpoint: config.checkpoint ?? null,
+        tableNamespace: null,
+      };
+    }
     let preparedExecution: DaytonaPreparedExecution;
     try {
       preparedExecution = isDaytonaPreparedExecution(prepared)
@@ -720,11 +701,7 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
     try {
       for (
         let executionAttempt = 1;
-        executionAttempt <=
-        Math.max(
-          DAYTONA_RUNTIME_INITIALIZATION_MAX_ATTEMPTS,
-          DAYTONA_INFRASTRUCTURE_MAX_ATTEMPTS,
-        );
+        executionAttempt <= DAYTONA_INFRASTRUCTURE_MAX_ATTEMPTS;
         executionAttempt += 1
       ) {
         let sandboxForAttempt: DaytonaSandbox | null = null;
@@ -757,6 +734,24 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
             workDir,
           });
 
+          // Session allocation is independent of payload staging. Start it
+          // now so Daytona control-plane latency overlaps compression/upload.
+          const sessionId = `deepline-play-${randomUUID()}`;
+          const sessionCreation = createDetachedDaytonaSession({
+            sandbox,
+            sessionId,
+          }).then(
+            () => ({ ok: true as const }),
+            (error: unknown) => ({ ok: false as const, error }),
+          );
+          const readinessBaseline =
+            captureDetachedDaytonaRunnerReadinessBaseline({
+              readiness: readRunnerReadiness,
+            }).then(
+              (heartbeatAt) => ({ ok: true as const, heartbeatAt }),
+              (error: unknown) => ({ ok: false as const, error }),
+            );
+
           const uploadStartedAt = Date.now();
           let uploadDeadlineTimer: ReturnType<typeof setTimeout> | null = null;
           const uploadDeadlinePromise = new Promise<never>(
@@ -840,16 +835,26 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
           });
           // Push execution (B2-final, park-and-wake): start the runner command
           // DETACHED via a Daytona session and return a `detached_runner`
-          // suspension only after the runner writes its one-time ready marker.
-          // The marker proves artifact materialization and an accepted gateway
-          // heartbeat: a Daytona cmdId alone does not prove durable liveness.
+          // suspension only after the scheduler observes the runner's durable
+          // gateway heartbeat. A Daytona cmdId alone does not prove liveness.
           // After that bounded startup check, the worker parks (releasing its
           // claim and slot) and wakes on terminal push or the ceiling timeout.
-          const sessionId = `deepline-play-${randomUUID()}`;
-          let start: Awaited<ReturnType<typeof startDetachedDaytonaCommand>>;
+          const session = await Promise.race([
+            sessionCreation,
+            cancellationPromise,
+          ]);
+          if (session.ok === false) throw session.error;
+          const baseline = await Promise.race([
+            readinessBaseline,
+            cancellationPromise,
+          ]);
+          if (baseline.ok === false) throw baseline.error;
+          let start: Awaited<
+            ReturnType<typeof executeDetachedDaytonaSessionCommand>
+          >;
           try {
             start = await Promise.race([
-              startDetachedDaytonaCommand({
+              executeDetachedDaytonaSessionCommand({
                 sandbox,
                 sessionId,
                 command: stagedPayload.command,
@@ -873,9 +878,9 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
               sandbox,
               sessionId: start.sessionId,
               cmdId: start.cmdId,
-              readyPath: stagedPayload.readyPath,
-              startAckPath: stagedPayload.startAckPath,
               exitCodePath: stagedPayload.exitCodePath,
+              readiness: readRunnerReadiness,
+              baselineHeartbeatAt: baseline.heartbeatAt,
             }),
             cancellationPromise,
           ]);
@@ -925,25 +930,6 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
             onCancel();
             throw new Error(DAYTONA_CANCELLED_ERROR);
           }
-          if (
-            executionAttempt < DAYTONA_RUNTIME_INITIALIZATION_MAX_ATTEMPTS &&
-            isRetryableUnstartedDaytonaRunner(error)
-          ) {
-            emitDaytonaStage(callbacks, config.context, 'execute:retry', {
-              sandboxId: sandboxForAttempt?.id ?? null,
-              attempt: executionAttempt + 1,
-              reason: 'runner_startup_not_live',
-              error: error.message,
-              elapsedMs: Date.now() - startedAt,
-            });
-            if (sandboxForAttempt) {
-              activeAcquiredResource!.billingEndedAt = Date.now();
-              await reportRetiringRuntimeResource(activeAcquiredResource!);
-              sandboxCleanup.stashActiveSandboxForRetry();
-            }
-            acquiredSandboxPromise = sandboxLifecycle.createFreshSandbox();
-            continue;
-          }
           if (
             executionAttempt < DAYTONA_INFRASTRUCTURE_MAX_ATTEMPTS &&
             isRetryableDaytonaInfrastructureFailure(error)

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

@@ -46,6 +46,14 @@ export interface PlayRunnerCallbacks {
   onRuntimeResourceAcquired?: (
     resource: PlayRunnerRuntimeResource,
   ) => void | Promise<void>;
+  /**
+   * Scheduler-owned readiness read for a detached runner attempt. Daytona uses
+   * this direct control-plane port before parking; it is never serialized into
+   * the sandbox or routed through the runtime gateway.
+   */
+  readDetachedRunnerReadiness?: (
+    baselineHeartbeatAt?: string | null,
+  ) => Promise<{ ready: boolean; heartbeatAt: string | null } | null>;
   cancellationSignal?: AbortSignal;
 }