fix(cli): surface uncaught exception as user error (FAILED) not system failure

Following on from the prior commit that wired UNCAUGHT_EXCEPTION to fail
the attempt: the parseExecuteError branch returned an INTERNAL_ERROR with
code TASK_EXECUTION_FAILED, which made the run show as "System failure" in
the dashboard. The exception was raised by user code (or a dependency the
user controls — e.g. an EventEmitter "error" event with no listener), so
it should surface as a regular task failure ("Failed" status), not as a
platform fault.

Widen parseExecuteError's return to TaskRunError and have the
UncaughtExceptionError branch return a BUILT_IN_ERROR carrying the
original error name, message, and stack. This routes through the same
finalization path as a thrown user error: status=FAILED, normal retry
policy, catchError / handleError hooks fire as expected.

Both call sites (managed/execution.ts, dev-run-controller.ts) already pass
the result into TaskRunFailedExecutionResult.error, which accepts the full
TaskRunError union — no caller-side changes needed.

Author: matt-aitken

.changeset/uncaught-exception-fail-attempt.md

@@ -2,8 +2,4 @@
 "trigger.dev": patch
 ---
 
-Fix runs hanging to `MAX_DURATION_EXCEEDED` after an uncaught exception. When a Node `EventEmitter` (e.g. `node-redis`) emits an `"error"` event with no listener attached, Node escalates it to `process.on("uncaughtException")` in the task worker. The worker reported the error via the `UNCAUGHT_EXCEPTION` IPC event but did not exit, and the supervisor-side handler in `taskRunProcess` only logged the message at debug level — leaving the `run()` promise orphaned until `maxDuration` fired and producing empty attempts (`durationMs=0`, `costInCents=0`).
-
-The supervisor now rejects the in-flight attempt with an `UncaughtExceptionError` and gracefully terminates the worker (preserving the OTEL flush window) on `UNCAUGHT_EXCEPTION`. The attempt fails fast with `TASK_EXECUTION_FAILED`, surfacing the original error name, message, and stack trace, and falls under the normal retry policy. This mirrors the existing indexing-side behavior. Apply the same handling to unhandled promise rejections, which Node already routes through `uncaughtException` by default.
-
-Customers should still attach `client.on("error", ...)` listeners to long-lived clients (Redis, Postgres, etc.) and let awaited command rejections drive failure semantics — but a missed listener will no longer silently consume the entire `maxDuration` budget.
+Fail attempts on uncaught exceptions instead of hanging to `MAX_DURATION_EXCEEDED`. A Node `EventEmitter` (e.g. `node-redis`) emitting `"error"` with no `.on("error", ...)` listener escalates to `uncaughtException`, which the worker previously reported but did not act on — runs drifted to maxDuration with empty attempts. They now fail fast with the original error and status `FAILED`. You should still attach `.on("error", ...)` listeners to long-lived clients to handle errors gracefully.

packages/cli-v3/src/executions/taskRunProcess.test.ts

@@ -120,7 +120,7 @@ describe("TaskRunProcess", () => {
   });
 
   describe("parseExecuteError(UncaughtExceptionError)", () => {
-    it("surfaces the original error name/message/stack as TASK_EXECUTION_FAILED", () => {
+    it("surfaces the original error as a BUILT_IN_ERROR so the run shows as Failed, not System failure", () => {
       const error = new UncaughtExceptionError(
         {
           name: "Error",
@@ -133,22 +133,27 @@ describe("TaskRunProcess", () => {
 
       const result = TaskRunProcess.parseExecuteError(error);
 
-      expect(result.type).toBe("INTERNAL_ERROR");
-      expect(result.code).toBe("TASK_EXECUTION_FAILED");
-      expect(result.message).toBe("Uncaught uncaughtException: read ECONNRESET");
-      expect(result.stackTrace).toContain("TCP.onStreamRead");
+      expect(result.type).toBe("BUILT_IN_ERROR");
+      if (result.type === "BUILT_IN_ERROR") {
+        expect(result.name).toBe("Error");
+        expect(result.message).toBe("read ECONNRESET");
+        expect(result.stackTrace).toContain("TCP.onStreamRead");
+      }
     });
 
-    it("preserves origin=unhandledRejection in the surfaced message", () => {
+    it("preserves the original error for unhandledRejection origin too", () => {
       const error = new UncaughtExceptionError(
-        { name: "Error", message: "boom" },
+        { name: "TypeError", message: "boom" },
         "unhandledRejection"
       );
 
       const result = TaskRunProcess.parseExecuteError(error);
 
-      expect(result.code).toBe("TASK_EXECUTION_FAILED");
-      expect(result.message).toBe("Uncaught unhandledRejection: boom");
+      expect(result.type).toBe("BUILT_IN_ERROR");
+      if (result.type === "BUILT_IN_ERROR") {
+        expect(result.name).toBe("TypeError");
+        expect(result.message).toBe("boom");
+      }
     });
   });
 });

packages/cli-v3/src/executions/taskRunProcess.ts

@@ -8,6 +8,7 @@ import {
   TaskRunExecution,
   TaskRunExecutionPayload,
   TaskRunExecutionResult,
+  type TaskRunError,
   type TaskRunInternalError,
   tryCatch,
   WorkerManifest,
@@ -555,7 +556,7 @@ export class TaskRunProcess {
     return this._child.connected;
   }
 
-  static parseExecuteError(error: unknown, dockerMode = true): TaskRunInternalError {
+  static parseExecuteError(error: unknown, dockerMode = true): TaskRunError {
     if (error instanceof CancelledProcessError) {
       return {
         type: "INTERNAL_ERROR",
@@ -590,11 +591,16 @@ export class TaskRunProcess {
     }
 
     if (error instanceof UncaughtExceptionError) {
+      // Surface the customer's original error as a regular task failure (user
+      // error → "Failed" status) rather than an internal error → "System
+      // failure" status. The exception was raised by user code (or a
+      // dependency the user controls, e.g. an EventEmitter "error" event with
+      // no listener); it isn't a platform fault.
       return {
-        type: "INTERNAL_ERROR",
-        code: TaskRunErrorCodes.TASK_EXECUTION_FAILED,
-        message: `Uncaught ${error.origin}: ${error.originalError.message}`,
-        stackTrace: error.originalError.stack,
+        type: "BUILT_IN_ERROR",
+        name: error.originalError.name,
+        message: error.originalError.message,
+        stackTrace: error.originalError.stack ?? "",
       };
     }