fix(pi): size the sandbox to the run's own execution timeout

The Pi sandbox lifetime was a global constant while the execution timeout is
per-plan and per-mode, varying 18x (a free sync run gets 5 minutes, an async
run 90). Every Pi sandbox asked E2B for the same sub-hour ceiling, so a
five-minute run whose web process died left a sandbox billing for an hour.
PI_SANDBOX_LIFETIME_MS could not close the gap: its floor is 31 minutes.

resolvePiRunLifetimeMs lowers the provider ceiling to whatever the run's own
deadline leaves, read from the signal that enforces it. Untimed runs and
Daytona are unchanged, so no path gets a longer lifetime than before.

The turn cap had to move with it. PI_TIMEOUT_MS reserved the clone and both
finalize budgets out of the ceiling as a module constant; leaving it there
while shrinking the lifetime would re-open the exact bug its docs describe —
the sandbox dying first, taking the agent's finished work with it unpushed.
It is now resolvePiTimeoutMs(lifetimeMs), and each backend resolves the
lifetime once and feeds both, so the two cannot disagree.

Two things this surfaced:

Babysit had to read context.signal, not the cancellation signal it uses
everywhere else. createCancellationSignal returns a fresh controller that
only forwards aborts, so the deadline lookup answers "unknown" through it and
would have silently left the longest-lived mode on the ceiling. Covered by a
test that fails against the wrong signal.

The E2B adapter tested lifetimeMs for truthiness, so a run resolving to zero
would have had the key dropped and been handed the SDK's five-minute default
- longer than it asked for, on the run least entitled to it.

Options precede the callback in withPiSandbox so that adding one did not
re-indent every caller's sandbox body.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: icecrasher321

apps/sim/executor/handlers/pi/babysit-backend.test.ts

@@ -59,7 +59,7 @@ vi.mock('@/executor/handlers/pi/babysit-github', async (importOriginal) => {
   }
 })
 
