deepline 0.3.88 → 0.3.90

package/dist/bundling-sources/shared_libs/play-runtime/receipt-status.ts

@@ -1,13 +1,10 @@
 import type { WorkReceiptStatus } from './work-receipts';
+import { WORK_RECEIPT_STATUS_CODE } from './work-receipt-storage-contract';
 
-export const RECEIPT_STATUS_CODE = {
-  queued: 0,
-  pending: 0,
-  running: 1,
-  completed: 2,
-  failed: 3,
-  skipped: 4,
-} as const satisfies Record<WorkReceiptStatus, number>;
+export const RECEIPT_STATUS_CODE = WORK_RECEIPT_STATUS_CODE satisfies Record<
+  WorkReceiptStatus,
+  number
+>;
 
 export type ReceiptStatusCode =
   (typeof RECEIPT_STATUS_CODE)[keyof typeof RECEIPT_STATUS_CODE];

package/dist/bundling-sources/shared_libs/play-runtime/run-failure.ts

@@ -63,10 +63,10 @@ export const WORKSPACE_STORAGE_NOT_READY_CODE = 'WORKSPACE_STORAGE_NOT_READY';
 // postgres-URI passwords). The raw pg error goes in the Error `cause` for server
 // logs only, never into this message or the normalized public failure.
 export const WORKSPACE_STORAGE_NOT_READY_MESSAGE =
-  'Workspace storage for this organization is unavailable, so this operation could not start. ' +
+  'Deepline could not prepare your workspace storage in time, so this operation did not start. ' +
+  'Try again in a few moments. You do not need to run a database command. ' +
   'This blocked operation did not use Deepline credits. ' +
   'Earlier completed operations in the same run may already have used credits. ' +
-  'Re-run the command. If it fails again, ask an organization admin to run `deepline db repair` (POST /api/v2/ingestion/repair), then re-run. ' +
   'If this keeps happening, contact Deepline support with the run ID.';
 
 export class WorkspaceStorageNotReadyError extends Error {
@@ -170,6 +170,27 @@ export class ProviderExhaustedError extends Error {
   }
 }
 
