fix(core, cli, run-engine): route uncaught exceptions through new INTERNAL_ERROR code

Introduce TASK_RUN_UNCAUGHT_EXCEPTION as a dedicated TaskRunInternalError
code so the engine handles retry through its existing crash-style pathway
(lockedRetryConfig lookup), and the dashboard renders these failures as
"Failed" rather than "System failure".

The previous BUILT_IN_ERROR approach showed the right status but didn't
respect the user's retry policy: BUILT_IN_ERROR with retry: undefined
short-circuits to fail_run because shouldLookupRetrySettings(BUILT_IN_ERROR)
returns false. Inline retry calculation in cli-v3 was rejected as
duplicating logic already owned by the engine.

This change mirrors how TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE,
TASK_PROCESS_SIGTERM, and TASK_PROCESS_SIGSEGV already work — same
lookup-and-retry pathway, just with a different surface status (Failed
vs Crashed) and the original error's message + stackTrace carried on the
INTERNAL_ERROR payload. No global behaviour changes; the new code is
opt-in via parseExecuteError's UncaughtExceptionError branch.

Touchpoints:
- packages/core/src/v3/schemas/common.ts: enum entry
- packages/core/src/v3/errors.ts: shouldRetryError, shouldLookupRetrySettings
- internal-packages/run-engine/src/engine/errors.ts: runStatusFromError
- packages/cli-v3/src/executions/taskRunProcess.ts: parseExecuteError + revert TaskRunError widening
- tests + changeset + server-changes entry

Author: matt-aitken

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

@@ -1,5 +1,6 @@
 ---
 "trigger.dev": patch
+"@trigger.dev/core": patch
 ---
 
-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.
+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`, and respect the task's normal retry policy. You should still attach `.on("error", ...)` listeners to long-lived clients to handle errors gracefully.

.server-changes/uncaught-exception-status-mapping.md

@@ -0,0 +1,12 @@
+---
+area: run-engine
+type: fix
+---
+
+Map the new `TASK_RUN_UNCAUGHT_EXCEPTION` internal-error code to
+`COMPLETED_WITH_ERRORS` (Failed) status in `runStatusFromError`. cli-v3
+now emits this code when the worker process surfaces an uncaught
+exception (e.g. a Node EventEmitter emitting `"error"` with no listener),
+so the run renders as a regular task failure in the dashboard rather
+than a system failure, while still routing through the engine's
+`lockedRetryConfig` lookup so the user's retry policy is honoured.

internal-packages/run-engine/src/engine/errors.ts

@@ -19,6 +19,7 @@ export function runStatusFromError(
     case "TASK_INPUT_ERROR":
     case "TASK_OUTPUT_ERROR":
     case "TASK_MIDDLEWARE_ERROR":
+    case "TASK_RUN_UNCAUGHT_EXCEPTION":
       return "COMPLETED_WITH_ERRORS";
     case "TASK_RUN_CANCELLED":
       return "CANCELED";

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

@@ -120,7 +120,7 @@ describe("TaskRunProcess", () => {
   });
 
   describe("parseExecuteError(UncaughtExceptionError)", () => {
-    it("surfaces the original error as a BUILT_IN_ERROR so the run shows as Failed, not System failure", () => {
+    it("returns INTERNAL_ERROR with TASK_RUN_UNCAUGHT_EXCEPTION + original message and stack", () => {
       const error = new UncaughtExceptionError(
         {
           name: "Error",
@@ -133,27 +133,23 @@ describe("TaskRunProcess", () => {
 
       const result = TaskRunProcess.parseExecuteError(error);
 
-      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");
-      }
+      expect(result.type).toBe("INTERNAL_ERROR");
+      expect(result.code).toBe("TASK_RUN_UNCAUGHT_EXCEPTION");
+      expect(result.message).toBe("read ECONNRESET");
+      expect(result.stackTrace).toContain("TCP.onStreamRead");
     });
 
-    it("preserves the original error for unhandledRejection origin too", () => {
+    it("uses the same code for unhandledRejection origin", () => {
       const error = new UncaughtExceptionError(
         { name: "TypeError", message: "boom" },
         "unhandledRejection"
       );
 
       const result = TaskRunProcess.parseExecuteError(error);
 
-      expect(result.type).toBe("BUILT_IN_ERROR");
-      if (result.type === "BUILT_IN_ERROR") {
-        expect(result.name).toBe("TypeError");
-        expect(result.message).toBe("boom");
-      }
+      expect(result.type).toBe("INTERNAL_ERROR");
+      expect(result.code).toBe("TASK_RUN_UNCAUGHT_EXCEPTION");
+      expect(result.message).toBe("boom");
     });
   });
 });

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

@@ -8,7 +8,6 @@ import {
   TaskRunExecution,
   TaskRunExecutionPayload,
   TaskRunExecutionResult,
-  type TaskRunError,
   type TaskRunInternalError,
   tryCatch,
   WorkerManifest,
@@ -556,7 +555,7 @@ export class TaskRunProcess {
     return this._child.connected;
   }
 
-  static parseExecuteError(error: unknown, dockerMode = true): TaskRunError {
+  static parseExecuteError(error: unknown, dockerMode = true): TaskRunInternalError {
     if (error instanceof CancelledProcessError) {
       return {
         type: "INTERNAL_ERROR",
@@ -591,16 +590,17 @@ 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.
+      // Dedicated INTERNAL_ERROR code so the engine handles retry via the
+      // existing crash-style lookup of run.lockedRetryConfig (same pathway as
+      // TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE etc.) and so the dashboard
+      // renders this as "Failed" rather than "System failure" — the exception
+      // was raised by user code (or a dependency the user controls, e.g. an
+      // EventEmitter "error" event with no listener), not a platform fault.
       return {
-        type: "BUILT_IN_ERROR",
-        name: error.originalError.name,
+        type: "INTERNAL_ERROR",
+        code: TaskRunErrorCodes.TASK_RUN_UNCAUGHT_EXCEPTION,
         message: error.originalError.message,
-        stackTrace: error.originalError.stack ?? "",
+        stackTrace: error.originalError.stack,
       };
     }
 

packages/core/src/v3/errors.ts

@@ -395,6 +395,7 @@ export function shouldRetryError(error: TaskRunError): boolean {
         case "TASK_EXECUTION_ABORTED":
         case "TASK_EXECUTION_FAILED":
         case "TASK_RUN_CRASHED":
+        case "TASK_RUN_UNCAUGHT_EXCEPTION":
         case "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE":
         case "TASK_PROCESS_SIGTERM":
           return true;
@@ -425,6 +426,7 @@ export function shouldLookupRetrySettings(error: TaskRunError): boolean {
         case "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE":
         case "TASK_PROCESS_SIGTERM":
         case "TASK_PROCESS_SIGSEGV":
+        case "TASK_RUN_UNCAUGHT_EXCEPTION":
           return true;
 
         default:

packages/core/src/v3/schemas/common.ts

@@ -174,6 +174,7 @@ export const TaskRunInternalError = z.object({
     "GRACEFUL_EXIT_TIMEOUT",
     "TASK_RUN_HEARTBEAT_TIMEOUT",
     "TASK_RUN_CRASHED",
+    "TASK_RUN_UNCAUGHT_EXCEPTION",
     "MAX_DURATION_EXCEEDED",
     "DISK_SPACE_EXCEEDED",
     "POD_EVICTED",