@@ -1,5 +1,8 @@
 import { describe, expect, it } from 'vitest'
-import { processCodeFailure } from '@/lib/execution/remote-sandbox/code-failure'
+import {
+  describeProcessExit,
+  processCodeFailure,
+} from '@/lib/execution/remote-sandbox/code-failure'
 
 /** Node 22's crash report when `fetch` loses its socket before any response bytes. */
 const FETCH_SOCKET_CLOSED = `node:internal/deps/undici/undici:13510
@@ -196,6 +199,29 @@ describe('processCodeFailure', () => {
     expect(error).toEqual({ name, value, traceback: stderr })
   })
 
+  it('names the signal for a process killed after printing only a warning', () => {
+    const warning = 'Warning: You are sending unauthenticated requests to the HF Hub.'
+    const killed = processCodeFailure({ stdout: '', stderr: warning, exitCode: 137 })
+    const exited = processCodeFailure({ stdout: '', stderr: warning, exitCode: 1 })
+
+    expect(killed.error).toEqual({
+      name: 'Error',
+      value: 'Process exited with code 137 (killed by SIGKILL, usually out of memory)',
+      traceback: warning,
+    })
+    expect(exited.error?.name).toBe('Warning')
+  })
+
+  it.each([
+    [1, 'Process exited with code 1'],
+    [128, 'Process exited with code 128'],
+    [129, 'Process exited with code 129 (killed by signal 1)'],
+    [143, 'Process exited with code 143 (killed by SIGTERM)'],
+    [193, 'Process exited with code 193'],
+  ])('describes exit code %i', (exitCode, description) => {
+    expect(describeProcessExit(exitCode)).toBe(description)
+  })
+
   it('reads the traceback from stdout when stderr is empty', () => {
     const { error } = processCodeFailure({ stdout: PYTHON_TRACEBACK, stderr: '', exitCode: 1 })
 
 
@@ -14,12 +14,47 @@ import type { SandboxCodeResult, SandboxCommandResult } from '@/lib/execution/re
 const ERROR_HEADLINE =
   /^(?:\[(?:[A-Za-z_$][\w.$]*)?(?:Error|Exception)|\[?[A-Za-z_$][\w.$]* \[[\w.$-]+\]|[A-Za-z_$][\w.$]*):(?:\s|$)/
 
+const SIGNAL_NAMES: Readonly<Record<number, string>> = {
+  6: 'SIGABRT',
+  9: 'SIGKILL',
+  11: 'SIGSEGV',
+  15: 'SIGTERM',
+}
+
+/**
+ * `Process exited with code N`, naming the signal behind a code above 128. A killed process often
+ * printed only a warning first, and that warning must not read as the reason it failed; SIGKILL
+ * (137) is usually the out-of-memory killer.
+ */
+export function describeProcessExit(exitCode: number): string {
+  const described = `Process exited with code ${exitCode}`
+  const signal = killingSignal(exitCode)
+  if (signal === undefined) return described
+  const name = SIGNAL_NAMES[signal] ?? `signal ${signal}`
+  return `${described} (killed by ${name}${signal === 9 ? ', usually out of memory' : ''})`
+}
+
+/** The signal a shell's `128 + n` exit code reports, if the code is one. */
+function killingSignal(exitCode: number): number | undefined {
+  return exitCode > 128 && exitCode <= 128 + 64 ? exitCode - 128 : undefined
+}
+
 /**
  * Converts a failed code command into a code result, naming the error from the
- * last error headline of the traceback (stderr, else stdout).
+ * last error headline of the traceback (stderr, else stdout). A process a signal
+ * killed raised nothing: anything it printed (a warning) is not the cause, so the
+ * signal names the error and the output stays as the traceback.
  */
 export function processCodeFailure(result: SandboxCommandResult): SandboxCodeResult {
   const traceback = result.stderr || result.stdout
+  if (killingSignal(result.exitCode) !== undefined) {
+    return {
+      text: '',
+      stdout: result.stdout,
+      stderr: result.stderr,
+      error: { name: 'Error', value: describeProcessExit(result.exitCode), traceback },
+    }
+  }
   const headline = traceback
     .split('\n')
     .reverse()
 
@@ -1261,6 +1261,18 @@ describe.each(PROVIDERS)('sandbox conformance [%s]', (provider) => {
     })
   })
 
+  it("leads a killed command's error with its signal, not the warning it printed first", async () => {
+    const warning = 'Warning: You are sending unauthenticated requests to the HF Hub.'
+    stubShellCommand(provider, provider === 'daytona' ? warning : '', warning, 137)
+
+    const res = await executeShellInSandbox({ code: 'python train.py', envs: {}, timeoutMs: 1000 })
+
+    expect(res.error).toBe(
+      `Process exited with code 137 (killed by SIGKILL, usually out of memory): ${warning}`
+    )
+    expect(res.stdout).toContain(warning)
+  })
+
   it('terminates shell execution when streamed process output exceeds the byte budget', async () => {
     const oversized = 'x'.repeat(MAX_SANDBOX_PROCESS_OUTPUT_BYTES + 1)
     if (provider === 'e2b') {
 
@@ -11,6 +11,7 @@ import {
 import { recordSandboxTeardownFailure } from '@/lib/core/execution-limits/metrics'
 import { buildJavaScriptRuntimeBindingsSource } from '@/lib/execution/code-placeholders/javascript-runtime'
 import { SANDBOX_SYSTEM_PATH } from '@/lib/execution/remote-sandbox/cli-tools.server'
+import { describeProcessExit } from '@/lib/execution/remote-sandbox/code-failure'
 import {
   type CreatedSandbox,
   createSandbox,
@@ -1152,8 +1153,10 @@ async function executeShellInSandboxWithinBudget(
     if (result.exitCode !== 0) {
       // Daytona merges both streams into stdout (stderr is always empty), so fall
       // back to stdout for the real command output before the generic message.
-      const errorMessage =
-        result.stderr || result.stdout || `Process exited with code ${result.exitCode}`
+      const output = result.stderr || result.stdout
+      const errorMessage = output
+        ? `${describeProcessExit(result.exitCode)}: ${output}`
+        : describeProcessExit(result.exitCode)
       logger.error('Sandbox shell execution error', {
         sandboxId,
         exitCode: result.exitCode,