+/**
+ * `ProviderExhaustedError` is created inside the runtime, but a tool execution
+ * can cross the execution gateway before a step program sees it. The gateway
+ * deliberately serializes that error as the public, provider-owned
+ * `ToolExecutionError` shape. Treat those two representations as the same
+ * typed exhaustion outcome; do not fall back based on a message substring.
+ */
+export function isProviderExhaustedFailure(error: unknown): error is
+  | ProviderExhaustedError
+  | (ToolExecutionError & {
+      readonly origin: 'provider';
+      readonly code: typeof PROVIDER_EXHAUSTED_CODE;
+    }) {
+  return (
+    error instanceof ProviderExhaustedError ||
+    (error instanceof ToolExecutionError &&
+      error.origin === 'provider' &&
+      error.code === PROVIDER_EXHAUSTED_CODE)
+  );
+}
+
 /**
  * Derive the human provider name for a PROVIDER_EXHAUSTED error from a pacing
  * bucketId. Bucket ids are `${orgId}:${provider}`; the provider itself is

package/dist/bundling-sources/shared_libs/play-runtime/run-identity.ts

@@ -0,0 +1,168 @@
+import { sha256Hex, stableStringify } from '../plays/row-identity';
+function sanitizePlayNameForWorkflowSegment(value: string): string {
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 64);
+}
+
+export function buildPlayWorkflowFamilyKey(playName: string): string {
+  const normalized = playName
+    .split('/')
+    .map(sanitizePlayNameForWorkflowSegment)
+    .filter(Boolean)
+    .join('/');
+  return normalized || 'play';
+}
+
+export function buildPlayWorkflowRunSuffix(now: Date): string {
+  const pad = (value: number, size = 2) => String(value).padStart(size, '0');
+  return [
+    now.getUTCFullYear(),
+    pad(now.getUTCMonth() + 1),
+    pad(now.getUTCDate()),
+    't',
+    pad(now.getUTCHours()),
+    pad(now.getUTCMinutes()),
+    pad(now.getUTCSeconds()),
+    '-',
+    pad(now.getUTCMilliseconds(), 3),
+  ].join('');
+}
+
+const CANONICAL_PLAY_RUN_TIMESTAMP_RE =
+  /\/run\/(\d{4})(\d{2})(\d{2})t(\d{2})(\d{2})(\d{2})-(\d{3})(?:-|$)/;
+
+/** Read the UTC creation time embedded in a canonical root play-run id. */
+export function canonicalPlayRunStartedAtMs(runId: string): number | null {
+  const match = CANONICAL_PLAY_RUN_TIMESTAMP_RE.exec(runId);
+  if (!match) return null;
+  const [, year, month, day, hour, minute, second, millisecond] = match;
+  const value = Date.UTC(
+    Number(year),
+    Number(month) - 1,
+    Number(day),
+    Number(hour),
+    Number(minute),
+    Number(second),
+    Number(millisecond),
+  );
+  if (!Number.isFinite(value)) return null;
+  const roundTrip = new Date(value);
+  return roundTrip.getUTCFullYear() === Number(year) &&
+    roundTrip.getUTCMonth() === Number(month) - 1 &&
+    roundTrip.getUTCDate() === Number(day) &&
+    roundTrip.getUTCHours() === Number(hour) &&
+    roundTrip.getUTCMinutes() === Number(minute) &&
+    roundTrip.getUTCSeconds() === Number(second) &&
+    roundTrip.getUTCMilliseconds() === Number(millisecond)
+    ? value
+    : null;
+}
+
+type BuildPlayWorkflowIdOptions = {
+  /**
+   * Add entropy for new run creation. Keep false for tests and explicit
+   * externally-owned ids that need deterministic reconstruction.
+   */
+  unique?: boolean;
+};
+
+function buildRunEntropySuffix(): string {
+  const randomUuid = globalThis.crypto?.randomUUID?.();
+  if (randomUuid) {
+    return randomUuid.replace(/-/g, '').slice(0, 8);
+  }
+  return Math.random().toString(36).slice(2, 10).padEnd(8, '0');
+}
+
+export function buildPlayWorkflowId(
+  playName: string,
+  now?: Date,
+  options: BuildPlayWorkflowIdOptions = {},
+): string {
+  const familyKey = buildPlayWorkflowFamilyKey(playName);
+  const timestamp = now ?? new Date();
+  const unique = options.unique ?? now === undefined;
+  const entropy = unique ? `-${buildRunEntropySuffix()}` : '';
+  return `play/${familyKey}/run/${buildPlayWorkflowRunSuffix(timestamp)}${entropy}`;
+}
+
+export type PlayRunIdentity = {
+  workflowId: string;
+  runId: string;
+  workflowFamilyKey: string;
+};
+
+/**
+ * Convex and runtime schedulers share one run identity contract.
+ *
+ * - `workflowId` is the unique execution id.
+ * - `runId` is the same execution id surfaced in dashboard/API state.
+ * - `workflowFamilyKey` is the stable play-name-derived family/group key.
+ *
+ * Keeping these three values explicit removes the old ambiguity where one field
+ * pretended to mean both "this specific run" and "this play family".
+ */
+export function buildPlayRunIdentity(
+  playName: string,
+  now?: Date,
+  options: BuildPlayWorkflowIdOptions = {},
+): PlayRunIdentity {
+  const workflowId = buildPlayWorkflowId(playName, now, {
+    unique: options.unique ?? now === undefined,
+  });
+  return {
+    workflowId,
+    runId: workflowId,
+    workflowFamilyKey: buildPlayWorkflowFamilyKey(playName),
+  };
+}
+
+/**
+ * Build the replay-stable identity for one ctx.runPlayAsync invocation.
+ *
+ * The parent's embedded timestamp keeps ordinary run ordering useful while
+ * the digest makes retries converge on exactly one independently scheduled
+ * child. Input is deliberately excluded: a changed request must conflict with
+ * the first immutable launch rather than silently minting another Run.
+ */
+export function buildAsyncPlayRunIdentity(input: {
+  playName: string;
+  parentRunId: string;
+  invocationKey: string;
+}): PlayRunIdentity {
+  const digest = sha256Hex(
+    `${input.parentRunId}\0${input.invocationKey}`,
+  ).slice(0, 20);
+  const parentStartedAt = canonicalPlayRunStartedAtMs(input.parentRunId) ?? 0;
+  // The run id is the durable identity of the authored invocation, so it must
+  // be reconstructible before resolving a mutable live Play reference. The
+  // workflow family remains the resolved child Play for grouping and display.
+  const base = buildPlayWorkflowId('async-child', new Date(parentStartedAt), {
+    unique: false,
+  });
+  const workflowId = `${base}-async-${digest}`;
+  return {
+    workflowId,
+    runId: workflowId,
+    workflowFamilyKey: buildPlayWorkflowFamilyKey(input.playName),
+  };
+}
+
+/** Immutable authored request identity, separate from the resolved revision. */
+export function buildAsyncPlayRequestFingerprint(input: {
+  key: string;
+  playRef: string;
+  childInput: Record<string, unknown>;
+}): string {
+  return sha256Hex(
+    stableStringify({
+      key: input.key,
+      playRef: input.playRef,
+      input: input.childInput,
+    }),
+  );
+}

