fix(pi): reserve both finalize budgets in the Pi command timeout

Create PR dispatches two commands at FINALIZE_TIMEOUT_MS, not one — the commit
and the push — so reserving a single budget left the push unbudgeted and the
worst case overshot the sandbox lifetime by exactly that amount. Losing the
sandbox during the push is the most expensive moment to lose it: the work is
committed and unpushed, which is the outcome the reserve exists to prevent.

The comment no longer claims more than the arithmetic delivers. What is reserved
is each command's timeout ceiling rather than its measured elapsed time, so this
is a budget that adds up, not a guarantee. Two other comments described Babysit
verifying the config digest in the present tense, when no mode verifies it yet.

Also drops the digest-line test: it asserted a string constant contains its own
substrings, while cloud-backend.test.ts already pins the property that matters —
the marker being the clone's last line, after the remote rewrite.

Author: cursoragent

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

@@ -6,28 +6,19 @@ import { PI_SANDBOX_MAX_LIFETIME_MS } from '@/lib/execution/remote-sandbox/pi-li
 import {
   CLONE_TIMEOUT_MS,
   FINALIZE_TIMEOUT_MS,
-  GIT_CONFIG_DIGEST_LINE,
-  GIT_CONFIG_DIGEST_MARKER,
   PI_TIMEOUT_MS,
 } from '@/executor/handlers/pi/cloud-shared'
 
 describe('PI_TIMEOUT_MS', () => {
-  it('leaves the host room to commit and push after the agent turn ends', () => {
+  it('reserves every command budget that brackets the agent turn', () => {
     // Capping at the bare sandbox lifetime would mean the sandbox always died
-    // first, taking the agent's finished work with it unpushed.
+    // first, taking the agent's finished work with it unpushed. Create PR runs
+    // three bracketing commands, and the commit and the push each get the full
+    // finalize budget — reserving only one of them leaves the push unbudgeted,
+    // which is exactly when losing the sandbox costs the most.
     expect(PI_TIMEOUT_MS).toBeLessThanOrEqual(
-      PI_SANDBOX_MAX_LIFETIME_MS - CLONE_TIMEOUT_MS - FINALIZE_TIMEOUT_MS
+      PI_SANDBOX_MAX_LIFETIME_MS - CLONE_TIMEOUT_MS - 2 * FINALIZE_TIMEOUT_MS
     )
     expect(PI_TIMEOUT_MS).toBeGreaterThan(0)
   })
 })
-
-describe('GIT_CONFIG_DIGEST_LINE', () => {
-  it('emits the marker a host parses, over the one config scope a root agent can write', () => {
-    expect(GIT_CONFIG_DIGEST_LINE).toContain(GIT_CONFIG_DIGEST_MARKER)
-    expect(GIT_CONFIG_DIGEST_LINE).toContain('.git/config')
-    // A worktree config is not always present, and its absence must not fail the clone.
-    expect(GIT_CONFIG_DIGEST_LINE).toContain('.git/config.worktree')
-    expect(GIT_CONFIG_DIGEST_LINE).toContain('2>/dev/null')
-  })
-})

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

@@ -19,33 +19,46 @@ export const FINALIZE_TIMEOUT_MS = 10 * 60 * 1000
 export const MAX_DIFF_BYTES = 200_000
 export const PUSH_ERROR_MAX = 1000
 
-/** Floor for {@link PI_TIMEOUT_MS}, so a very short configured lifetime still leaves a usable turn. */
+/**
+ * Floor for {@link PI_TIMEOUT_MS}. Only reachable by configuring a sandbox
+ * lifetime too short to hold the commands around the turn, in which case the run
+ * was going to be reaped either way; the floor keeps the turn non-zero rather
+ * than making it useful.
+ */
 const MIN_PI_TIMEOUT_MS = 60 * 1000
 
 /**
  * How long one Pi CLI invocation may run. The platform's max execution timeout
- * is longer than the sandbox lives, so without this a hung CLI would sit there
- * until E2B reaped the sandbox and surface as an opaque SDK error.
+ * outlives the sandbox, so without this a hung CLI would sit there until E2B
+ * reaped the sandbox and surface as an opaque SDK error.
+ *
+ * The reserve matters as much as the cap. The sandbox clock starts at create,
+ * and three commands bracket the agent turn: the clone before it, then the
+ * commit and the push after it, the last two sharing
+ * {@link FINALIZE_TIMEOUT_MS}. Capping at the bare lifetime would mean the
+ * sandbox always died first, taking the agent's finished work with it unpushed.
  *
- * The reserve matters as much as the cap: the sandbox clock starts at create,
- * and the clone runs before the agent while the commit and push run after it.
- * Capping at the bare lifetime would mean the sandbox always died first, taking
- * the agent's finished work with it unpushed. Reserving both surrounding command
- * budgets leaves the host time to finalize whatever the agent produced.
+ * What is reserved is each command's timeout ceiling, not its measured elapsed
+ * time — a clone takes seconds in practice — so this is a budget that adds up,
+ * not a guarantee that the sandbox outlives the run.
  */
 export const PI_TIMEOUT_MS = Math.min(
   getMaxExecutionTimeout(),
-  Math.max(resolvePiSandboxLifetimeMs() - CLONE_TIMEOUT_MS - FINALIZE_TIMEOUT_MS, MIN_PI_TIMEOUT_MS)
+  Math.max(
+    resolvePiSandboxLifetimeMs() - CLONE_TIMEOUT_MS - 2 * FINALIZE_TIMEOUT_MS,
+    MIN_PI_TIMEOUT_MS
+  )
 )
 
 /**
  * Marker carrying a digest of the cloned repository's git config. A clone script
  * emits it as its *last* line, after any `git remote set-url` rewrite — a digest
  * taken before that rewrite mismatches at push time and every push fails.
  *
- * Every mode that clones in order to push emits it; only Babysit re-verifies it
- * before pushing, because verification is not a pure tightening: a run that
- * legitimately writes repo-local config would fail its push.
+ * Every mode that clones in order to push emits it. No mode verifies it yet;
+ * Babysit will, and deliberately alone, because verification is not a pure
+ * tightening — a run that legitimately writes repo-local config would fail its
+ * push.
  */
 export const GIT_CONFIG_DIGEST_MARKER = '__GIT_CONFIG_DIGEST__='
 
@@ -84,8 +97,8 @@ if git diff --quiet "$BASE_SHA" HEAD; then echo "__NO_CHANGES__=1"; else echo "_
  * could send the token's userinfo to another host. Repository-local config —
  * the scope a root agent inside the checkout can actually write — still
  * rewrites the push URL, and stays open until a mode compares the
- * {@link GIT_CONFIG_DIGEST_MARKER} digest before pushing. Babysit does; Create
- * PR does not, and inherits the pre-existing exposure it always had.
+ * {@link GIT_CONFIG_DIGEST_MARKER} digest before pushing. No mode does yet;
+ * Babysit will, and Create PR will not, keeping the exposure it always had.
  *
  * Git is invoked by absolute path so a shim planted earlier on `$PATH` is not
  * what runs. Both sandbox images apt-install git on Debian (see