deepline 0.3.476 → 0.3.478

package/dist/bundling-sources/sdk/src/client-core.ts

@@ -12,6 +12,7 @@ import type {
   PlaySettingsPatch,
   PlaySettingsPathsPage,
 } from '../../shared_libs/plays/settings-contract';
+import type { PlaySandboxRuntimeDeclaration } from '../../shared_libs/plays/sandbox-runtime-limits';
 import type {
   PlayTriggerConfigUpdate,
   PlayTriggerConfigUpdateResult,
@@ -2419,6 +2420,8 @@ export type BillingRecentUsageEntry = {
 export type BillingUsageOptions = {
   /** Return the one exact call identified by `executeTool().job_id`. */
   requestId?: string;
+  /** Return only the workspace identity and recent activity page. */
+  recentOnly?: boolean;
   /** Bound the recent-call page. Ignored for an exact requestId lookup. */
   limit?: number;
   offset?: number;
@@ -2555,10 +2558,7 @@ export type BillingNamespace = {
 
 export type BillingQuoteRequest = {
   quantity: number;
-  sandbox_runtime: {
-    timeout?: string;
-    size?: 'standard' | 'large' | 'xlarge';
-  };
+  sandbox_runtime: PlaySandboxRuntimeDeclaration;
 };
 
 export type BillingQuoteResult = {
@@ -6466,6 +6466,7 @@ export class DeeplineClient {
       }
       params.set('request_id', requestId);
     } else {
+      if (options.recentOnly) params.set('recent_only', 'true');
       if (options.limit !== undefined) {
         params.set('recent_limit', String(options.limit));
       }

package/dist/bundling-sources/sdk/src/http-core.ts

@@ -218,14 +218,95 @@ function mapNetworkError(
       code: 'NETWORK_ABORTED',
     };
   }
+  const causeCode = networkCauseCode(error);
   return {
-    message: error?.message
-      ? `Unable to connect to ${baseUrl}. ${error.message}`
-      : `Unable to connect to ${baseUrl}. Is the computer able to access the url?`,
+    message: connectionFailureMessage(baseUrl, error),
     code: 'NETWORK_ERROR',
+    ...(causeCode ? { details: { causeCode } } : {}),
   };
 }
 
+const BLOCKED_EGRESS_CAUSE_CODES = new Set([
+  'EPERM',
+  'EACCES',
+  'ENOTFOUND',
+  'EAI_AGAIN',
+  'ENETUNREACH',
+  'EHOSTUNREACH',
+  'ETIMEDOUT',
+  'UND_ERR_CONNECT_TIMEOUT',
+]);
+
+/**
+ * The first system error code in a transport failure's cause chain. Node's
+ * fetch reports only "fetch failed"; the reason (ENOTFOUND, ECONNREFUSED,
+ * EPERM, ...) is on `cause`, or on `errors` when every address was tried.
+ */
+export function networkCauseCode(error: unknown): string | undefined {
+  const seen = new Set<unknown>();
+  const queue: unknown[] = [error];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current || typeof current !== 'object' || seen.has(current)) continue;
+    seen.add(current);
+    const record = current as Record<string, unknown>;
+    if (
+      typeof record.code === 'string' &&
+      /^[A-Z][A-Z0-9_]+$/.test(record.code)
+    )
+      return record.code;
+    queue.push(record.cause);
+    if (Array.isArray(record.errors)) queue.push(...record.errors);
+  }
+  return undefined;
+}
+
+function isLoopbackHost(hostname: string): boolean {
+  return (
+    hostname === 'localhost' ||
+    hostname === '[::1]' ||
+    hostname.startsWith('127.') ||
+    hostname.endsWith('.localhost')
+  );
+}
+
+/**
+ * One line naming the host, the transport error, its underlying cause code,
+ * and — when the cause is how blocked egress presents — what to check.
+ */
+export function connectionFailureMessage(
+  baseUrl: string,
+  error: Error | null,
+): string {
+  if (!error?.message) {
+    return `Unable to connect to ${baseUrl}. Is the computer able to access the url?`;
+  }
+  const causeCode = networkCauseCode(error);
+  let hostname = '';
+  try {
+    hostname = new URL(baseUrl).hostname;
+  } catch {
+    // An unparseable base URL still reports the transport failure.
+  }
+  const blocked =
+    hostname !== '' &&
+    !isLoopbackHost(hostname) &&
+    causeCode !== undefined &&
+    (BLOCKED_EGRESS_CAUSE_CODES.has(causeCode) || causeCode === 'ECONNREFUSED');
+  // Without a code, the cause's own message is still more than "fetch failed".
+  const causeMessage =
+    error.cause instanceof Error ? error.cause.message.slice(0, 200) : '';
+  const cause = causeCode ?? causeMessage;
+  return [
+    `Unable to connect to ${baseUrl}. ${error.message}${cause && !error.message.includes(cause) ? ` (${cause})` : ''}.`,
+    ...(blocked
+      ? [
+          `A sandbox, firewall, or proxy may be blocking ${hostname}; allow outbound HTTPS to it and retry.`,
+        ]
+      : []),
+  ].join(' ');
+}
+
 function describeRequestTarget(path: string): string {
   const toolExecuteMatch = path.match(
     /^\/api\/v2\/integrations\/([^/?#]+)\/execute(?:[/?#]|$)/,

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

@@ -3,6 +3,8 @@ import { HttpClient as HttpClientCore } from './http-core';
 import { readSdkSkillsLocalVersion } from './skills-version';
 import type { ResolvedConfig } from './types';
 
+export { connectionFailureMessage, networkCauseCode } from './http-core';
+
 export class HttpClient extends HttpClientCore {
   constructor(config: ResolvedConfig) {
     super(config, readSdkSkillsLocalVersion);

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

@@ -185,8 +185,14 @@ export type PlayFetchResponse = PlayAuthoringFetchResponse;
  *   The changed row is delivered as the listener event's `after` in the play function's input.
  *
  * The default Play runtime is 30 minutes with the `standard` 1 GiB / 1 CPU
- * profile. Select `large` (4 GiB / 2 CPU) or `xlarge` (8 GiB / 4 CPU)
- * through `runtime.size` when a step needs more memory.
+ * profile. Set `runtime.size` to `standard` or `1gb` (1 GiB / 1 CPU),
+ * `large` or `4gb` (4 GiB / 2 CPU), or `xlarge` or `8gb` (8 GiB / 4 CPU).
+ * Each alias selects the same resource profile and compute price.
+ *
+ * ```ts
+ * export const config = { runtime: { size: '4gb' } };
+ * ```
+ *
  * Compute pricing follows the workspace plan; use `deepline billing quote`
  * for the session ceiling.
  * Set `runtime.timeout` for longer bounded runs; duration values are whole

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

@@ -205,7 +205,7 @@ export const SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: '0.3.476',
+  version: '0.3.478',
   updateSummary: {
     introducedIn: '0.3.90',
     summary:

package/dist/bundling-sources/shared_libs/observability/scheduled-jobs.json

@@ -255,6 +255,24 @@
     "failureAlert": "github_workflow_run",
     "domainReportRequired": true
   },
+  {
+    "id": "github.prebuilt-benchmarks",
+    "name": "Prebuilt benchmarks",
+    "scheduler": "github_actions",
+    "cadence": "0 14 * * 1",
+    "timezone": "UTC",
+    "source": ".github/workflows/prebuilt-benchmarks.yml",
+    "locator": "schedule:",
+    "owner": "evals",
+    "criticality": "reporting",
+    "purpose": "Run each prebuilt play on its fixed labeled sample in a disposable Production workspace with the published CLI and publish found, exact, recall, precision and settled credits.",
+    "successDefinition": "Every benchmark exports its rows, scores them, settles within its credit cap, and the summary uploads; the disposable workspace is deleted.",
+    "failureDefinition": "Workspace bootstrap, dataset load, a play run, export, scoring, a credit-cap overrun, or workspace deletion fails.",
+    "startGraceMs": 600000,
+    "runTimeoutMs": 7200000,
+    "failureAlert": "github_workflow_run",
+    "domainReportRequired": true
+  },
   {
     "id": "github.fly-pr-preview-cleanup",
     "name": "Reconcile Fly PR Preview Capacity",

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

@@ -2281,6 +2281,39 @@ export async function releaseRateStateViaAppRuntime(
   });
 }
 
+/** Persist the final success batch without acquiring another provider permit. */
+export async function flushRateStateFeedbackViaAppRuntime(
+  context: WorkerRuntimeApiContext,
+  input: PlayRunnerRateStateReleaseInput,
+  signal: AbortSignal,
+): Promise<void> {
+  const batch = input.concurrencyObservationBatch;
+  if (!batch)
+    throw new Error('Rate-state feedback is missing its batch identity.');
+  const result = await postAppRuntimeApi<{
+    acknowledgedObservationBatch?: typeof batch;
+  }>(
+    {
+      ...context,
+      connectionRetryBudgetMs: 0,
+      signal: context.signal
+        ? AbortSignal.any([context.signal, signal])
+        : signal,
+    },
+    { action: 'rate_state_release', ...input },
+  );
+  const acknowledged = result.acknowledgedObservationBatch;
+  if (
+    acknowledged?.observerId !== batch.observerId ||
+    acknowledged.laneId !== batch.laneId ||
+    acknowledged.sequence !== batch.sequence
+  ) {
+    throw new Error(
+      'Rate-state receiver did not acknowledge the success batch.',
+    );
+  }
+}
+
 export async function penalizeRateStateViaAppRuntime(
   context: WorkerRuntimeApiContext,
   input: PlayRunnerRateStatePenalizeInput,

package/dist/bundling-sources/shared_libs/play-runtime/context.ts

@@ -19656,11 +19656,19 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                 statusCode: 504,
               },
             ));
+          // The gateway admits a recovery key only under the executor token's
+          // run, which is the root run even inside an inline child. Root runs
+          // keep their original key (executor run == logical run); an inline
+          // child keeps its own logical identity inside the invocation key.
+          const asyncRecoveryScope = this.currentExecutionScope;
           const asyncRecoveryKey = (attempt: number) =>
             asyncRecoveryInvocationKey
               ? buildRuntimeExecutionRecoveryKey({
-                  parentRunId: this.currentRunId,
-                  invocationKey: `${asyncRecoveryInvocationKey}:attempt:${attempt}`,
+                  parentRunId: asyncRecoveryScope.placement.executorRunId,
+                  invocationKey:
+                    asyncRecoveryScope.placement.kind === 'inline_child'
+                      ? `${asyncRecoveryInvocationKey}:inline-child:${asyncRecoveryScope.logical.runId}:attempt:${attempt}`
+                      : `${asyncRecoveryInvocationKey}:attempt:${attempt}`,
                 })
               : null;
           // This is deliberately a claim about only the immediately preceding

package/dist/bundling-sources/shared_libs/play-runtime/governor/app-runtime-rate-state-backend.ts

@@ -2,6 +2,7 @@ import {
   acquireRateStateViaAppRuntime,
   AppRuntimeApiTransportError,
   capacityShedRetryAfterMs,
+  flushRateStateFeedbackViaAppRuntime,
   penalizeRateStateViaAppRuntime,
   releaseRateStateViaAppRuntime,
   RateStateValidationUnavailableError,
@@ -54,6 +55,7 @@ export const RATE_ACQUIRE_MAX_WAIT_MS = 300_000;
  */
 export const PROVIDER_ADMISSION_WAIT_BUDGET_MS = 120_000;
 const PROVIDER_NO_PROGRESS_WARNING_MS = 180_000;
+const SUCCESS_FEEDBACK_DRAIN_TIMEOUT_MS = 10_000;
 
 /**
  * Permits leased per app-runtime round trip for the direct Node substrate.
@@ -77,6 +79,10 @@ export interface AppRuntimeRatePort {
   penalize(
     input: Parameters<typeof penalizeRateStateViaAppRuntime>[1],
   ): ReturnType<typeof penalizeRateStateViaAppRuntime>;
+  flushFeedback?(
+    input: Parameters<typeof flushRateStateFeedbackViaAppRuntime>[1],
+    signal: AbortSignal,
+  ): Promise<void>;
   validate?(
     input: Parameters<typeof validateRateStateViaAppRuntime>[1],
   ): ReturnType<typeof validateRateStateViaAppRuntime>;
@@ -87,6 +93,8 @@ function contextRatePort(context: WorkerRuntimeApiContext): AppRuntimeRatePort {
     acquire: (input) => acquireRateStateViaAppRuntime(context, input),
     release: (input) => releaseRateStateViaAppRuntime(context, input),
     penalize: (input) => penalizeRateStateViaAppRuntime(context, input),
+    flushFeedback: (input, signal) =>
+      flushRateStateFeedbackViaAppRuntime(context, input, signal),
     validate: (input) => validateRateStateViaAppRuntime(context, input),
   };
 }
@@ -296,6 +304,16 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
   private readonly effectiveRps = new Map<string, number>();
   private readonly pendingSuccesses = new Map<string, number>();
   private readonly successFeedbackFlights = new Map<string, SuccessFeedback>();
+  private readonly successFeedbackScopes = new Map<
+    string,
+    {
+      bucketId: string;
+      rateScopeToken?: string | null;
+      rules: readonly PacingRule[];
+    }
+  >();
+  private readonly successFeedbackSupported = new Set<string>();
+  private successFeedbackDrain: Promise<void> | null = null;
   /**
    * Completion samples travel with the next lease refill. This keeps the
    * Gradient2 checkpoint current without adding one gateway request per row.
@@ -1072,7 +1090,22 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
                   : rawResponse.waitMs,
             }
           : rawResponse;
-        this.acknowledgeSuccessFeedback(successKey, feedback);
+        const acknowledged = response.acknowledgedObservationBatch;
+        const submitted = feedback.concurrencyObservationBatch;
+        if (
+          acknowledged === undefined ||
+          (submitted &&
+            acknowledged?.observerId === submitted.observerId &&
+            acknowledged.laneId === submitted.laneId &&
+            acknowledged.sequence === submitted.sequence)
+        ) {
+          this.acknowledgeSuccessFeedback(successKey, feedback);
+        }
+        if (response.successFeedbackSupported === true) {
+          this.successFeedbackSupported.add(bucketId);
+        } else {
+          this.successFeedbackSupported.delete(bucketId);
+        }
         this.recordCooldown(bucketId, response);
         if (response.scopeValidationSupported === true)
           this.validationScopes.add(bucketId);
@@ -1559,11 +1592,17 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
 
   observeSuccess(input: {
     bucketId: string;
+    rateScopeToken?: string | null;
     rules: readonly PacingRule[];
     latencyMs?: number | null;
   }): void {
     this.providerStalls.delete(input.bucketId);
     const key = pendingSuccessKey(input.bucketId, input.rules);
+    this.successFeedbackScopes.set(key, {
+      bucketId: input.bucketId,
+      rateScopeToken: input.rateScopeToken,
+      rules: input.rules,
+    });
     this.pendingSuccesses.set(
       key,
       Math.min(1_000_000, (this.pendingSuccesses.get(key) ?? 0) + 1),
@@ -1593,6 +1632,43 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
     this.pendingConcurrencyObservations.set(key, pending);
   }
 
+  async flushSuccessFeedback(): Promise<void> {
+    if (!this.port.flushFeedback) return;
+    if (this.successFeedbackDrain) return await this.successFeedbackDrain;
+    const signal = AbortSignal.timeout(SUCCESS_FEEDBACK_DRAIN_TIMEOUT_MS);
+    const drain = async () => {
+      for (const [key, scope] of this.successFeedbackScopes) {
+        // Older receivers retain their existing piggyback behavior. An explicit
+        // capability and matching batch acknowledgement protect rolling deploys.
+        if (!this.successFeedbackSupported.has(scope.bucketId)) continue;
+        for (;;) {
+          if (signal.aborted) throw abortReason(signal);
+          const feedback = this.snapshotSuccessFeedback(key);
+          if (!feedback.concurrencyObservationBatch) break;
+          await this.port.flushFeedback!(
+            {
+              ...scope,
+              rules: [...scope.rules],
+              leaseIds: [],
+              ...feedback,
+              schedulerSchema: this.schedulerSchema,
+            },
+            signal,
+          );
+          // A lost response leaves this exact frozen payload available to retry.
+          this.acknowledgeSuccessFeedback(key, feedback);
+        }
+        this.successFeedbackScopes.delete(key);
+      }
+    };
+    this.successFeedbackDrain = drain();
+    try {
+      await this.successFeedbackDrain;
+    } finally {
+      this.successFeedbackDrain = null;
+    }
+  }
+
   private newPendingConcurrencyObservations(
     key: string,
     observations: Array<{ kind: 'success'; latencyMs: number }> = [],

package/dist/bundling-sources/shared_libs/play-runtime/governor/governor.ts

@@ -868,6 +868,7 @@ export function createPlayExecutionGovernor(
         if (!rules) return;
         input.rateState.observeSuccess?.({
           bucketId: rateScope[0],
+          ...(rateScope[1] ? { rateScopeToken: rateScope[1] } : {}),
           rules,
           latencyMs: success.latencyMs,
         });

package/dist/bundling-sources/shared_libs/play-runtime/governor/rate-state-backend.ts

@@ -197,6 +197,9 @@ export interface RateStateBackend {
     /** Provider residence measured at the HTTP boundary. */
     latencyMs?: number | null;
   }): void;
+
+  /** Bounded final feedback write after the invocation's provider work settles. */
+  flushSuccessFeedback?(): Promise<void>;
 }
 
 const NOOP_PERMIT: PacingPermit = {

package/dist/bundling-sources/shared_libs/play-runtime/protocol.ts

@@ -90,6 +90,13 @@ export type PlayRunnerRateStateAcquireResult = {
   scopeValidationSupported?: boolean;
   /** This gateway rechecks signed provider permits on integration execute. */
   dispatchValidationSupported?: boolean;
+  /** This receiver acknowledges replay-safe success batches on release. */
+  successFeedbackSupported?: boolean;
+  /**
+   * Exact committed feedback identity; null leaves the batch pending for replay.
+   * Absent preserves implicit acknowledgement from older receivers.
+   */
+  acknowledgedObservationBatch?: PlayRunnerRateStateConcurrencyObservationBatch | null;
   /**
    * Gateway clock used to produce `scheduledAtMs`. Runners translate the
    * schedule into relative delays so cross-machine clock skew cannot compress
@@ -138,6 +145,10 @@ export type PlayRunnerRateStateReleaseInput = {
   leaseIds: string[];
   /** Idempotently refund rate reservations that never reached provider fetch. */
   refundReservationIds?: string[];
+  /** Flush confirmed outcomes without reserving another provider permit. */
+  observedSuccesses?: number;
+  concurrencyObservations?: PlayRunnerRateStateConcurrencyObservation[];
+  concurrencyObservationBatch?: PlayRunnerRateStateConcurrencyObservationBatch;
   schedulerSchema?: string | null;
 };
 

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

@@ -3788,6 +3788,19 @@ async function run(
   } finally {
     clearInterval(workCounterTimer);
     emitWorkCounters();
+    try {
+      await rateStateBackend.rateState?.flushSuccessFeedback?.();
+    } catch (feedbackError) {
+      // Feedback is advisory: preserve the Play's result or original failure.
+      emitWorkerLog(
+        `[warn] runtime.provider_success_feedback_flush_failed: ${
+          feedbackError instanceof Error
+            ? feedbackError.message
+            : String(feedbackError)
+        }`,
+        options,
+      );
+    }
   }
 }
 

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

@@ -83,6 +83,23 @@ export type StagedDaytonaPayload = {
   startupDiagnosticPath: string;
 };
 
+/** No payload or customer command has been sent when this is raised. */
+export class DaytonaNodeUnavailableError extends Error {
+  constructor(
+    readonly diagnostic: {
+      reason: 'command_failed' | 'empty_output';
+      exitCode: number | null;
+      attempts: number;
+      responseBytes: number;
+    },
+  ) {
+    super(
+      `Daytona Node executable was not ready before payload staging (${diagnostic.reason}, exit ${diagnostic.exitCode ?? 'unknown'}).`,
+    );
+    this.name = 'DaytonaNodeUnavailableError';
+  }
+}
+
 export type RemoteRunnerPayloadSandbox = {
   id: string;
   /** Daytona target (region) the sandbox runs in, when the provider reports it. */
@@ -129,10 +146,11 @@ function nodeMaterializePayloadCommand(input: {
   artifactCodePath: string;
   artifactSourceMapPath: string;
   crashPusherPath: string;
+  nodeBinaryPath?: string;
 }): string {
   const script = buildDaytonaPayloadMaterializerSource();
   return [
-    'node',
+    input.nodeBinaryPath ? shellQuote(input.nodeBinaryPath) : 'node',
     '-e',
     shellQuote(script),
     shellQuote(input.envelopePath),
@@ -583,6 +601,8 @@ export function withRunnerSandboxProvider(
 export async function stageRunnerPayload(input: {
   sandbox: RemoteRunnerPayloadSandbox;
   bundlePromise: Promise<string>;
+  /** A provider-resolved executable, independent of detached-shell PATH. */
+  nodeBinaryPath?: string;
   config: PlayRunnerExecutionConfig;
   /** Provider-selected burst ceiling; the stored profile remains a reservation. */
   memoryLimitMiB?: number;
@@ -736,8 +756,11 @@ export async function stageRunnerPayload(input: {
     typeof sandboxTarget === 'string' && sandboxTarget.trim()
       ? `DEEPLINE_SANDBOX_TARGET=${shellQuote(sandboxTarget.trim())} `
       : '';
+  const nodeCommand = input.nodeBinaryPath
+    ? shellQuote(input.nodeBinaryPath)
+    : 'node';
   const watchedRunnerCommand = [
-    'node',
+    nodeCommand,
     '-e',
     shellQuote(
       buildDaytonaRuntimeWatchdogSource(
@@ -766,6 +789,7 @@ export async function stageRunnerPayload(input: {
     artifactCodePath,
     artifactSourceMapPath,
     crashPusherPath,
+    nodeBinaryPath: input.nodeBinaryPath,
   })} && 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 an unacknowledged parsed (or synthesized) terminal so the parked
@@ -775,7 +799,7 @@ export async function stageRunnerPayload(input: {
   // Its own retry diagnostics are kept in a separate log: appending them to
   // `outputPath` after a near-gateway-sized result could hide that result from
   // a later bounded-tail recovery read.
-  const command = `rm -f ${shellQuote(outputPath)} ${shellQuote(crashPusherLogPath)} ${shellQuote(exitCodePath)} ${shellQuote(oomKillBaselinePath)} ${shellQuote(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"`;
+  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}${nodeCommand} ${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,
@@ -793,12 +817,61 @@ export async function stageRunnerPayload(input: {
 }
 
 export async function stageDaytonaRunnerPayload(
-  input: Omit<Parameters<typeof stageRunnerPayload>[0], 'sandbox'> & {
+  input: Omit<
+    Parameters<typeof stageRunnerPayload>[0],
+    'sandbox' | 'nodeBinaryPath'
+  > & {
     sandbox: DaytonaSandbox;
   },
 ): Promise<StagedDaytonaPayload> {
+  // Toolbox commands and detached sessions need not share PATH. Bind the
+  // provider's actual Node executable before constructing either launcher.
+  const nodeStartedAt = Date.now();
+  // A started sandbox may still be bringing its toolbox/runtime online. Retry
+  // only an unsuccessful or empty readiness read on this same sandbox before
+  // handing the pre-code failure back to the existing startup recovery owner.
+  const retryDelaysMs = [0, 150, 350] as const;
+  let node!: Awaited<ReturnType<DaytonaSandbox['process']['executeCommand']>>;
+  for (const [attempt, delayMs] of retryDelaysMs.entries()) {
+    if (delayMs) await new Promise((resolve) => setTimeout(resolve, delayMs));
+    node = await input.sandbox.process.executeCommand(
+      'node -p process.execPath',
+      input.workDir,
+      {},
+      5,
+    );
+    if (node.exitCode === 0 && node.result.trim() !== '') break;
+    const diagnostic = {
+      reason: node.exitCode === 0 ? 'empty_output' : 'command_failed',
+      exitCode:
+        typeof node.exitCode === 'number' && Number.isInteger(node.exitCode)
+          ? node.exitCode
+          : null,
+      attempts: attempt + 1,
+      responseBytes: Buffer.byteLength(node.result),
+    } satisfies DaytonaNodeUnavailableError['diagnostic'];
+    input.emitStage('runtime:node_unavailable', diagnostic);
+    if (attempt === retryDelaysMs.length - 1) {
+      throw new DaytonaNodeUnavailableError(diagnostic);
+    }
+  }
+  const nodeBinaryPath = node.result.trim();
+  if (
+    node.exitCode !== 0 ||
+    !nodeBinaryPath.startsWith('/') ||
+    /[\r\n\0]/.test(nodeBinaryPath) ||
+    nodeBinaryPath.length > 4_096
+  ) {
+    throw new Error(
+      'Daytona did not confirm an absolute Node executable path for this sandbox.',
+    );
+  }
+  input.emitStage('runtime:node_resolved', {
+    elapsedMs: Date.now() - nodeStartedAt,
+  });
   return await stageRunnerPayload({
     ...input,
+    nodeBinaryPath,
     sandbox: {
       id: input.sandbox.id,
       target: