fix(core): preserve undefined for optional INTERNAL_ERROR fields

truncateMessage(undefined) and truncateStack(undefined) returned empty
strings, breaking the `error.message ?? fallback` nullish coalescing in
createErrorTaskError. INTERNAL_ERROR.message and stackTrace are optional
in the schema, so sanitizeError now preserves undefined for them.

Author: ericallam

packages/core/src/v3/errors.ts

@@ -332,11 +332,20 @@ export function sanitizeError(error: TaskRunError): TaskRunError {
       };
     }
     case "INTERNAL_ERROR": {
+      // message and stackTrace are optional for INTERNAL_ERROR — preserve
+      // `undefined` so the `error.message ?? "Internal error (CODE)"` fallback
+      // in createErrorTaskError still kicks in (empty string is not nullish).
       return {
         type: "INTERNAL_ERROR",
         code: error.code,
-        message: truncateMessage(error.message?.replace(/\0/g, "")),
-        stackTrace: truncateStack(error.stackTrace?.replace(/\0/g, "")),
+        message:
+          error.message != null
+            ? truncateMessage(error.message.replace(/\0/g, ""))
+            : undefined,
+        stackTrace:
+          error.stackTrace != null
+            ? truncateStack(error.stackTrace.replace(/\0/g, ""))
+            : undefined,
       };
     }
   }

packages/core/test/errors.test.ts

@@ -195,6 +195,36 @@ describe("sanitizeError truncation", () => {
   });
 });
 
+describe("sanitizeError INTERNAL_ERROR optional fields", () => {
+  it("preserves undefined message (does not convert to empty string)", () => {
+    const result = sanitizeError({
+      type: "INTERNAL_ERROR",
+      code: "SOME_INTERNAL_CODE" as any,
+      // message and stackTrace intentionally undefined
+    });
+
+    if (result.type === "INTERNAL_ERROR") {
+      // Must stay undefined so `error.message ?? fallback` works downstream
+      expect(result.message).toBeUndefined();
+      expect(result.stackTrace).toBeUndefined();
+    }
+  });
+
+  it("truncates INTERNAL_ERROR message when present", () => {
+    const result = sanitizeError({
+      type: "INTERNAL_ERROR",
+      code: "SOME_INTERNAL_CODE" as any,
+      message: "x".repeat(5000),
+    });
+
+    if (result.type === "INTERNAL_ERROR") {
+      expect(result.message).toBeDefined();
+      expect(result.message!.length).toBeLessThan(1100);
+      expect(result.message).toContain("...[truncated]");
+    }
+  });
+});
+
 describe("truncateStack message line bounding", () => {
   it("truncates huge error messages embedded in the stack", () => {
     // V8 format: "Error: <message>\n    at ..."