@@ -199,24 +199,29 @@ describe('processCodeFailure', () => {
     expect(error).toEqual({ name, value, traceback: stderr })
   })
 
-  it('names the signal for a process killed after printing only a warning', () => {
+  it('keeps the printed headline and adds the signal exit code beside it', () => {
     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)',
+      name: 'Warning',
+      value:
+        'You are sending unauthenticated requests to the HF Hub. [Process exited with code 137 (the exit code of SIGKILL, usually out of memory)]',
+      traceback: warning,
+    })
+    expect(exited.error).toEqual({
+      name: 'Warning',
+      value: 'You are sending unauthenticated requests to the HF Hub.',
       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)'],
+    [129, 'Process exited with code 129 (the exit code of signal 1)'],
+    [143, 'Process exited with code 143 (the exit code of SIGTERM)'],
     [193, 'Process exited with code 193'],
   ])('describes exit code %i', (exitCode, description) => {
     expect(describeProcessExit(exitCode)).toBe(description)
 
@@ -22,39 +22,32 @@ const SIGNAL_NAMES: Readonly<Record<number, string>> = {
 }
 
 /**
- * `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.
+ * `Process exited with code N`, naming the signal a code above 128 stands for. A process a signal
+ * killed often printed only a warning first, so the code must be visible beside whatever it
+ * printed. The code alone cannot prove a kill (a program may exit 137 itself), so it is described
+ * as the signal's code; SIGKILL's (137) usually means 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' : ''})`
+  const note = signalCodeNote(exitCode)
+  return `Process exited with code ${exitCode}${note ? ` (${note})` : ''}`
 }
 
-/** 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
+/** What a shell's `128 + n` exit code stands for, if the code is one. */
+function signalCodeNote(exitCode: number): string | undefined {
+  if (exitCode <= 128 || exitCode > 128 + 64) return undefined
+  const signal = exitCode - 128
+  const name = SIGNAL_NAMES[signal] ?? `signal ${signal}`
+  return `the exit code of ${name}${signal === 9 ? ', usually out of memory' : ''}`
 }
 
 /**
  * Converts a failed code command into a code result, naming the error from the
- * 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.
+ * last error headline of the traceback (stderr, else stdout). A signal's exit code
+ * is appended to the value, since a killed process's last printed line (often a
+ * warning) is not necessarily why it stopped.
  */
 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()
@@ -66,10 +59,13 @@ export function processCodeFailure(result: SandboxCommandResult): SandboxCodeRes
   const separator = errorLine?.indexOf(':') ?? -1
   const parsedErrorLine = errorLine ?? ''
   const name = separator > 0 ? parsedErrorLine.slice(0, separator) : 'Error'
-  const value =
+  const headlineValue =
     separator > 0
       ? parsedErrorLine.slice(separator + 1).trim()
       : parsedErrorLine || 'Execution failed'
+  const value = signalCodeNote(result.exitCode)
+    ? `${headlineValue} [${describeProcessExit(result.exitCode)}]`
+    : headlineValue
   return {
     text: '',
     stdout: result.stdout,
 
@@ -1261,14 +1261,14 @@ describe.each(PROVIDERS)('sandbox conformance [%s]', (provider) => {
     })
   })
 
-  it("leads a killed command's error with its signal, not the warning it printed first", async () => {
+  it("leads a failed command's error with its exit code and the signal it stands for", 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}`
+      `Process exited with code 137 (the exit code of SIGKILL, usually out of memory): ${warning}`
     )
     expect(res.stdout).toContain(warning)
   })