deepline 0.2.55 → 0.2.57

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

@@ -79,37 +79,88 @@ export interface ResolvedExecutionPolicy {
   readonly pacing: ExecutionPacingPolicy;
 }
 
+export const DEFAULT_MAX_CONCURRENT_EXTERNAL_CALLS = 64;
+export const MAX_CONFIGURABLE_CONCURRENT_EXTERNAL_CALLS = 256;
+export const MAX_CONFIGURABLE_CONCURRENT_ROWS = 1_000;
+// Dispatch groups are only a scheduler envelope. The external-call semaphore
+// remains the resource bound, so do not impose a lower hidden ceiling here.
+// This lets an explicit run-level call limit describe the actual concurrency
+// available to long-residence providers while still bounding live calls.
+export const DEFAULT_MAX_IN_FLIGHT_TOOL_DISPATCH_GROUPS =
+  MAX_CONFIGURABLE_CONCURRENT_EXTERNAL_CALLS;
+// Launches persisted before this field existed used the original fixed
+// eight-slot policy. Preserve that value on their retries and resumes.
+export const LEGACY_MAX_CONCURRENT_EXTERNAL_CALLS = 8;
+
+export function resolveMaxConcurrentExternalCalls(
+  requested?: number | null,
+): number {
+  if (requested === undefined || requested === null) {
+    return DEFAULT_MAX_CONCURRENT_EXTERNAL_CALLS;
+  }
+  if (
+    !Number.isSafeInteger(requested) ||
+    requested < 1 ||
+    requested > MAX_CONFIGURABLE_CONCURRENT_EXTERNAL_CALLS
+  ) {
+    throw new Error(
+      `maxConcurrentExternalCalls must be a whole number from 1 through ${MAX_CONFIGURABLE_CONCURRENT_EXTERNAL_CALLS}.`,
+    );
+  }
+  return requested;
+}
+
+export function resolveMaxConcurrentRows(
+  requested?: number | null,
+): number | null {
+  if (requested === undefined || requested === null) return null;
+  if (
+    !Number.isSafeInteger(requested) ||
+    requested < 1 ||
+    requested > MAX_CONFIGURABLE_CONCURRENT_ROWS
+  ) {
+    throw new Error(
+      `maxConcurrentRows must be a whole number from 1 through ${MAX_CONFIGURABLE_CONCURRENT_ROWS}.`,
+    );
+  }
+  return requested;
+}
+
 /**
  * The shared default policy. Both substrates use this verbatim unless an entry
  * in {@link ADAPTER_POLICY_OVERRIDES} forces a documented difference.
  */
 export const SHARED_EXECUTION_POLICY: ResolvedExecutionPolicy = {
   concurrency: {
-    // Logical row target. A 1,000-row window can fill five 200-item provider
-    // batches or keep a 100-RPS unbatched provider fed; the runtime's shared
-    // resident-byte admission calculator clamps fat rows below this target.
-    // Pending rows remain indexes, not promises or pre-claimed receipts.
-    rowDefault: 1_000,
-    // Finite global ceiling across concurrent maps in one run. This intentionally
-    // matches the default: throughput grows through provider pacing/batching,
-    // while row payload size can only reduce admission through the byte budget.
+    // Bound the complete live row promise graph, not only outbound calls.
+    // Cached provider payloads can expand far beyond their encoded receipt size
+    // while Node parses and delivers result lists. Twenty rows leave enough
+    // headroom in a standard 1 GiB sandbox while still filling the default
+    // external-call scheduling group. Pending rows remain compact indexes.
+    // Pure-compute maps
+    // use a separate fast path and do not pay this bound.
+    rowDefault: 20,
+    // Internal callers can request a wider window, but the default remains the
+    // safe standard-sandbox resident set. The input-byte estimator may reduce
+    // either value further for large source rows.
     rowMax: 1_000,
-    // Global logical-call backstop. A logical call can spend most of its life
-    // waiting on a provider/fixture response without holding a network socket.
-    toolCalls: 256,
+    // Global logical-call backstop. The default is intentionally close to the
+    // standard row cohort so slow small responses do not serialize most rows.
+    // Runs may request a value through the validated 1..256 launch contract;
+    // provider pacing and the runner-owned hard ceiling still apply.
+    toolCalls: DEFAULT_MAX_CONCURRENT_EXTERNAL_CALLS,
     // Physical runtime-to-app fetch/body admission. Keep short socket bursts
     // below the sandbox/Vercel transport cliff while allowing many more logical
     // calls to remain resident. This is deliberately independent of provider
     // rate limits: it protects Deepline's own transport edge.
     integrationRequests: 64,
-    // Scheduling groups contain bounded-dispatch workers and receipt buffers.
-    // Keep their promise topology finite even when pipelined replacement rows
-    // become ready one at a time behind a slower provider pacer.
-    toolDispatchGroups: 32,
-    // Preserve limited overlap so a fast row can enter its next column while a
-    // prior group's receipt persistence is still settling. Provider permits
-    // enforce declared maxConcurrency across these overlapping groups.
-    toolDispatchGroupsPerLane: 4,
+    // Scheduling cohorts overlap provider-response tails, but each cohort may
+    // itself contain many logical calls. Keep this materially above the legacy
+    // eight-group ceiling without creating one independently flushed cohort
+    // per configured tool slot. The latter fragments batchable providers and
+    // adds receipt/gateway round trips under wide (128+) runs.
+    toolDispatchGroups: DEFAULT_MAX_IN_FLIGHT_TOOL_DISPATCH_GROUPS,
+    toolDispatchGroupsPerLane: DEFAULT_MAX_IN_FLIGHT_TOOL_DISPATCH_GROUPS,
   },
   budgets: {
     // Runaway guards, not workload limits. A 5,000-row map calling several tools
@@ -181,13 +232,22 @@ export function resolveExecutionPolicy(
 export function resolveRowConcurrency(
   policy: ResolvedExecutionPolicy,
   requested?: number,
+  runMaximum?: number | null,
 ): number {
+  const normalizedRunMaximum = resolveMaxConcurrentRows(runMaximum);
   if (
     typeof requested === 'number' &&
     Number.isFinite(requested) &&
     requested > 0
   ) {
-    return Math.min(Math.floor(requested), policy.concurrency.rowMax);
+    return Math.min(
+      Math.floor(requested),
+      normalizedRunMaximum ?? policy.concurrency.rowMax,
+      policy.concurrency.rowMax,
+    );
   }
-  return policy.concurrency.rowDefault;
+  return Math.min(
+    normalizedRunMaximum ?? policy.concurrency.rowDefault,
+    policy.concurrency.rowMax,
+  );
 }

package/dist/bundling-sources/shared_libs/play-runtime/output-size-limits.ts

@@ -47,6 +47,13 @@ export const RUNNER_TERMINAL_PUSH_MAX_BODY_BYTES = 16 * 1024 * 1024;
  * 10 MiB receipt fits while compatible fat receipts split before transport.
  */
 export const RUNTIME_RECEIPT_GATEWAY_BATCH_MAX_BYTES = 12 * 1024 * 1024;
+/**
+ * Aim below the hard gateway ceiling when coalescing receipts. One legal large
+ * receipt may exceed this target and is still sent alone; the target only
+ * prevents several multi-megabyte results from monopolizing the serialized
+ * gateway writer behind one request.
+ */
+export const RUNTIME_RECEIPT_WRITER_TARGET_BATCH_BYTES = 4 * 1024 * 1024;
 /**
  * The terminal `result` line is the crash-recovery record in Daytona stdout.
  * Once that line is written, retries may still emit runner-owned diagnostics.

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

@@ -133,6 +133,9 @@ export interface PlayRunnerContextConfig {
   fixtureBehavior?: FixtureBehavior | null;
   /** Preview/dev test seam that applies provider pacing to fixture responses. */
   enforceFixtureProviderPacing?: boolean;
+  /** Validated per-run ceiling for provider-tool executions and ctx.fetch. */
+  maxConcurrentExternalCalls?: number | null;
+  maxConcurrentRows?: number | null;
   /** Immutable tool-error payload schema copied from the run contract. */
   toolErrorSchemaVersion?: ToolExecutionErrorSchemaVersion;
   orgId?: string;

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

@@ -109,6 +109,11 @@ function isDaytonaSandboxStartTimeout(error: string): boolean {
   );
 }
 
+function isDaytonaSandboxStateChangeConflict(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  return /Sandbox state change in progress/i.test(message);
+}
+
 type DaytonaCreateResult = {
   sandbox: DaytonaSandbox;
   attempt: number;
@@ -300,6 +305,7 @@ async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
   sandboxName: string;
 }): Promise<boolean> {
   if (!input.daytona.get) return false;
+  let lastDeleteConflict: unknown = null;
   for (const delayMs of DAYTONA_TIMED_OUT_CREATE_RECONCILE_DELAYS_MS) {
     if (delayMs > 0) {
       await new Promise((resolve) => setTimeout(resolve, delayMs));
@@ -313,6 +319,15 @@ async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
     try {
       await sandbox.delete(30);
     } catch (error) {
+      // Daytona can make the named sandbox lookup-addressable before its
+      // timed-out create transition has settled. That exact conflict is not a
+      // cleanup verdict: re-read the same provider identity after the bounded
+      // reconcile delay instead of failing the run or launching a duplicate
+      // sandbox while the first one is still becoming ready.
+      if (isDaytonaSandboxStateChangeConflict(error)) {
+        lastDeleteConflict = error;
+        continue;
+      }
       throw new Error(
         `Daytona timed-out sandbox ${sandbox.id} was reconciled by name but could not be deleted. Modal fallback suppressed.`,
         { cause: error },
@@ -320,6 +335,12 @@ async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
     }
     return true;
   }
+  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 false;
 }
 

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

@@ -66,6 +66,7 @@ export type StagedDaytonaPayload = {
   outputPath: string;
   exitCodePath: string;
   runtimeCompletedPath: string;
+  terminationDiagnosticPath: string;
   progressEventPath: string;
 };
 
@@ -142,6 +143,7 @@ const outputPath = process.argv[4];
 const runtimeLimitMarkerPath = process.argv[5] || '';
 const oomKillBaselinePath = process.argv[6] || '';
 const memoryEventsPath = process.argv[7] || '/sys/fs/cgroup/memory.events';
+const terminationDiagnosticPath = process.argv[8] || '';
 const exitCode = Number.isFinite(exitCodeRaw) ? exitCodeRaw : null;
 const MAX_OUTPUT_BYTES = ${DAYTONA_CRASH_PUSHER_OUTPUT_TAIL_MAX_BYTES};
 const MAX_POST_TERMINAL_DIAGNOSTIC_BYTES = ${RUNNER_POST_TERMINAL_DIAGNOSTIC_MAX_BYTES};
@@ -221,6 +223,23 @@ function cgroupOomKillObserved() {
   return false;
 }
 
+function watchdogObservedChildSigkill() {
+  try {
+    if (!terminationDiagnosticPath) return false;
+    const diagnostic = JSON.parse(
+      fs.readFileSync(terminationDiagnosticPath, 'utf8'),
+    );
+    return Boolean(
+      diagnostic &&
+        diagnostic.schemaVersion === 1 &&
+        diagnostic.reason === 'child_exit' &&
+        diagnostic.childExitCode === null &&
+        diagnostic.childSignal === 'SIGKILL',
+    );
+  } catch {}
+  return false;
+}
+
 function terminalResultForTransport(result) {
   if (
     result &&
@@ -273,7 +292,10 @@ async function main() {
   // 137 is SIGKILL, not proof of an OOM. A watchdog, platform eviction, or
   // operator action can produce the same status. Only label this an OOM when
   // the captured runtime output carries an explicit V8 allocation signature.
-  const sandboxKilled = exitCode === 137;
+  // The shell sees the watchdog's exit code, not necessarily the nested
+  // runner child's signal. Read the watchdog's strict marker so a child
+  // SIGKILL does not collapse into the wrapper's generic exit code 1.
+  const sandboxKilled = exitCode === 137 || watchdogObservedChildSigkill();
   const sandboxOom =
     sandboxKilled && (outputHasExplicitOomSignature() || cgroupOomKillObserved());
   const synthesizedError = runtimeLimitExceeded
@@ -549,6 +571,7 @@ export async function stageRunnerPayload(input: {
   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`;
+  const terminationDiagnosticPath = `${workDir}/deepline-play-termination-${randomUUID()}.json`;
   const progressEventPath = `${workDir}/deepline-play-progress-${randomUUID()}.jsonl`;
   const runnerTraceEnv =
     process.env.DEEPLINE_RUNTIME_RECEIPT_TRACE === '1'
@@ -566,6 +589,7 @@ export async function stageRunnerPayload(input: {
     String(PLAY_RUNNER_STARTUP_GRACE_SECONDS * 1_000),
     String(PLAY_RUNNER_TERMINAL_GRACE_SECONDS * 1_000),
     shellQuote(runtimeLimitMarkerPath),
+    shellQuote(terminationDiagnosticPath),
   ].join(' ');
   const runnerCommand = `${nodeMaterializePayloadCommand({
     envelopePath,
@@ -583,7 +607,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(runtimeStartedPath)} ${shellQuote(runtimeCompletedPath)} ${shellQuote(runtimeLimitMarkerPath)} ${shellQuote(progressEventPath)} ${shellQuote(`${progressEventPath}.*`)}; ( 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)}; node ${shellQuote(crashPusherPath)} ${shellQuote(configPath)} "$code" ${shellQuote(outputPath)} ${shellQuote(runtimeLimitMarkerPath)} ${shellQuote(oomKillBaselinePath)} /sys/fs/cgroup/memory.events > ${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(runtimeStartedPath)} ${shellQuote(runtimeCompletedPath)} ${shellQuote(runtimeLimitMarkerPath)} ${shellQuote(terminationDiagnosticPath)} ${shellQuote(progressEventPath)} ${shellQuote(`${progressEventPath}.*`)}; ( 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)}; node ${shellQuote(crashPusherPath)} ${shellQuote(configPath)} "$code" ${shellQuote(outputPath)} ${shellQuote(runtimeLimitMarkerPath)} ${shellQuote(oomKillBaselinePath)} /sys/fs/cgroup/memory.events ${shellQuote(terminationDiagnosticPath)} > ${shellQuote(crashPusherLogPath)} 2>&1 || true; printf 'deepline runner output captured: %s\\n' ${shellQuote(outputPath)}; exit "$code"`;
 
   return {
     workDir: input.workDir,
@@ -591,6 +615,7 @@ export async function stageRunnerPayload(input: {
     outputPath,
     exitCodePath,
     runtimeCompletedPath,
+    terminationDiagnosticPath,
     progressEventPath,
   };
 }

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

@@ -18,11 +18,16 @@ const limitMs = Math.max(1, Number.parseInt(process.argv[5] || '', 10) || 1);
 const startupLimitMs = Math.max(1, Number.parseInt(process.argv[6] || '', 10) || 1);
 const terminalGraceMs = Math.max(1, Number.parseInt(process.argv[7] || '', 10) || 1);
 const runtimeLimitMarkerPath = process.argv[8] || '';
+const terminationDiagnosticPath = process.argv[9] || '';
 const runtimeLimitSeconds = Math.max(1, Math.ceil(limitMs / 1_000));
-const child = spawn(process.execPath, [runnerPath, configPath], {
+const child = spawn(
+  process.execPath,
+  ['--max-old-space-size=512', runnerPath, configPath],
+  {
   env: process.env,
   stdio: 'inherit',
-});
+  },
+);
 let timedOut = false;
 let startupTimedOut = false;
 let terminalFlushTimedOut = false;
@@ -31,7 +36,25 @@ let forceKillTimer = null;
 let runtimeTimer = null;
 let terminalGraceTimer = null;
 
-function stopChild() {
+function writeTerminationDiagnostic(reason, details = {}) {
+  if (!terminationDiagnosticPath) return;
+  try {
+    fs.writeFileSync(
+      terminationDiagnosticPath,
+      JSON.stringify({
+        schemaVersion: 1,
+        reason,
+        runtimeStarted: fs.existsSync(runtimeStartedPath),
+        runtimeCompleted: fs.existsSync(runtimeCompletedPath),
+        ...details,
+      }),
+      { flag: 'wx' },
+    );
+  } catch {}
+}
+
+function stopChild(reason, details) {
+  writeTerminationDiagnostic(reason, details);
   child.kill('SIGTERM');
   forceKillTimer = setTimeout(() => child.kill('SIGKILL'), 1_000);
 }
@@ -60,7 +83,7 @@ function armRuntimeDeadline() {
         runtimeLimitSeconds +
         ' second runtime limit and was stopped by the external watchdog.\\n',
     );
-    stopChild();
+    stopChild('runtime_limit');
   }, limitMs);
 }
 
@@ -75,7 +98,7 @@ function armTerminalGrace() {
   terminalGraceTimer = setTimeout(() => {
     terminalFlushTimedOut = true;
     process.stderr.write('RUNTIME_TERMINAL_FLUSH_LIMIT_EXCEEDED: terminal settlement exceeded its grace period.\\n');
-    stopChild();
+    stopChild('terminal_flush_limit');
   }, terminalGraceMs);
 }
 
@@ -92,7 +115,7 @@ const startupTimer = setTimeout(() => {
   startupTimedOut = true;
   clearInterval(runtimeBoundaryPoll);
   process.stderr.write('RUNTIME_STARTUP_LIMIT_EXCEEDED: runner never reached the customer-code boundary.\\n');
-  stopChild();
+  stopChild('startup_limit');
 }, startupLimitMs);
 if (fs.existsSync(runtimeStartedPath)) armRuntimeDeadline();
 if (fs.existsSync(runtimeCompletedPath)) armTerminalGrace();
@@ -116,9 +139,25 @@ function finish(code) {
       : 1;
 }
 
-child.once('error', () => finish(1));
-child.once('exit', (code) => finish(code));
-process.once('SIGTERM', stopChild);
-process.once('SIGINT', stopChild);
+child.once('error', (error) => {
+  writeTerminationDiagnostic('child_spawn_error', {
+    errorName: error && typeof error.name === 'string' ? error.name : 'Error',
+    errorCode: error && typeof error.code === 'string' ? error.code : null,
+  });
+  finish(1);
+});
+child.once('exit', (code, signal) => {
+  writeTerminationDiagnostic('child_exit', {
+    childExitCode: typeof code === 'number' ? code : null,
+    childSignal: typeof signal === 'string' ? signal : null,
+  });
+  finish(code);
+});
+process.once('SIGTERM', () =>
+  stopChild('watchdog_signal', { watchdogSignal: 'SIGTERM' }),
+);
+process.once('SIGINT', () =>
+  stopChild('watchdog_signal', { watchdogSignal: 'SIGINT' }),
+);
 `;
 }

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

@@ -74,8 +74,93 @@ export type DaytonaCrashDiagnostic = {
   tailTruncated: boolean;
   signals: string[];
   unclassifiedLineCount: number;
+  termination: DaytonaTerminationDiagnostic | null;
   collectionFailure: DaytonaLookupFailure | null;
 };
+export type DaytonaTerminationDiagnostic = {
+  schemaVersion: 1;
+  reason:
+    | 'runtime_limit'
+    | 'terminal_flush_limit'
+    | 'startup_limit'
+    | 'watchdog_signal'
+    | 'child_spawn_error'
+    | 'child_exit';
+  runtimeStarted: boolean;
+  runtimeCompleted: boolean;
+  childExitCode?: number | null;
+  childSignal?: string | null;
+  watchdogSignal?: 'SIGTERM' | 'SIGINT';
+  errorName?: string;
+  errorCode?: string | null;
+};
+
+function parseDaytonaTerminationDiagnostic(
+  value: unknown,
+): DaytonaTerminationDiagnostic | null {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  const candidate = value as Record<string, unknown>;
+  const reasons = new Set<DaytonaTerminationDiagnostic['reason']>([
+    'runtime_limit',
+    'terminal_flush_limit',
+    'startup_limit',
+    'watchdog_signal',
+    'child_spawn_error',
+    'child_exit',
+  ]);
+  if (
+    candidate.schemaVersion !== 1 ||
+    typeof candidate.reason !== 'string' ||
+    !reasons.has(candidate.reason as DaytonaTerminationDiagnostic['reason']) ||
+    typeof candidate.runtimeStarted !== 'boolean' ||
+    typeof candidate.runtimeCompleted !== 'boolean'
+  ) {
+    return null;
+  }
+  const diagnostic: DaytonaTerminationDiagnostic = {
+    schemaVersion: 1,
+    reason: candidate.reason as DaytonaTerminationDiagnostic['reason'],
+    runtimeStarted: candidate.runtimeStarted,
+    runtimeCompleted: candidate.runtimeCompleted,
+  };
+  if (candidate.childExitCode === null) {
+    diagnostic.childExitCode = null;
+  } else if (
+    typeof candidate.childExitCode === 'number' &&
+    Number.isSafeInteger(candidate.childExitCode)
+  ) {
+    diagnostic.childExitCode = candidate.childExitCode;
+  }
+  if (candidate.childSignal === null) {
+    diagnostic.childSignal = null;
+  } else if (
+    typeof candidate.childSignal === 'string' &&
+    /^SIG[A-Z0-9]+$/.test(candidate.childSignal)
+  ) {
+    diagnostic.childSignal = candidate.childSignal;
+  }
+  if (
+    candidate.watchdogSignal === 'SIGTERM' ||
+    candidate.watchdogSignal === 'SIGINT'
+  ) {
+    diagnostic.watchdogSignal = candidate.watchdogSignal;
+  }
+  if (
+    typeof candidate.errorName === 'string' &&
+    /^[A-Za-z][A-Za-z0-9]{0,39}$/.test(candidate.errorName)
+  ) {
+    diagnostic.errorName = candidate.errorName;
+  }
+  if (
+    candidate.errorCode === null ||
+    (typeof candidate.errorCode === 'string' &&
+      /^[A-Z0-9_]{1,40}$/.test(candidate.errorCode))
+  ) {
+    diagnostic.errorCode =
+      typeof candidate.errorCode === 'string' ? candidate.errorCode : null;
+  }
+  return diagnostic;
+}
 type DaytonaUploadAttemptTiming = {
   attempt: number;
   sandboxId: string;
@@ -198,7 +283,8 @@ function daytonaCrashDiagnosticSignature(line: string): string | null {
   if (/\bunhandled(?:promiserejection)?\b/i.test(line))
     signals.add('exception:unhandled_rejection');
   if (/\bFATAL ERROR\b/i.test(line)) signals.add('runtime:fatal_error');
-  if (/heap out of memory/i.test(line)) signals.add('runtime:heap_out_of_memory');
+  if (/heap out of memory/i.test(line))
+    signals.add('runtime:heap_out_of_memory');
 
   for (const code of line.matchAll(/\b(ENOMEM|EPIPE|ECONNRESET|ETIMEDOUT)\b/gi))
     signals.add(`transport:${code[1]!.toUpperCase()}`);
@@ -268,6 +354,7 @@ export async function readDetachedDaytonaCrashDiagnostic(input: {
   cmdId: string;
   outputPath: string;
   exitCodePath: string;
+  terminationDiagnosticPath?: string;
   expectedOrganizationId?: string | null;
 }): Promise<DaytonaCrashDiagnostic> {
   const unavailable = (
@@ -282,6 +369,7 @@ export async function readDetachedDaytonaCrashDiagnostic(input: {
     tailTruncated: false,
     signals: [],
     unclassifiedLineCount: 0,
+    termination: null,
     collectionFailure,
   });
   try {
@@ -307,10 +395,10 @@ export async function readDetachedDaytonaCrashDiagnostic(input: {
       };
     }
 
-    const script = `const fs=require('node:fs');const output=process.argv[1];const exit=process.argv[2];const max=Number(process.argv[3]);const stat=fs.statSync(output);const start=Math.max(0,stat.size-max);const fd=fs.openSync(output,'r');const tail=Buffer.alloc(stat.size-start);fs.readSync(fd,tail,0,tail.length,start);fs.closeSync(fd);let exitCode=null;try{const value=Number.parseInt(fs.readFileSync(exit,'utf8').trim(),10);if(Number.isFinite(value))exitCode=value}catch{}process.stdout.write(JSON.stringify({outputBytes:stat.size,tail:tail.toString('base64'),exitCode}));`;
+    const script = `const fs=require('node:fs');const output=process.argv[1];const exit=process.argv[2];const max=Number(process.argv[3]);const terminationPath=process.argv[4]||'';const stat=fs.statSync(output);const start=Math.max(0,stat.size-max);const fd=fs.openSync(output,'r');const tail=Buffer.alloc(stat.size-start);fs.readSync(fd,tail,0,tail.length,start);fs.closeSync(fd);let exitCode=null;try{const value=Number.parseInt(fs.readFileSync(exit,'utf8').trim(),10);if(Number.isFinite(value))exitCode=value}catch{}let termination=null;try{const value=JSON.parse(fs.readFileSync(terminationPath,'utf8'));if(value&&typeof value==='object')termination=value}catch{}process.stdout.write(JSON.stringify({outputBytes:stat.size,tail:tail.toString('base64'),exitCode,termination}));`;
     const [snapshotResult, sessionResult] = await Promise.allSettled([
       sandbox.process.executeCommand(
-        `node -e ${shellQuoteDaytonaDiagnostic(script)} ${shellQuoteDaytonaDiagnostic(input.outputPath)} ${shellQuoteDaytonaDiagnostic(input.exitCodePath)} ${DAYTONA_CRASH_DIAGNOSTIC_TAIL_MAX_BYTES}`,
+        `node -e ${shellQuoteDaytonaDiagnostic(script)} ${shellQuoteDaytonaDiagnostic(input.outputPath)} ${shellQuoteDaytonaDiagnostic(input.exitCodePath)} ${DAYTONA_CRASH_DIAGNOSTIC_TAIL_MAX_BYTES} ${shellQuoteDaytonaDiagnostic(input.terminationDiagnosticPath ?? '')}`,
         undefined,
         {},
         8,
@@ -324,6 +412,7 @@ export async function readDetachedDaytonaCrashDiagnostic(input: {
       outputBytes?: unknown;
       tail?: unknown;
       exitCode?: unknown;
+      termination?: unknown;
     };
     const tailBuffer =
       typeof snapshot.tail === 'string'
@@ -342,6 +431,7 @@ export async function readDetachedDaytonaCrashDiagnostic(input: {
       typeof sessionResult.value?.exitCode === 'number'
         ? sessionResult.value.exitCode
         : null;
+    const termination = parseDaytonaTerminationDiagnostic(snapshot.termination);
     return {
       schemaVersion: 1,
       collectionStatus: 'collected',
@@ -358,6 +448,7 @@ export async function readDetachedDaytonaCrashDiagnostic(input: {
         outputBytes > DAYTONA_CRASH_DIAGNOSTIC_TAIL_MAX_BYTES,
       signals,
       unclassifiedLineCount,
+      termination,
       collectionFailure:
         sessionResult.status === 'rejected'
           ? describeDaytonaLookupFailure(sessionResult.reason)
@@ -1251,6 +1342,8 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
               outputPath: stagedPayload.outputPath,
               exitCodePath: stagedPayload.exitCodePath,
               runtimeCompletedPath: stagedPayload.runtimeCompletedPath,
+              terminationDiagnosticPath:
+                stagedPayload.terminationDiagnosticPath,
               startedAtMs: Date.now(),
               heartbeatTimeoutMs: push.leaseSeconds * 1_000,
               runtimeLimitSeconds: executionTimeoutSeconds,