@@ -613,6 +613,36 @@ describe('E2B session recovery', () => {
     expect(stopCommand).toHaveBeenCalledOnce()
     expect(killSandbox).not.toHaveBeenCalled()
   })
+
+  it('returns what a session command printed before its own timeout stopped it', async () => {
+    runCommand.mockImplementation(
+      async (
+        _command: string,
+        options: { onStdout?: (chunk: string) => void; onStderr?: (chunk: string) => void }
+      ) => {
+        options.onStdout?.('rendered 1 of 3\n')
+        options.onStderr?.('slow frame\n')
+        options.onStdout?.('rendered 2 of 3\n')
+        return {
+          pid: 7,
+          wait: async () => {
+            throw Object.assign(
+              new Error("deadline_exceeded: This error is likely due to exceeding 'timeoutMs'"),
+              { name: 'TimeoutError' }
+            )
+          },
+        }
+      }
+    )
+    const sandbox = await sessionSandbox('reconnected')
+    const result = await sandbox?.runCommand('render', { timeoutMs: 1000 })
+    expect(result).toMatchObject({
+      timedOut: true,
+      exitCode: 124,
+      stdout: 'rendered 1 of 3\nrendered 2 of 3\n',
+      stderr: 'slow frame\n',
+    })
+  })
 })
 
 describe('E2B session lease', () => {
 
@@ -373,6 +373,14 @@ export async function stopE2BSessionProcess(
   if (sandbox) await stopSessionCommand(sandbox, process.id, signal)
 }
 
+/** Joins what the stream callbacks observed with the streams the SDK returned, without repeating either. */
+function mergeObservedOutput(observed: string, returned: string): string {
+  if (!observed) return returned
+  if (!returned || observed.endsWith(returned)) return observed
+  if (returned.startsWith(observed)) return returned
+  return observed + returned
+}
+
 class E2BSandboxHandle implements SandboxHandle {
   private killed = false
   private killPromise: Promise<void> | null = null
@@ -676,12 +684,6 @@ class E2BSandboxHandle implements SandboxHandle {
         // process handle because `background: true` is fixed above.
         result = started
       }
-      const mergeObservedOutput = (observed: string, returned: string): string => {
-        if (!observed) return returned
-        if (!returned || observed.endsWith(returned)) return observed
-        if (returned.startsWith(observed)) return returned
-        return observed + returned
-      }
       const stdout = mergeObservedOutput(observedStdout, result.stdout ?? '')
       const stderr = mergeObservedOutput(observedStderr, result.stderr ?? '')
       assertSandboxProcessOutputWithinLimit([stdout, stderr], options.maxOutputBytes)
@@ -727,16 +729,21 @@ class E2BSandboxHandle implements SandboxHandle {
       )
       const tailIfStreamed = (value: string | undefined, retain: boolean) =>
         retain || value === undefined ? value : tailStreamedSandboxOutput(value)
-      const failureStdout = tailIfStreamed(failure.stdout, retainStdout)
-      const failureStderr = tailIfStreamed(failure.stderr, retainStderr)
       if (isE2BExecutionTimeout(error)) {
+        // The SDK's timeout error carries no streams; the callbacks observed the run's output.
+        const stdout = mergeObservedOutput(observedStdout, failure.stdout ?? '')
+        const stderr = mergeObservedOutput(observedStderr, failure.stderr ?? '')
         return {
-          stdout: failureStdout ?? '',
-          stderr: failureStderr ?? failure.message ?? '',
+          stdout: retainStdout ? stdout : tailStreamedSandboxOutput(stdout),
+          stderr:
+            (retainStderr ? stderr : tailStreamedSandboxOutput(stderr)) ||
+            `Command timed out after ${options.timeoutMs}ms`,
           exitCode: 124,
           timedOut: true,
         }
       }
+      const failureStdout = tailIfStreamed(failure.stdout, retainStdout)
+      const failureStderr = tailIfStreamed(failure.stderr, retainStderr)
       return {
         stdout: failureStdout ?? '',
         stderr: failureStderr ?? failure.message ?? getErrorMessage(error),
 
@@ -9,6 +9,7 @@ import {
   isTimeoutAbortReason,
 } from '@/lib/core/execution-limits'
 import { recordSandboxTeardownFailure } from '@/lib/core/execution-limits/metrics'
+import { withinDeadline } from '@/lib/core/utils/deadline'
 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'
@@ -65,6 +66,10 @@ import {
   recordSessionFileInput,
 } from '@/lib/execution/remote-sandbox/session-file-provenance'
 import { withSandboxSessionLock } from '@/lib/execution/remote-sandbox/session-lock'
+import {
+  SandboxExecutionTimeoutError,
+  sandboxTimeoutProgress,
+} from '@/lib/execution/remote-sandbox/timeout'
 import type {
   CreateSandboxOptions,
   SandboxCodeResult,
@@ -258,6 +263,36 @@ function throwIfSandboxTimedOut(result: { timedOut?: boolean }): void {
   if (result.timedOut) throw new DOMException('timeout', 'AbortError')
 }
 
+/** Bounds the output-directory listing a timeout report adds; a slow listing reports no files. */
+const TIMED_OUT_OUTPUT_LISTING_MS = 3_000
+
+/**
+ * A workbench run stopped by its own timeout reports what it produced, because the workbench and
+ * its files outlive the call and the next call can resume from them. A one-shot sandbox is torn
+ * down with everything in it, so it keeps the plain timeout.
+ */
+async function throwIfRunTimedOut(
+  result: { timedOut?: boolean },
+  streams: Array<string | undefined>,
+  run: {
+    sandbox: SandboxHandle
+    lease: SandboxLease
+    outputSandboxDir: string | undefined
+    timeoutMs: number
+  }
+): Promise<void> {
+  if (!result.timedOut) return
+  if (!run.lease.session) throw new DOMException('timeout', 'AbortError')
+  const { outputSandboxDir, sandbox } = run
+  const listed = outputSandboxDir
+    ? await withinDeadline(
+        () => sandbox.listFiles(outputSandboxDir, { depth: SANDBOX_OUTPUT_DIR_MAX_DEPTH }),
+        Date.now() + TIMED_OUT_OUTPUT_LISTING_MS
+      ).catch(() => [])
+    : []
+  throw new SandboxExecutionTimeoutError(sandboxTimeoutProgress(streams, run.timeoutMs, listed))
+}
+
 function bindSandboxAbort(
   sandbox: SandboxHandle,
   provider: SandboxProviderId,
@@ -969,10 +1004,11 @@ async function executeInSandboxWithinBudget(
       Object.keys(privateInputFiles.environment).length > 0
 
     let execution: SandboxCodeResult
+    const runTimeoutMs = codeBudgetMs(req, signal)
     try {
       const endRun = phases.start('run')
       execution = await sandbox.runCode(code, {
-        timeoutMs: codeBudgetMs(req, signal),
+        timeoutMs: runTimeoutMs,
         javascriptPreload: buildJavaScriptRuntimeBindingsSource(req.runtimeBindings ?? []),
         maxOutputBytes: MAX_SANDBOX_PROCESS_OUTPUT_BYTES,
         signal,
@@ -984,7 +1020,12 @@ async function executeInSandboxWithinBudget(
       throw error
     }
     throwIfAborted(signal)
-    throwIfSandboxTimedOut(execution)
+    await throwIfRunTimedOut(execution, [execution.text, execution.stdout, execution.stderr], {
+      sandbox,
+      lease,
+      outputSandboxDir: req.outputSandboxDir,
+      timeoutMs: runTimeoutMs,
+    })
 
     if (execution.error) {
       const errorMessage = `${execution.error.name}: ${execution.error.value}`
@@ -1166,6 +1207,7 @@ async function executeShellInSandboxWithinBudget(
     endPrepare()
 
     let result: SandboxCommandResult
+    const runTimeoutMs = codeBudgetMs(req, signal)
     try {
       const endRun = phases.start('run')
       result = await sandbox.runCommand(code, {
@@ -1177,7 +1219,7 @@ async function executeShellInSandboxWithinBudget(
           ...privateInputFiles.environment,
           ...(req.session && req.outputSandboxDir ? { SIM_OUTPUT_DIR: req.outputSandboxDir } : {}),
         },
-        timeoutMs: codeBudgetMs(req, signal),
+        timeoutMs: runTimeoutMs,
         maxOutputBytes: MAX_SANDBOX_PROCESS_OUTPUT_BYTES,
         signal,
         rootUser: !lease.session,
@@ -1189,7 +1231,12 @@ async function executeShellInSandboxWithinBudget(
       throw error
     }
     throwIfAborted(signal)
-    throwIfSandboxTimedOut(result)
+    await throwIfRunTimedOut(result, [result.stdout, result.stderr], {
+      sandbox,
+      lease,
+      outputSandboxDir: req.outputSandboxDir,
+      timeoutMs: runTimeoutMs,
+    })
 
     const stdout = [result.stdout, result.stderr].filter(Boolean).join('\n')
 
 
@@ -48,15 +48,16 @@ const STREAMED_OUTPUT_TRUNCATION_NOTE =
  */
 export function tailStreamedSandboxOutput(
   value: string | undefined,
-  limitBytes = MAX_SANDBOX_STREAMED_OUTPUT_TAIL_BYTES
+  limitBytes = MAX_SANDBOX_STREAMED_OUTPUT_TAIL_BYTES,
+  truncationNote = STREAMED_OUTPUT_TRUNCATION_NOTE
 ): string {
   if (!value) return ''
   const buffer = Buffer.from(value, 'utf8')
   if (buffer.length <= limitBytes) return value
 
   let start = buffer.length - limitBytes
   while (start < buffer.length && (buffer[start] & 0xc0) === 0x80) start += 1
-  return `${STREAMED_OUTPUT_TRUNCATION_NOTE}${buffer.subarray(start).toString('utf8')}`
+  return `${truncationNote}${buffer.subarray(start).toString('utf8')}`
 }
 
 /**
 
@@ -19,6 +19,7 @@ import type {
   SandboxCommandResult,
   SandboxHandle,
   SandboxProvider,
+  SandboxSessionRequest,
 } from '@/lib/execution/remote-sandbox/types'
 
 const { mockCreate, mockFindSessionSandbox, mockResolveWorkspaceSandbox } = vi.hoisted(() => ({
@@ -41,6 +42,7 @@ vi.mock('@/lib/core/execution-limits/metrics', () => ({
   recordSandboxProviderLimit: vi.fn(),
 }))
 
+import { isTimeoutAbortReason } from '@/lib/core/execution-limits'
 import {
   executeInSandbox,
   executeShellInSandbox,
@@ -56,6 +58,10 @@ import {
   recordSessionFileInput,
 } from '@/lib/execution/remote-sandbox/session-file-provenance'
 import { writeSessionSandboxFile } from '@/lib/execution/remote-sandbox/session-files'
+import {
+  MAX_SANDBOX_TIMEOUT_OUTPUT_TAIL_BYTES,
+  SandboxExecutionTimeoutError,
+} from '@/lib/execution/remote-sandbox/timeout'
 
 remoteSandboxProviderMockFns.mockResolveProvider.mockImplementation(
   (): SandboxProvider => ({
@@ -941,6 +947,122 @@ describe('session sandbox lease', () => {
     expect(calls.killed).toBe(false)
   })
 
+  describe('a workbench run stopped by its own timeout', () => {
+    const OUTPUT_DIR = '/tmp/sim/outputs/call-timeout'
+
+    async function timedOutRun(
+      kind: 'code' | 'shell',
+      streams: { stdout: string; stderr: string },
+      listFiles: SandboxHandle['listFiles'],
+      acceptOutputProvenance?: SandboxSessionRequest['acceptOutputProvenance']
+    ): Promise<unknown> {
+      const { handle } = fakeSandbox(`timeout-${kind}`)
+      mockFindSessionSandbox.mockResolvedValue(handle)
+      handle.runCode = async () => ({ text: '', ...streams, timedOut: true })
+      handle.runCommand = async () => ({ ...streams, exitCode: 124, timedOut: true })
+      handle.listFiles = listFiles
+      const request = {
+        ...CODE_REQUEST,
+        session: {
+          key: `timeout-${kind}`,
+          ...(acceptOutputProvenance ? { acceptOutputProvenance } : {}),
+        },
+        outputSandboxDir: OUTPUT_DIR,
+      }
+      return (
+        kind === 'code'
+          ? executeInSandbox(request)
+          : executeShellInSandbox({ ...request, envs: {} })
+      ).then(
+        () => {
+          throw new Error('Expected the run to time out')
+        },
+        (error: unknown) => error
+      )
+    }
+
+    it.each(['code', 'shell'] as const)(
+      'reports the %s output so far and the files already exported',
+      async (kind) => {
+        const error = await timedOutRun(
+          kind,
+          { stdout: 'rendered 1 of 3\nrendered 2 of 3', stderr: 'slow frame' },
+          async () => [
+            {
+              path: `${OUTPUT_DIR}/${SANDBOX_OUTPUT_DIR_SENTINEL}`,
+              relativePath: SANDBOX_OUTPUT_DIR_SENTINEL,
+              kind: 'file',
+              size: 0,
+            },
+            { path: `${OUTPUT_DIR}/frames`, relativePath: 'frames', kind: 'directory', size: 0 },
+            {
+              path: `${OUTPUT_DIR}/frames/2.png`,
+              relativePath: 'frames/2.png',
+              kind: 'file',
+              size: 9,
+            },
+            {
+              path: `${OUTPUT_DIR}/frames/1.png`,
+              relativePath: 'frames/1.png',
+              kind: 'file',
+              size: 9,
+            },
+          ]
+        )
+        expect(isTimeoutAbortReason(error)).toBe(true)
+        if (!(error instanceof SandboxExecutionTimeoutError)) throw error
+        expect(error.progress.output).toBe('rendered 1 of 3\nrendered 2 of 3\nslow frame')
+        expect(error.progress.outputFiles).toEqual([
+          `${OUTPUT_DIR}/frames/1.png`,
+          `${OUTPUT_DIR}/frames/2.png`,
+        ])
+        expect(error.progress.stoppedAfterMs).toBeGreaterThan(0)
+        expect(error.progress.stoppedAfterMs).toBeLessThanOrEqual(CODE_REQUEST.timeoutMs)
+      }
+    )
+
+    it.each([
+      ['fails', async () => Promise.reject(new Error('listing unavailable'))],
+      ['never answers', () => new Promise<never>(() => {})],
+    ] as const)('still reports the output when the file listing %s', async (_case, listFiles) => {
+      vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] })
+      try {
+        const pending = timedOutRun('shell', { stdout: 'step 1', stderr: '' }, listFiles)
+        await vi.runAllTimersAsync()
+        const error = await pending
+        if (!(error instanceof SandboxExecutionTimeoutError)) throw error
+        expect(error.progress.output).toBe('step 1')
+        expect(error.progress.outputFiles).toEqual([])
+      } finally {
+        vi.useRealTimers()
+      }
+    })
+
+    it('withholds the output when the workbench secret provenance is unavailable', async () => {
+      const error = await timedOutRun(
+        'shell',
+        { stdout: 'token=secret-value', stderr: '' },
+        async () => [],
+        async () => {
+          throw new Error('Workbench output withheld because its secret provenance is unavailable')
+        }
+      )
+      expect(error).not.toBeInstanceOf(SandboxExecutionTimeoutError)
+      expect(getErrorMessage(error)).not.toContain('secret-value')
+    })
+
+    it('keeps only the end of an output too large to return', async () => {
+      const lines = Array.from({ length: 20_000 }, (_, index) => `frame ${index}`).join('\n')
+      const error = await timedOutRun('shell', { stdout: lines, stderr: '' }, async () => [])
+      if (!(error instanceof SandboxExecutionTimeoutError)) throw error
+      expect(Buffer.byteLength(error.progress.output)).toBeLessThanOrEqual(
+        MAX_SANDBOX_TIMEOUT_OUTPUT_TAIL_BYTES + 64
+      )
+      expect(error.progress.output.endsWith('frame 19999')).toBe(true)
+      expect(error.progress.output.startsWith('[earlier output omitted]')).toBe(true)
+    })
+  })
+
   it('keeps the one-shot teardown when no session is requested', async () => {
     const { handle, calls } = fakeSandbox('sb-oneshot')
     mockCreate.mockResolvedValue(handle)