-import { getMaxExecutionTimeout } from '@/lib/core/execution-limits'
+import { createTimeoutAbortController, getMaxExecutionTimeout } from '@/lib/core/execution-limits'
 import {
   resolveBabysitExecutionBudgetMs,
   runBabysitPiWithOptions,
@@ -283,6 +283,37 @@ describe('runBabysitPiWithOptions', () => {
     expect(mockWithPiSandbox).not.toHaveBeenCalled()
   })
 
+  it("creates its sandbox against the execution's deadline, not the provider ceiling", async () => {
+    mockFetchSnapshot.mockResolvedValue(snapshot)
+    mockFetchThreads.mockResolvedValue({
+      actionable: [],
+      skipped: [],
+      totalUnresolved: 0,
+      latestReview: null,
+    })
+    mockFetchChecks.mockResolvedValue(greenChecks)
+    const { runner } = makeRunner({})
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
+
+    // Babysit wraps `context.signal` in its own cancellation controller, and the
+    // deadline is recorded against the executor's signal alone. Resolving the
+    // lifetime from that wrapper answers "unknown" and silently falls back to the
+    // provider ceiling — the run still succeeds, it just over-reserves the
+    // sandbox. This is the longest-lived Pi mode, so that regression matters most
+    // here and is invisible without an assertion.
+    const timeout = createTimeoutAbortController(6 * 60 * 1000)
+    await runBabysitPiWithOptions(
+      params(),
+      { onEvent: vi.fn(), signal: timeout.signal },
+      { roundWaitMs: 0 }
+    )
+
+    const [{ lifetimeMs }] = mockWithPiSandbox.mock.calls[0]
+    expect(lifetimeMs).toBeLessThanOrEqual(6 * 60 * 1000)
+    expect(lifetimeMs).toBeGreaterThan(5 * 60 * 1000)
+    timeout.cleanup()
+  })
+
   it('requests the initial review and waits without consuming a round when the PR starts clean', async () => {
     mockFetchSnapshot.mockResolvedValue(snapshot)
     mockFetchThreads.mockResolvedValue({
@@ -293,7 +324,7 @@ describe('runBabysitPiWithOptions', () => {
     })
     mockFetchChecks.mockResolvedValue(greenChecks)
     const { runner } = makeRunner({})
-    mockWithPiSandbox.mockImplementation(async (callback) => callback(runner))
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
 
     const result = await runBabysitPiWithOptions(params(), { onEvent: vi.fn() }, { roundWaitMs: 0 })
 
@@ -325,7 +356,7 @@ describe('runBabysitPiWithOptions', () => {
     const { runner } = makeRunner({
       cloneResult: commandResult('', 'clone failed', 1),
     })
-    mockWithPiSandbox.mockImplementation(async (callback) => callback(runner))
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
 
     const result = await runBabysitPiWithOptions(params(), { onEvent: vi.fn() })
 
@@ -348,7 +379,7 @@ describe('runBabysitPiWithOptions', () => {
     })
     mockFetchChecks.mockResolvedValue(greenChecks)
     const { runner } = makeRunner({})
-    mockWithPiSandbox.mockImplementation(async (callback) => callback(runner))
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
 
     const result = await runBabysitPiWithOptions(
       params({ executionBudgetMs: 2 * 60 * 1000 }),
@@ -375,7 +406,7 @@ describe('runBabysitPiWithOptions', () => {
     })
     mockFetchChecks.mockResolvedValue(greenChecks)
     const { runner } = makeRunner({})
-    mockWithPiSandbox.mockImplementation(async (callback) => callback(runner))
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
 
     const result = await runBabysitPiWithOptions(params(), { onEvent: vi.fn() }, { roundWaitMs: 0 })
 
@@ -409,7 +440,7 @@ describe('runBabysitPiWithOptions', () => {
       contextRequirements: new Map(failures.map((check) => [check.key, true])),
     })
     const { runner, runCalls } = makeRunner({})
-    mockWithPiSandbox.mockImplementation(async (callback) => callback(runner))
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
 
     const result = await runBabysitPiWithOptions(params(), { onEvent: vi.fn() })
 
@@ -489,7 +520,7 @@ describe('runBabysitPiWithOptions', () => {
         throw new Error(`Unexpected read ${path}`)
       }),
     }
-    mockWithPiSandbox.mockImplementation(async (callback) => callback(runner))
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
 
     const result = await runBabysitPiWithOptions(
       params(),
@@ -543,7 +574,7 @@ describe('runBabysitPiWithOptions', () => {
     })
     mockFetchChecks.mockResolvedValue(greenChecks)
     const { runner, runCalls } = makeRunner({})
-    mockWithPiSandbox.mockImplementation(async (callback) => callback(runner))
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
 
     await runBabysitPiWithOptions(params(), { onEvent: vi.fn() })
 
@@ -605,7 +636,7 @@ describe('runBabysitPiWithOptions', () => {
       roundFile: JSON.stringify({ threads: [] }),
       diff: ['round-one-diff', 'round-two-diff'],
     })
-    mockWithPiSandbox.mockImplementation(async (callback) => callback(runner))
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
 
     const result = await runBabysitPiWithOptions(
       params({ reviewMentions: ['@review-bot'] }),
@@ -641,7 +672,7 @@ describe('runBabysitPiWithOptions', () => {
     const { runner, runCalls } = makeRunner({
       prepareStdout: `__CUMULATIVE_CHANGED__=.github/workflows/ci.yml\n__CUMULATIVE_DIFF_BYTES__=20\n__CHANGED__=.github/workflows/ci.yml\n__NEW_SHA__=${NEW_SHA}\n__NEEDS_PUSH__=1\n`,
     })
-    mockWithPiSandbox.mockImplementation(async (callback) => callback(runner))
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
 
     const result = await runBabysitPiWithOptions(params(), { onEvent: vi.fn() })
 
@@ -671,7 +702,7 @@ describe('runBabysitPiWithOptions', () => {
     const { runner, runCalls } = makeRunner({
       prepareStdout: `__CUMULATIVE_CHANGED__=${unicodePath}\n__CUMULATIVE_DIFF_BYTES__=20\n__CHANGED__=${unicodePath}\n__NEW_SHA__=${NEW_SHA}\n__NEEDS_PUSH__=1\n`,
     })
-    mockWithPiSandbox.mockImplementation(async (callback) => callback(runner))
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
 
     const result = await runBabysitPiWithOptions(params(), { onEvent: vi.fn() })
 
@@ -701,7 +732,7 @@ describe('runBabysitPiWithOptions', () => {
     const { runner, runCalls } = makeRunner({
       prepareStdout: `__CUMULATIVE_CHANGED__=${quotedPath}\n__CUMULATIVE_DIFF_BYTES__=20\n__CHANGED__=${quotedPath}\n__NEW_SHA__=${NEW_SHA}\n__NEEDS_PUSH__=1\n`,
     })
-    mockWithPiSandbox.mockImplementation(async (callback) => callback(runner))
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
 
     const result = await runBabysitPiWithOptions(params(), { onEvent: vi.fn() })
 
@@ -721,7 +752,7 @@ describe('runBabysitPiWithOptions', () => {
     const { runner } = makeRunner({
       pushResult: commandResult('', 'rejected by remote', 1),
     })
-    mockWithPiSandbox.mockImplementation(async (callback) => callback(runner))
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
 
     const result = await runBabysitPiWithOptions(params(), { onEvent: vi.fn() })
 
@@ -747,7 +778,7 @@ describe('runBabysitPiWithOptions', () => {
     const { runner, runCalls } = makeRunner({
       prepareStdout: '__NEEDS_PUSH__=1\n',
     })
-    mockWithPiSandbox.mockImplementation(async (callback) => callback(runner))
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
 
     const result = await runBabysitPiWithOptions(params(), { onEvent: vi.fn() })
 
@@ -772,7 +803,7 @@ describe('runBabysitPiWithOptions', () => {
     })
     mockFetchChecks.mockResolvedValue(greenChecks)
     const { runner, runCalls } = makeRunner({})
-    mockWithPiSandbox.mockImplementation(async (callback) => callback(runner))
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
 
     const result = await runBabysitPiWithOptions(params(), { onEvent: vi.fn() })
 
@@ -814,7 +845,7 @@ describe('runBabysitPiWithOptions', () => {
     })
     mockFetchChecks.mockResolvedValueOnce(pendingChecks).mockResolvedValueOnce(greenChecks)
     const { runner, runCalls } = makeRunner({})
-    mockWithPiSandbox.mockImplementation(async (callback) => callback(runner))
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
 
     const result = await runBabysitPiWithOptions(
       params({ maxRounds: 1 }),
@@ -846,7 +877,7 @@ describe('runBabysitPiWithOptions', () => {
       awaitingConfirmation: true,
     })
     const { runner } = makeRunner({})
-    mockWithPiSandbox.mockImplementation(async (callback) => callback(runner))
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
 
     const result = await runBabysitPiWithOptions(
       params(),
@@ -878,7 +909,7 @@ describe('runBabysitPiWithOptions', () => {
     })
     mockFetchChecks.mockResolvedValue(noChecksGreen)
     const { runner } = makeRunner({})
-    mockWithPiSandbox.mockImplementation(async (callback) => callback(runner))
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
 
     const result = await runBabysitPiWithOptions(
       params({ reviewMentions: ['@review-bot'] }),
@@ -910,7 +941,7 @@ describe('runBabysitPiWithOptions', () => {
     })
     mockFetchChecks.mockResolvedValue(noChecksGreen)
     const { runner } = makeRunner({})
-    mockWithPiSandbox.mockImplementation(async (callback) => callback(runner))
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
 
     const result = await runBabysitPiWithOptions(
       params(),
@@ -942,7 +973,7 @@ describe('runBabysitPiWithOptions', () => {
     })
     mockFetchChecks.mockResolvedValue(greenChecks)
     const { runner } = makeRunner({ roundFile: 'not json' })
-    mockWithPiSandbox.mockImplementation(async (callback) => callback(runner))
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
 
     const result = await runBabysitPiWithOptions(
       params(),
@@ -998,7 +1029,7 @@ describe('runBabysitPiWithOptions', () => {
       failures: ['@missing-bot'],
     })
     const { runner } = makeRunner({})
-    mockWithPiSandbox.mockImplementation(async (callback) => callback(runner))
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
 
     const result = await runBabysitPiWithOptions(
       params({ reviewMentions: ['@review-bot', '@missing-bot'] }),
@@ -1040,7 +1071,7 @@ describe('runBabysitPiWithOptions', () => {
         ],
       }),
     })
-    mockWithPiSandbox.mockImplementation(async (callback) => callback(runner))
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
 
     const result = await runBabysitPiWithOptions(params(), { onEvent: vi.fn() }, { roundWaitMs: 0 })
 
@@ -1076,7 +1107,7 @@ describe('runBabysitPiWithOptions', () => {
       prepareStdout: '__NO_CHANGES__=1\n',
       roundFile: JSON.stringify({ threads: [] }),
     })
-    mockWithPiSandbox.mockImplementation(async (callback) => callback(runner))
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
 
     const result = await runBabysitPiWithOptions(params(), { onEvent: vi.fn() }, { roundWaitMs: 0 })
 
@@ -1126,7 +1157,7 @@ describe('runBabysitPiWithOptions', () => {
         ],
       }),
     })
-    mockWithPiSandbox.mockImplementation(async (callback) => callback(runner))
+    mockWithPiSandbox.mockImplementation(async (_options, callback) => callback(runner))
 
     const result = await runBabysitPiWithOptions(
       params(),

apps/sim/executor/handlers/pi/babysit-backend.ts

@@ -11,7 +11,10 @@ import { getMaxExecutionTimeout } from '@/lib/core/execution-limits'
 import { sleepUntilAborted } from '@/lib/data-drains/destinations/utils'
 import { isExecutionCancelled, isRedisCancellationEnabled } from '@/lib/execution/cancellation'
 import { type PiSandboxRunner, withPiSandbox } from '@/lib/execution/remote-sandbox'
-import { resolvePiSandboxLifetimeMs } from '@/lib/execution/remote-sandbox/pi-lifetime'
+import {
+  resolvePiRunLifetimeMs,
+  resolvePiSandboxLifetimeMs,
+} from '@/lib/execution/remote-sandbox/pi-lifetime'
 import {
   assertBabysitPinned,
   type BabysitCheck,
@@ -50,11 +53,11 @@ import {
   GIT_CONFIG_DIGEST_MARKER,
   MAX_DIFF_BYTES,
   MIN_PI_TIMEOUT_MS,
-  PI_TIMEOUT_MS,
   PROMPT_PATH,
   PUSH_ERROR_MAX,
   REPO_DIR,
   raceAbort,
+  resolvePiTimeoutMs,
   scrubGitSecrets,
 } from '@/executor/handlers/pi/cloud-shared'
 import { buildPiPrompt } from '@/executor/handlers/pi/context'
@@ -814,7 +817,19 @@ export async function runBabysitPiWithOptions(
       landed: false,
     }
 
-    return await withPiSandbox(async (runner) => {
+    // Resolved here rather than at the top of the run: the GitHub reads above
+    // already spent part of the execution's budget, and reading it at the moment
+    // of creation is what keeps the sandbox from outliving the run by that much.
+    //
+    // Deliberately `context.signal`, not the `signal` every other call in this
+    // function uses. The deadline is recorded against the signal the executor
+    // created; `createCancellationSignal` returns a fresh controller that only
+    // forwards aborts, so asking it for a deadline answers "unknown" and would
+    // silently leave the longest-lived Pi mode on the provider ceiling.
+    const lifetimeMs = resolvePiRunLifetimeMs(context.signal)
+    const piTimeoutMs = resolvePiTimeoutMs(lifetimeMs)
+
+    return await withPiSandbox({ lifetimeMs }, async (runner) => {
       const clone = await raceAbort(
         runner.run(BABYSIT_CLONE_SCRIPT, {
           envs: {
@@ -969,7 +984,7 @@ export async function runBabysitPiWithOptions(
         const round = buildRoundPrompt(params, latestThreads!, promptChecks, diagnostics, secrets)
         progress.notes.push(...round.notes)
         const agentTimeoutMs = Math.min(
-          PI_TIMEOUT_MS,
+          piTimeoutMs,
           lifetime - (Date.now() - startedAt) - ROUND_FINALIZATION_RESERVE_MS
         )
         if (agentTimeoutMs < MIN_ROUND_BUDGET_MS) {

apps/sim/executor/handlers/pi/cloud-backend.test.ts

@@ -26,6 +26,9 @@ vi.mock('@/lib/execution/remote-sandbox', () => ({
 }))
 vi.mock('@/lib/execution/remote-sandbox/pi-lifetime', () => ({
   resolvePiSandboxLifetimeMs: () => 40 * 60 * 1000,
+  // Same ceiling: these cases run without an execution deadline, where the run
+  // lifetime is the ceiling because there is nothing shorter to narrow to.
+  resolvePiRunLifetimeMs: () => 40 * 60 * 1000,
 }))
 vi.mock('@/executor/handlers/pi/babysit-backend', () => ({
   runBabysitPi: mockRunBabysit,
@@ -64,7 +67,7 @@ function baseParams(overrides: Partial<PiCloudRunParams> = {}): PiCloudRunParams
 describe('runCloudPi', () => {
   beforeEach(() => {
     vi.clearAllMocks()
-    mockWithPiSandbox.mockImplementation((fn: (runner: unknown) => unknown) =>
+    mockWithPiSandbox.mockImplementation((_options: unknown, fn: (runner: unknown) => unknown) =>
       fn({ run: mockRun, readFile: mockReadFile, writeFile: mockWriteFile })
     )
     mockProviderEnvVar.mockReturnValue('ANTHROPIC_API_KEY')

apps/sim/executor/handlers/pi/cloud-backend.ts

@@ -23,7 +23,10 @@ import { generateShortId } from '@sim/utils/id'
 import { truncate } from '@sim/utils/string'
 import { getMaxExecutionTimeout, getRemainingExecutionMs } from '@/lib/core/execution-limits'
 import { withPiSandbox } from '@/lib/execution/remote-sandbox'
-import { resolvePiSandboxLifetimeMs } from '@/lib/execution/remote-sandbox/pi-lifetime'
+import {
+  resolvePiRunLifetimeMs,
+  resolvePiSandboxLifetimeMs,
+} from '@/lib/execution/remote-sandbox/pi-lifetime'
 import { runBabysitPi } from '@/executor/handlers/pi/babysit-backend'
 import type { PiBackendRun, PiCloudRunParams, PiRunResult } from '@/executor/handlers/pi/backend'
 import {
@@ -35,14 +38,14 @@ import {
   FINALIZE_TIMEOUT_MS,
   GIT_CONFIG_DIGEST_LINE,
   MAX_DIFF_BYTES,
-  PI_TIMEOUT_MS,
   PREPARE_SCRIPT,
   PROMPT_PATH,
   PUSH_ERR_PATH,
   PUSH_ERROR_MAX,
   PUSH_SCRIPT,
   REPO_DIR,
   raceAbort,
+  resolvePiTimeoutMs,
   scrubGitSecrets,
 } from '@/executor/handlers/pi/cloud-shared'
 import { buildPiPrompt } from '@/executor/handlers/pi/context'
@@ -263,7 +266,12 @@ export const runCloudPi: PiBackendRun<PiCloudRunParams> = async (params, context
   const totals = createPiTotals()
   const thinking = mapThinkingLevel(params.thinkingLevel) ?? 'medium'
 
-  const created = await withPiSandbox<CreatePrPhaseResult>(async (runner) => {
+  // Resolved once and shared: the sandbox is created with this lifetime and the
+  // agent turn reserves its finalize budget against the same number.
+  const lifetimeMs = resolvePiRunLifetimeMs(context.signal)
+  const piTimeoutMs = resolvePiTimeoutMs(lifetimeMs)
+
+  const created = await withPiSandbox<CreatePrPhaseResult>({ lifetimeMs }, async (runner) => {
     try {
       const clone = await raceAbort(
         runner.run(CLONE_SCRIPT, {
@@ -331,7 +339,7 @@ export const runCloudPi: PiBackendRun<PiCloudRunParams> = async (params, context
                 }
               : {}),
           },
-          timeoutMs: PI_TIMEOUT_MS,
+          timeoutMs: piTimeoutMs,
           onStdout: handleChunk,
         }),
         context.signal

apps/sim/executor/handlers/pi/cloud-review-backend.test.ts

@@ -60,7 +60,7 @@ const mockModelRuntime = {
 }
 
 vi.mock('@/lib/execution/remote-sandbox', () => ({
-  withPiSandbox: (fn: (runner: unknown) => unknown) =>
+  withPiSandbox: (_options: unknown, fn: (runner: unknown) => unknown) =>
     fn({ run: mockRun, writeFile: mockWriteFile }),
 }))
 vi.mock('@/tools', () => ({ executeTool: mockExecuteTool }))