fix(sandboxes): drop the dead row when a re-adopt rebuild cannot be scheduled

Greptile, one layer under the previous fix. Making the post-delete rebuild swallow
its own failures kept it from being reported as a failed release, but left the
adopter's row claiming a `ready` image whose template is already deleted — the one
state resolution cannot repair, since it rebuilds a row that is missing or failed
and never one that says ready.

So the row is now dropped when the rebuild does not take. That turns the adopter
into the missing-row case, which the next execution repairs on its own, instead of
a sandbox that stays broken until someone re-saves it by hand. A failure to drop it
is logged at error, because at that point two writes in a row have failed and there
is nothing further this path can do.

Also gives the release tests a default "nothing re-adopted" select. Without it the
rebuild threw on an unstubbed mock and the cleanup delete overwrote the predicate
the claim assertions read, so two of them were passing on the wrong statement.

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

Author: icecrasher321

apps/sim/lib/execution/remote-sandbox/image-registry.test.ts

@@ -83,6 +83,11 @@ beforeEach(() => {
   mockProviderStrategy.current = 'prebuilt'
   mockDelete.mockReturnValue({ where: () => ({ returning: () => Promise.resolve([]) }) })
   mockInsert.mockReturnValue({ values: () => ({ onConflictDoNothing: () => Promise.resolve() }) })
+  // Default: nothing re-adopted the hash, so the post-delete rebuild is a no-op and
+  // cases that are not about it stay on one `delete`.
+  mockSelect.mockReturnValue({
+    from: () => ({ where: () => ({ limit: () => Promise.resolve([]) }) }),
+  })
   mockDeleteImage.mockResolvedValue(undefined)
 })
 
@@ -243,6 +248,24 @@ describe('releaseSandboxImage', () => {
     expect(mockInsert).not.toHaveBeenCalled()
   })
 
+  /**
+   * A row claiming `ready` against a deleted template is the state resolution
+   * cannot repair, so a rebuild that does not take must not leave one behind.
+   * Dropping it converts the adopter into the missing-row case, which the next
+   * execution fixes on its own.
+   */
+  it('drops the dead row when the rebuild cannot be scheduled', async () => {
+    stubClaim([READY_IMAGE])
+    mockSelect.mockImplementation(() => {
+      throw new Error('registry unreachable')
+    })
+
+    await releaseSandboxImage('hash-1')
+
+    // The claim itself plus the dead-row cleanup.
+    expect(mockDelete).toHaveBeenCalledTimes(2)
+  })
+
   it('skips the provider when the claimed row never had an image', async () => {
     stubClaim([{ ...READY_IMAGE, imageRef: null }])
 

apps/sim/lib/execution/remote-sandbox/image-registry.ts

@@ -390,13 +390,26 @@ async function rebuildIfReadopted(
     logger.warn('Sandbox image was re-adopted mid-delete; rebuilding it now', { specHash })
     await ensureSandboxImage(spec, specHash, { imageKnownGone: true })
   } catch (error) {
-    // Opportunistic: the delete it follows has already succeeded, so failing here
-    // must not surface as a failed release, and in the sweep must not reject the
-    // rest of its chunk. The adopter's next run still reaches the repair path.
-    logger.warn('Failed to rebuild a re-adopted sandbox image', {
+    // The template is gone and the rebuild did not take, so the adopter's row now
+    // claims a `ready` image that does not exist — the one state resolution cannot
+    // repair, because it only rebuilds a row that is missing or `failed`. Dropping
+    // the row converts that into the missing case, which the next execution fixes
+    // on its own. Swallowing instead would leave the sandbox broken until someone
+    // re-saved it by hand.
+    logger.warn('Failed to rebuild a re-adopted sandbox image; dropping the dead row', {
       specHash,
       error: getErrorMessage(error),
     })
+    try {
+      await db
+        .delete(sandboxImage)
+        .where(and(eq(sandboxImage.provider, providerId), eq(sandboxImage.specHash, specHash)))
+    } catch (cleanupError) {
+      logger.error('Could not drop a sandbox image row pointing at a deleted template', {
+        specHash,
+        error: getErrorMessage(cleanupError),
+      })
+    }
   }
 }