package/dist/bundling-sources/shared_libs/play-runtime/run-snapshot-stream.ts

@@ -130,7 +130,7 @@ export function isActivePlayRunStatus(status: unknown): boolean {
  * The minimal persisted Play Run document shape required to project the live
  * snapshot. This is a structural subset of the Convex `playRuns` doc and of
  * the run-observer projection returned by
- * `convex/runObservers.getPlayRunSnapshotForObserver`.
+ * `packages/convex/runObservers.getPlayRunSnapshotForObserver`.
  */
 export type LedgerBackedRunLike = {
   workflowId: string;

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

@@ -11,8 +11,15 @@ import {
 } from '../../../plays/sandbox-runtime-limits';
 import type { PlayRunnerRuntimeLifecycleEvent } from '../types';
 import { DAYTONA_PLAY_RUNNER_LABEL_SOURCE } from './daytona-labels';
-
-const DAYTONA_CREATE_TIMEOUT_SECONDS = 10;
+import type { DaytonaSandboxStartAdmission } from './daytona-start-admission';
+
+// Match Daytona's supported default create window. Ten seconds is shorter
+// than normal provider startup under burst load: the SDK abandons an otherwise
+// healthy create, and the resulting provider-side transition cannot safely be
+// deleted or hedged with a second sandbox. The runner deadline still bounds
+// the full lifecycle, while ambiguous creates retain the fail-closed cleanup
+// path below.
+const DAYTONA_CREATE_TIMEOUT_SECONDS = 60;
 const DAYTONA_CREATE_RETRY_DELAYS_MS = [0, 500, 1_500] as const;
 const DAYTONA_TIMED_OUT_CREATE_RECONCILE_DELAYS_MS = [
   0, 1_000, 3_000, 6_000, 12_000, 24_000, 36_000,
@@ -85,6 +92,20 @@ export class DaytonaSandboxAcquisitionUnavailableError extends Error {
   }
 }
 
+/**
+ * A named Daytona create is still changing state after the client deadline.
+ * The scheduler must defer and resume this exact identity; falling back or
+ * creating another sandbox could execute the Play twice.
+ */
+export class DaytonaSandboxTransitionPendingError extends Error {
+  constructor(readonly sandboxName: string) {
+    super(
+      `Daytona sandbox ${sandboxName} is still transitioning after create timed out.`,
+    );
+    this.name = 'DaytonaSandboxTransitionPendingError';
+  }
+}
+
 export function resolveDaytonaSandboxAcquisitionUnavailableReason(
   errors: readonly string[],
 ): DaytonaSandboxAcquisitionUnavailableReason | null {
@@ -105,7 +126,7 @@ export function resolveDaytonaSandboxAcquisitionUnavailableReason(
 }
 
 function isDaytonaSandboxStartTimeout(error: string): boolean {
-  return /Failed to create and start sandbox within 10 seconds\. Operation timed out\./.test(
+  return /Failed to create and start sandbox within \d+ seconds\. Operation timed out\./.test(
     error,
   );
 }
@@ -319,7 +340,8 @@ async function createOneShotDaytonaSandbox(input: {
 type TimedOutDaytonaSandboxReconciliation =
   | { kind: 'started'; sandbox: DaytonaSandbox }
   | { kind: 'deleted' }
-  | { kind: 'not_found' };
+  | { kind: 'not_found' }
+  | { kind: 'transition_pending' };
 
 async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
   daytona: DaytonaClient;
@@ -369,23 +391,28 @@ async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
     return { kind: 'deleted' };
   }
   if (lastDeleteConflict) {
-    throw new Error(
-      `Daytona timed-out sandbox ${input.sandboxName} remained in a state transition across the bounded cleanup window. Modal fallback suppressed.`,
-      { cause: lastDeleteConflict },
-    );
+    return { kind: 'transition_pending' };
   }
   return { kind: 'not_found' };
 }
 
+function daytonaSandboxName(providerOperationToken?: string | null): string {
+  return providerOperationToken
+    ? `dl-${providerOperationToken}`
+    : `dl-${crypto.randomUUID()}`;
+}
+
 async function createRetriedOneShotDaytonaSandbox(input: {
   daytona: DaytonaClient;
   orgId: string;
   context: DaytonaExecutionContext;
   emitStage: DaytonaStageEmitter;
   observeCreateCall?: DaytonaCreateCallObserver;
-  reserveSandboxCapacity?: (
-    providerAttempt: number,
-  ) => Promise<{ leaseId: string; providerOperationToken: string | null }>;
+  reserveSandboxCapacity?: (providerAttempt: number) => Promise<{
+    leaseId: string;
+    providerOperationToken: string | null;
+    resumeExistingProviderOperation?: boolean;
+  }>;
   releaseSandboxCapacity?: (leaseId: string) => Promise<void>;
   nextProviderAttempt: () => number;
   startedAt: number;
@@ -393,7 +420,6 @@ async function createRetriedOneShotDaytonaSandbox(input: {
   const errors: string[] = [];
   for (const [index, delayMs] of DAYTONA_CREATE_RETRY_DELAYS_MS.entries()) {
     const attempt = input.nextProviderAttempt();
-    const sandboxName = `dl-${crypto.randomUUID()}`;
     if (delayMs > 0) {
       input.emitStage('create:retry', {
         attempt: index,
@@ -410,6 +436,40 @@ async function createRetriedOneShotDaytonaSandbox(input: {
       providerAttempt: attempt,
     });
     const reservation = await input.reserveSandboxCapacity?.(attempt);
+    const sandboxName = daytonaSandboxName(reservation?.providerOperationToken);
+    if (reservation?.resumeExistingProviderOperation) {
+      if (!input.daytona.get) {
+        throw new DaytonaSandboxTransitionPendingError(sandboxName);
+      }
+      try {
+        const sandbox = await input.daytona.get(sandboxName);
+        if (sandbox.state !== 'started') {
+          throw new DaytonaSandboxTransitionPendingError(sandboxName);
+        }
+        const acquiredAt = Date.now();
+        input.emitStage('create:resumed', {
+          attempt,
+          elapsedMs: acquiredAt - input.startedAt,
+          sandboxId: sandbox.id,
+        });
+        return {
+          sandbox,
+          attempt,
+          attemptElapsedMs: acquiredAt - attemptStartedAt,
+          sandboxCapacityLeaseId: reservation.leaseId,
+        };
+      } catch (error) {
+        if (error instanceof DaytonaSandboxTransitionPendingError) throw error;
+        if (!isDaytonaSandboxNotFound(error)) {
+          throw new DaytonaSandboxTransitionPendingError(sandboxName);
+        }
+        await input.releaseSandboxCapacity?.(reservation.leaseId);
+        throw new DaytonaSandboxAcquisitionUnavailableError(
+          'daytona_sandbox_start_timeout',
+          `Timed-out Daytona sandbox ${sandboxName} was confirmed absent before resume.`,
+        );
+      }
+    }
     let sandbox: DaytonaSandbox;
     try {
       sandbox = await createOneShotDaytonaSandbox({
@@ -489,6 +549,15 @@ async function createRetriedOneShotDaytonaSandbox(input: {
           };
         }
         await recordCreateFailure();
+        if (reconciliation.kind === 'transition_pending') {
+          if (reservation?.providerOperationToken) {
+            throw new DaytonaSandboxTransitionPendingError(sandboxName);
+          }
+          throw new Error(
+            `Daytona timed-out sandbox ${sandboxName} remained in a state transition across the bounded cleanup window. Modal fallback suppressed.`,
+            { cause: error },
+          );
+        }
         if (reconciliation.kind === 'deleted') {
           // The provider-confirmed reconciliation means this reservation can
           // no longer represent a live sandbox. Release before returning the
@@ -575,6 +644,7 @@ async function acquireOneShotDaytonaSandbox(input: {
   releaseSandboxCapacity?: (leaseId: string) => Promise<void>;
   nextProviderAttempt: () => number;
   startedAt: number;
+  startAdmission?: DaytonaSandboxStartAdmission;
 }): Promise<AcquiredDaytonaSandbox> {
   const limits = validatePlaySandboxRuntimeLimits(
     input.context.sandboxRuntimeLimits ?? {
@@ -582,7 +652,11 @@ async function acquireOneShotDaytonaSandbox(input: {
     },
   );
   input.emitStage('create:start');
-  const result = await createRetriedOneShotDaytonaSandbox(input);
+  const result = input.startAdmission
+    ? await input.startAdmission.run(() =>
+        createRetriedOneShotDaytonaSandbox(input),
+      )
+    : await createRetriedOneShotDaytonaSandbox(input);
   const granted = {
     cpu: result.sandbox.cpu,
     memoryGiB: result.sandbox.memory,
@@ -681,8 +755,10 @@ export function createOneShotDaytonaSandboxLifecycle(input: {
   reserveSandboxCapacity?: (providerAttempt: number) => Promise<{
     leaseId: string;
     providerOperationToken: string | null;
+    resumeExistingProviderOperation?: boolean;
   }>;
   releaseSandboxCapacity?: (leaseId: string) => Promise<void>;
+  startAdmission?: DaytonaSandboxStartAdmission;
   startedAt?: number;
 }): OneShotDaytonaSandboxLifecycle {
   const orgId = validateDaytonaExecutionContext(input.context);
@@ -700,6 +776,7 @@ export function createOneShotDaytonaSandboxLifecycle(input: {
       observeCreateCall: input.observeCreateCall,
       reserveSandboxCapacity: input.reserveSandboxCapacity,
       releaseSandboxCapacity: input.releaseSandboxCapacity,
+      startAdmission: input.startAdmission,
       nextProviderAttempt: () => {
         providerAttempt += 1;
         return providerAttempt;

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

@@ -26,6 +26,11 @@ import {
   RUNTIME_SANDBOX_KILLED_MESSAGE,
   RUNTIME_SANDBOX_OOM_MESSAGE,
 } from '../../run-failure';
+import {
+  buildDaytonaPayloadMaterializerSource,
+  type DaytonaPayloadEnvelope,
+} from '../../daytona-payload-contract';
+export { buildDaytonaPayloadMaterializerSource } from '../../daytona-payload-contract';
 import { compactPlayArtifactForRuntimeTransport } from '../../../plays/artifact-transport';
 import type {
   DaytonaExecutionContext,
@@ -36,16 +41,6 @@ import { buildDaytonaRuntimeWatchdogSource } from './daytona-runtime-watchdog';
 
 type DaytonaRemoteRuntimeContext = PlayRunnerExecutionConfig['context'];
 
-type DaytonaPayloadEnvelope = {
-  schemaVersion: 1;
-  runnerCode: string;
-  artifactBundledCode: string;
-  artifactSourceMap: string;
-  config: PlayRunnerExecutionConfig;
-  /** Crash-containment epilogue script (see buildDaytonaCrashTerminalPusherSource). */
-  crashPusherCode: string;
-};
-
 /**
  * The crash pusher must be able to recover one complete terminal event after
  * a runner exits before its primary gateway push. A stdout `result` event is
@@ -116,8 +111,7 @@ function nodeMaterializePayloadCommand(input: {
   artifactSourceMapPath: string;
   crashPusherPath: string;
 }): string {
-  const script =
-    "const fs=require('node:fs');const zlib=require('node:zlib');const p=JSON.parse(zlib.gunzipSync(fs.readFileSync(process.argv[1])));if(p.schemaVersion!==1)throw new Error('Unsupported Daytona payload envelope');fs.writeFileSync(process.argv[2],p.runnerCode);fs.writeFileSync(process.argv[3],JSON.stringify(p.config));fs.writeFileSync(process.argv[4],p.artifactBundledCode);fs.writeFileSync(process.argv[5],p.artifactSourceMap);fs.writeFileSync(process.argv[6],p.crashPusherCode);";
+  const script = buildDaytonaPayloadMaterializerSource();
   return [
     'node',
     '-e',

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

@@ -0,0 +1,68 @@
+import { RUNTIME_CAPACITY_POLICY } from '../../runtime-capacity-policy';
+
+export type DaytonaSandboxStartAdmission = {
+  run<T>(operation: () => Promise<T>): Promise<T>;
+};
+
+/**
+ * Daytona sandbox starts are control-plane transitions, not execution work.
+ * Keep their admission independent from Absurd worker slots so a run burst can
+ * still multiplex started sandboxes without stampeding the provider's create
+ * transition. A permit covers timeout reconciliation too: releasing it when
+ * `create` times out would admit another create while the first named sandbox
+ * is still transitioning, recreating the unsafe overlap this gate prevents.
+ */
+export function createDaytonaSandboxStartAdmission(
+  concurrency =
+    RUNTIME_CAPACITY_POLICY.sandboxAcquisition
+      .daytonaConcurrentStartsPerProcess,
+): DaytonaSandboxStartAdmission {
+  if (!Number.isInteger(concurrency) || concurrency <= 0) {
+    throw new Error(
+      'Daytona sandbox-start concurrency must be a positive integer.',
+    );
+  }
+
+  let active = 0;
+  const waiters: Array<(release: () => void) => void> = [];
+
+  const createRelease = (): (() => void) => {
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      const next = waiters.shift();
+      if (next) {
+        // Transfer the occupied permit directly. Keeping `active` unchanged
+        // prevents a new eager caller from jumping ahead of the FIFO waiter.
+        next(createRelease());
+        return;
+      }
+      active -= 1;
+    };
+  };
+
+  return {
+    async run<T>(operation: () => Promise<T>): Promise<T> {
+      // Preserve eager prepare semantics when capacity is free: the provider
+      // create begins in this turn, just as it did before admission existed.
+      // Only contended callers cross an asynchronous queue boundary.
+      const release =
+        active < concurrency
+          ? (() => {
+              active += 1;
+              return createRelease();
+            })()
+          : await new Promise<() => void>((resolve) => waiters.push(resolve));
+      try {
+        return await operation();
+      } finally {
+        release();
+      }
+    },
+  };
+}
+
+/** One admission queue per worker process; all run slots share it. */
+export const daytonaSandboxStartAdmission =
+  createDaytonaSandboxStartAdmission();

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

@@ -28,6 +28,7 @@ import {
 import {
   DAYTONA_CANCELLED_ERROR,
   DaytonaSandboxAcquisitionUnavailableError,
+  DaytonaSandboxTransitionPendingError,
   createDaytonaSandboxCleanupManager,
   createOneShotDaytonaSandboxLifecycle,
   type AcquiredDaytonaSandbox,
@@ -37,12 +38,14 @@ import {
   type OneShotDaytonaSandboxLifecycle,
   validateDaytonaExecutionContext,
 } from './daytona-lifecycle';
+import { recoveryForDaytonaSandboxTransitionPending } from '../../play-run-recovery-policy';
 import { stageDaytonaRunnerPayload } from './daytona-payload-transport';
 import {
   DaytonaRunnerInitializationError,
   prepareDetachedDaytonaRunner,
 } from './daytona-session-execution';
 import { RUNTIME_RELIABILITY_POLICY } from '../../runtime-reliability-policy';
+import { daytonaSandboxStartAdmission } from './daytona-start-admission';
 
 const DAYTONA_COMMAND_RECOVERY_TIMEOUT_MS =
   RUNTIME_RELIABILITY_POLICY.sandbox.daytonaCommandRecoveryTimeoutMs;
@@ -68,6 +71,12 @@ const RUNTIME_API_TRANSPORT_RETRY_PATTERN =
 // with user code that has already had side effects.
 const DAYTONA_PUBLIC_STATUS_TRANSIENT_RETRY_PATTERN =
   /\bDaytonaValidationError:\s*bad request:\s*failed to get sandbox public status:\s*an unexpected error occurred\.?\b/i;
+// A detached runner sends its first authenticated heartbeat before it can run
+// customer code.  Persisted terminal results retain the bounded startup
+// diagnostic, so the worker can distinguish that proven pre-code transport
+// failure from a generic readiness timeout on a later wake.
+const DAYTONA_RUNNER_STARTUP_TRANSPORT_RETRY_PATTERN =
+  /\bDaytonaRunnerInitializationError:\s*RUNTIME_SANDBOX_START_FAILED:.*\bScheduler diagnosis:\s*runner_heartbeat_not_observed\..*"schedulerReadinessObserved":false.*"commandFound":true.*"exitCode":null.*"sessionFound":true.*"exitCodeFile":null.*"runnerStartup":\{"phase":"heartbeat_transport","outcome":"network_error","errorCode":"(?:ECONNRESET|ECONNREFUSED|ETIMEDOUT|UND_ERR_CONNECT_TIMEOUT)"/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|Daytona readiness baseline)\b/i;
 
@@ -901,6 +910,7 @@ export function retryableRuntimeInitializationFailureReason(
   | 'runtime_api_transport'
   | 'runtime_receipt_gateway_transport'
   | 'daytona_public_status'
+  | 'daytona_runner_startup_transport'
   | null {
   if (result.status !== 'failed') return null;
   if (RUNTIME_POSTGRES_CONNECT_RETRY_PATTERN.test(result.error)) {
@@ -910,6 +920,13 @@ export function retryableRuntimeInitializationFailureReason(
     return 'runtime_receipt_gateway_transport';
   }
   const rowsProcessed = Number(result.stats?.rowsProcessed ?? 0);
+  if (
+    rowsProcessed === 0 &&
+    result.steps.length === 0 &&
+    DAYTONA_RUNNER_STARTUP_TRANSPORT_RETRY_PATTERN.test(result.error)
+  ) {
+    return 'daytona_runner_startup_transport';
+  }
   if (
     rowsProcessed === 0 &&
     result.steps.length === 0 &&
@@ -973,6 +990,7 @@ function prepareDaytonaExecution(
           callbacks.reserveSandboxCapacity!('daytona', providerAttempt)
       : undefined,
     releaseSandboxCapacity: callbacks?.releaseSandboxCapacity,
+    startAdmission: daytonaSandboxStartAdmission,
   });
   return {
     kind: 'daytona',
@@ -1468,6 +1486,9 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
       if (error instanceof SandboxRunnerPreCodeDeferralError) {
         throw error;
       }
+      if (error instanceof DaytonaSandboxTransitionPendingError) {
+        throw recoveryForDaytonaSandboxTransitionPending(error);
+      }
       if (error instanceof DaytonaSandboxAcquisitionUnavailableError) {
         throw error;
       }

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

@@ -206,7 +206,6 @@ export async function buildPlayRunnerBundle(): Promise<string> {
         resolve(process.cwd(), 'packages', 'play-runtime'),
         resolve(process.cwd(), 'packages', 'plays'),
         resolve(process.cwd(), 'packages', 'security'),
-        resolve(process.cwd(), 'shared_libs'),
       ];
       const sourceHash = await hashRunnerSources(sourceRoots);
       setSpanAttributes(span, {