test(local-process): destroy the sandbox in a finally block

A failed assertion or a failed stdout wait skipped the teardown, so the
`sleep 30` child and its sandbox survived the test. Measured on a failing
run: two host processes remained. `kill-tree.test.ts` already states this
rule for the same construct.

`destroy()` kills the process tree unconditionally, so the explicit
`proc.kill()` is redundant and goes.

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

Author: taylorfsteele

packages/ai-sandbox-local-process/tests/local-process.test.ts

@@ -233,38 +233,42 @@ describe('local-process stdin errors', () => {
     'a write to a child that closed its stdin rejects without an uncaught error (skipped on Windows: named pipes do not report EPIPE the same way)',
     async () => {
       const sbx = await fresh()
-      // `exec 0<&-` makes the child close its own stdin while it keeps running:
-      // the write end stays open, and no process holds the read end.
-      const proc = await sbx.process.spawn('exec 0<&- ; echo closed ; sleep 30')
-      // The shell echoes after it closes fd 0. An earlier write only fills the
-      // pipe buffer and resolves, which would prove nothing.
-      let closed = false
-      for await (const chunk of proc.stdout) {
-        if (chunk.includes('closed')) {
-          closed = true
-          break
+      // `finally`: the `sleep 30` below outlives a failed assertion otherwise.
+      try {
+        // `exec 0<&-` makes the child close its own stdin while it keeps
+        // running: the write end stays open, and no process holds the read end.
+        const proc = await sbx.process.spawn(
+          'exec 0<&- ; echo closed ; sleep 30',
+        )
+        // The shell echoes after it closes fd 0. An earlier write only fills the
+        // pipe buffer and resolves, which would prove nothing.
+        let closed = false
+        for await (const chunk of proc.stdout) {
+          if (chunk.includes('closed')) {
+            closed = true
+            break
+          }
         }
-      }
-      expect(closed).toBe(true)
+        expect(closed).toBe(true)
 
-      const uncaught: Array<Error> = []
-      const onUncaught = (error: Error): void => {
-        uncaught.push(error)
-      }
-      process.on('uncaughtException', onUncaught)
-      try {
-        await expect(proc.stdin.write('probe\n')).rejects.toThrow(/EPIPE/)
-        // Node emits the socket's `error` event on a `nextTick` after the
-        // callback, and that queue always drains before a `setImmediate`.
-        await new Promise((resolve) => setImmediate(resolve))
+        const uncaught: Array<Error> = []
+        const onUncaught = (error: Error): void => {
+          uncaught.push(error)
+        }
+        process.on('uncaughtException', onUncaught)
+        try {
+          await expect(proc.stdin.write('probe\n')).rejects.toThrow(/EPIPE/)
+          // Node emits the socket's `error` event on a `nextTick` after the
+          // callback, and that queue always drains before a `setImmediate`.
+          await new Promise((resolve) => setImmediate(resolve))
+        } finally {
+          process.off('uncaughtException', onUncaught)
+        }
+
+        expect(uncaught).toEqual([])
       } finally {
-        process.off('uncaughtException', onUncaught)
+        await sbx.destroy()
       }
-
-      expect(uncaught).toEqual([])
-
-      await proc.kill()
-      await sbx.destroy()
     },
     30_000,
   )