fix(core): capture PTY errors in result instead of throwing from async callback

packages/core/src/core/coreToolScheduler.ts

@@ -1045,6 +1045,8 @@ export class CoreToolScheduler {
               confirmationDetails,
               reqInfo.callId,
               signal,
+            ).catch((err) =>
+              debugLogger.error(`IDE confirmation handling failed: ${err}`),
             );
 
             const originalOnConfirm = confirmationDetails.onConfirm;

packages/core/src/services/shellExecutionService.test.ts

@@ -423,7 +423,7 @@ describe('ShellExecutionService', () => {
       expect(result.exitCode).toBe(0);
     });
 
-    it('should throw unexpected PTY errors from error event', async () => {
+    it('should capture unexpected PTY errors in output instead of throwing', async () => {
       const abortController = new AbortController();
       const handle = await ShellExecutionService.execute(
         'ls -l',
@@ -435,15 +435,16 @@ describe('ShellExecutionService', () => {
       );
       await new Promise((resolve) => process.nextTick(resolve));
 
-      const unexpectedError = Object.assign(new Error('unexpected pty error'), {
+      const unexpectedError = Object.assign(new Error('connection broken'), {
         code: 'EPIPE',
       });
-      expect(() => mockPtyProcess.emit('error', unexpectedError)).toThrow(
-        'unexpected pty error',
-      );
+      // Should not throw — error is reported in output instead
+      expect(() => mockPtyProcess.emit('error', unexpectedError)).not.toThrow();
 
-      mockPtyProcess.onExit.mock.calls[0][0]({ exitCode: 0, signal: null });
-      await handle.result;
+      const result = await handle.result;
+      expect(result.error).toBeNull();
+      expect(result.output).toBe('connection broken');
+      expect(result.exitCode).toBe(1);
     });
 
     it('should ignore ioctl EBADF message-only resize race errors', async () => {

packages/core/src/services/shellExecutionService.ts

@@ -198,12 +198,16 @@ const getErrorMessage = (error: unknown): string =>
 
 const isExpectedPtyReadExitError = (error: unknown): boolean => {
   const code = getErrnoCode(error);
-  if (code === 'EIO') {
+  if (code === 'EIO' || code === 'EINTR' || code === 'ENODEV') {
     return true;
   }
 
   const message = getErrorMessage(error);
-  return message.includes('read EIO');
+  return (
+    message.includes('read EIO') ||
+    message.includes('read EINTR') ||
+    (message.includes('read') && message.toLowerCase().includes('pty'))
+  );
 };
 
 const isExpectedPtyExitRaceError = (error: unknown): boolean => {
@@ -622,7 +626,7 @@ export class ShellExecutionService {
         let decoder: TextDecoder | null = null;
         let output: string | AnsiOutput | null = null;
         const outputChunks: Buffer[] = [];
-        const error: Error | null = null;
+        let error: Error | null = null;
         let exited = false;
 
         let isStreamingRawContent = true;
@@ -812,12 +816,41 @@ export class ShellExecutionService {
             return;
           }
 
-          // Surface unexpected PTY errors to preserve existing crash behavior.
-          throw err;
+          // Store the error and trigger exit handling.
+          // Throwing from an async event callback causes uncaught exception.
+          error = err;
+          if (!exited) {
+            exited = true;
+            abortSignal.removeEventListener('abort', abortHandler);
+            this.activePtys.delete(ptyProcess.pid);
+            try {
+              ptyProcess.kill();
+            } catch {
+              // PTY may already be dead
+            }
+            // Do NOT set `error` — that field is reserved for spawn failures.
+            // Include the error message in output so downstream consumers
+            // correctly treat this as a runtime failure, not a startup failure.
+            resolve({
+              rawOutput: Buffer.concat(outputChunks),
+              output: getErrorMessage(err),
+              exitCode: 1,
+              signal: null,
+              error: null,
+              aborted: abortSignal.aborted,
+              pid: ptyProcess.pid,
+              executionMethod:
+                (ptyInfo?.name as 'node-pty' | 'lydell-node-pty') ?? 'node-pty',
+            });
+          }
         });
 
         ptyProcess.onExit(
           ({ exitCode, signal }: { exitCode: number; signal?: number }) => {
+            // If the error handler already resolved, skip redundant cleanup.
+            if (error) {
+              return;
+            }
             exited = true;
             abortSignal.removeEventListener('abort', abortHandler);
             this.activePtys.delete(ptyProcess.pid);