deepline 0.3.477 → 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.477',
+  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/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

@@ -1090,7 +1090,17 @@ 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 {

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

@@ -92,6 +92,11 @@ export type PlayRunnerRateStateAcquireResult = {
   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

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:

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

@@ -29,6 +29,18 @@ export type DetachedDaytonaStartupDiagnostic = {
     errorCode?: string;
     transportAttemptId?: string;
   } | null;
+  /** Fixed summaries only: raw runner output can contain customer secrets. */
+  launcherFailure?: {
+    reason:
+      | 'node_not_found'
+      | 'node_loader_failed'
+      | 'permission_denied'
+      | 'argument_list_too_long'
+      | 'exec_format_error'
+      | 'unknown_exit_127'
+      | 'output_unavailable';
+    nodeCheckExitCode: number;
+  };
   errors: string[];
 };
 
@@ -124,6 +136,7 @@ function summarizeProcesses(value: unknown): {
  * Process names are reduced to a Node count before logging; runner logs,
  * output, and arbitrary process names are deliberately excluded because no
  * heuristic redactor can guarantee removal of arbitrary customer secrets.
+ * Exit-127 shell failures are classified inside the sandbox into fixed enums.
  */
 export async function inspectDetachedDaytonaStartup(input: {
   sandbox: DaytonaSandbox;
@@ -131,6 +144,7 @@ export async function inspectDetachedDaytonaStartup(input: {
   cmdId: string;
   exitCodePath: string;
   startupDiagnosticPath?: string;
+  outputPath?: string;
 }): Promise<DetachedDaytonaStartupDiagnostic> {
   const errors: string[] = [];
   const diagnostic: DetachedDaytonaStartupDiagnostic = {
@@ -189,6 +203,70 @@ export async function inspectDetachedDaytonaStartup(input: {
       .catch(() => errors.push('process_snapshot_failed')),
   ]);
 
+  if (
+    input.outputPath &&
+    diagnostic.exitCodeFile === 127 &&
+    !diagnostic.runnerStartup
+  ) {
+    // The failed shell is retired immediately after this inspection. Classify
+    // its bounded output inside the sandbox, returning only known enum values
+    // and an exit code. Never ship arbitrary output through a heuristic redactor.
+    const quotedPath = "'" + input.outputPath.replace(/'/g, "'\\''") + "'";
+    try {
+      const result = await input.sandbox.process.executeCommand(
+        `
+        if [ -r ${quotedPath} ]; then
+          startup_tail="$(tail -c 4096 -- ${quotedPath} 2>/dev/null)"
+          case "$startup_tail" in
+            *"error while loading shared libraries"*) startup_reason=node_loader_failed ;;
+            *"not found: node"*|*node*"not found"*|*node*"No such file"*) startup_reason=node_not_found ;;
+            *"Permission denied"*) startup_reason=permission_denied ;;
+            *"Argument list too long"*) startup_reason=argument_list_too_long ;;
+            *"Exec format error"*) startup_reason=exec_format_error ;;
+            *) startup_reason=unknown_exit_127 ;;
+          esac
+        else
+          startup_reason=output_unavailable
+        fi
+        node --version >/dev/null 2>&1
+        startup_node_code=$?
+        printf '{"reason":"%s","nodeCheckExitCode":%s}\\n' "$startup_reason" "$startup_node_code"
+      `,
+        undefined,
+        {},
+        5,
+      );
+      const value = JSON.parse(result.result) as Record<string, unknown>;
+      const reasons = [
+        'node_not_found',
+        'node_loader_failed',
+        'permission_denied',
+        'argument_list_too_long',
+        'exec_format_error',
+        'unknown_exit_127',
+        'output_unavailable',
+      ];
+      if (
+        typeof value.reason !== 'string' ||
+        !reasons.includes(value.reason) ||
+        typeof value.nodeCheckExitCode !== 'number' ||
+        !Number.isInteger(value.nodeCheckExitCode) ||
+        value.nodeCheckExitCode < 0 ||
+        value.nodeCheckExitCode > 255
+      ) {
+        errors.push('launcher_diagnostic_invalid');
+      } else {
+        diagnostic.launcherFailure = {
+          reason: value.reason as NonNullable<
+            DetachedDaytonaStartupDiagnostic['launcherFailure']
+          >['reason'],
+          nodeCheckExitCode: value.nodeCheckExitCode,
+        };
+      }
+    } catch {
+      errors.push('launcher_diagnostic_unavailable');
+    }
+  }
   return diagnostic;
 }
 
@@ -225,6 +303,7 @@ export type DetachedDaytonaRunnerSupervisor = {
     command: string;
     exitCodePath: string;
     startupDiagnosticPath?: string;
+    outputPath?: string;
   }): Promise<Extract<DetachedDaytonaRunnerState, { phase: 'ready' }>>;
 };
 
@@ -394,7 +473,7 @@ export function prepareDetachedDaytonaRunner(input: {
   let started = false;
 
   return {
-    async start({ command, exitCodePath, startupDiagnosticPath }) {
+    async start({ command, exitCodePath, startupDiagnosticPath, outputPath }) {
       if (started) {
         throw new Error(
           `Detached Daytona runner session ${input.sessionId} was already started.`,
@@ -435,6 +514,7 @@ export function prepareDetachedDaytonaRunner(input: {
           cmdId: state.cmdId,
           exitCodePath,
           startupDiagnosticPath,
+          outputPath,
           readiness: input.readiness,
           baselineHeartbeatAt: state.baselineHeartbeatAt,
           runControl: input.runControl,
@@ -461,6 +541,7 @@ export async function confirmDetachedDaytonaRunnerReady(input: {
   cmdId: string;
   exitCodePath: string;
   startupDiagnosticPath?: string;
+  outputPath?: string;
   readiness: DetachedRunnerReadinessPort;
   baselineHeartbeatAt: string | null;
   runControl?: <T>(
@@ -517,6 +598,7 @@ export async function confirmDetachedDaytonaRunnerReady(input: {
       cmdId: input.cmdId,
       exitCodePath: input.exitCodePath,
       startupDiagnosticPath: input.startupDiagnosticPath,
+      outputPath: input.outputPath,
     });
   const diagnostic = await (input.runControl
     ? input.runControl(inspect)

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

@@ -67,6 +67,7 @@ import {
   recoveryForRunnerStartupNotLive,
 } from '../../play-run-recovery-policy';
 import {
+  DaytonaNodeUnavailableError,
   stageDaytonaRunnerPayload,
   withRunnerSandboxProvider,
 } from './daytona-payload-transport';
@@ -1506,6 +1507,7 @@ const DAYTONA_UNANSWERED_REQUEST_CODES: ReadonlySet<string> = new Set([
  * loud too, because its input may be too large for any sandbox.
  */
 function isFailedDaytonaRunnerStart(error: unknown): boolean {
+  if (error instanceof DaytonaNodeUnavailableError) return true;
   if (error instanceof DaytonaControlTimeoutError) return true;
   if (!isDaytonaProviderError(error)) return false;
   const status = daytonaErrorStatusForLog(error);
@@ -1536,6 +1538,9 @@ function startFailureForLog(error: unknown) {
     errorName: error instanceof Error ? error.name : null,
     providerStatus: daytonaErrorStatusForLog(error),
     providerCode: daytonaErrorCodeForLog(error),
+    ...(error instanceof DaytonaNodeUnavailableError
+      ? { nodeReadiness: error.diagnostic }
+      : {}),
     ...(diagnostic
       ? {
           // Retain the already-sanitized evidence before sandbox retirement.
@@ -1563,6 +1568,7 @@ function startFailureForLog(error: unknown) {
                   transportAttemptId: startup.transportAttemptId,
                 }
               : null,
+            launcherFailure: diagnostic.launcherFailure,
             inspectionErrorCount: diagnostic.errors.length,
           },
         }
@@ -2092,6 +2098,7 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
               command: stagedPayload.command,
               exitCodePath: stagedPayload.exitCodePath,
               startupDiagnosticPath: stagedPayload.startupDiagnosticPath,
+              outputPath: stagedPayload.outputPath,
             });
           } catch (error) {
             if (