diff --git a/public/main/exercise/UploadAnswer.php b/public/main/exercise/UploadAnswer.php
index a8a7e053b69..df80edcb60a 100644
--- a/public/main/exercise/UploadAnswer.php
+++ b/public/main/exercise/UploadAnswer.php
@@ -2,9 +2,9 @@
 /* For licensing terms, see /license.txt */
 
 use Chamilo\CoreBundle\Entity\AttemptFile;
+use Chamilo\CoreBundle\Entity\ResourceNode;
 use Chamilo\CoreBundle\Entity\TrackEAttempt;
 use Chamilo\CoreBundle\Framework\Container;
-use Symfony\Component\Uid\Uuid;
 
 /**
  * Question with file upload, where the file is the answer.
@@ -63,9 +63,9 @@ public function return_header(Exercise $exercise, $counter = null, $score = [])
     }
 
     /**
-     * Attach uploaded Asset(s) to the question attempt as AttemptFile.
+     * Attach uploaded ResourceNode(s) to the question attempt as AttemptFile.
      */
-    public static function saveAssetInQuestionAttempt(int $attemptId, array $postedAssetIds = []): void
+    public static function saveAssetInQuestionAttempt(int $attemptId, array $postedNodeIds = []): void
     {
         $em = Container::getEntityManager();
 
@@ -78,30 +78,36 @@ public static function saveAssetInQuestionAttempt(int $attemptId, array $postedA
         $questionId = (int) $attempt->getQuestionId();
         $sessionKey = 'upload_answer_assets_'.$questionId;
 
-        $assetIds = array_values(array_filter(array_map('strval', $postedAssetIds)));
-        if (empty($assetIds)) {
+        $nodeIds = array_values(array_filter(array_map('intval', $postedNodeIds)));
+
+        if (empty($nodeIds)) {
             $sessionVal = ChamiloSession::read($sessionKey);
-            $assetIds = is_array($sessionVal) ? $sessionVal : (empty($sessionVal) ? [] : [$sessionVal]);
+            $nodeIds = is_array($sessionVal) ? $sessionVal : (empty($sessionVal) ? [] : [(int) $sessionVal]);
         }
-        if (empty($assetIds)) {
+
+        if (empty($nodeIds)) {
             return;
         }
 
         ChamiloSession::erase($sessionKey);
-        $repo = Container::getAssetRepository();
 
-        foreach ($assetIds as $id) {
-            try {
-                $asset = $repo->find(Uuid::fromRfc4122($id));
-            } catch (\Throwable $e) {
+        $resourceNodeRepo = Container::getResourceNodeRepository();
+
+        foreach ($nodeIds as $id) {
+            if (!$id) {
                 continue;
             }
-            if (!$asset) {
+
+            /** @var ResourceNode|null $node */
+            $node = $resourceNodeRepo->find($id);
+            if (null === $node) {
                 continue;
             }
 
-            $attemptFile = (new AttemptFile())->setAsset($asset);
+            $attemptFile = new AttemptFile();
+            $attemptFile->setResourceNode($node);
             $attempt->addAttemptFile($attemptFile);
+
             $em->persist($attemptFile);
         }
 
diff --git a/public/main/exercise/exercise_show.php b/public/main/exercise/exercise_show.php
index 9d41e2934f8..8f316189464 100644
--- a/public/main/exercise/exercise_show.php
+++ b/public/main/exercise/exercise_show.php
@@ -657,7 +657,8 @@ function getFCK(vals, marksid) {
             if (!empty($comnt)) {
                 echo ExerciseLib::getFeedbackText($comnt);
             }
-            echo ExerciseLib::getOralFeedbackAudio($id, $questionId);
+            echo ExerciseLib::getOralFeedbackAudio($id, $questionId, false);
+
             echo '</div>';
 
             echo '<div id="'.$name.'" class="row hidden">';
@@ -707,7 +708,7 @@ function getFCK(vals, marksid) {
             if (!empty($comnt)) {
                 echo '<b>'.get_lang('Feedback').'</b>';
                 echo ExerciseLib::getFeedbackText($comnt);
-                echo ExerciseLib::getOralFeedbackAudio($id, $questionId);
+                echo ExerciseLib::getOralFeedbackAudio($id, $questionId, false);
             }
         }
 
diff --git a/public/main/exercise/oral_expression.class.php b/public/main/exercise/oral_expression.class.php
index 03943b80f11..0e8de4e3c45 100644
--- a/public/main/exercise/oral_expression.class.php
+++ b/public/main/exercise/oral_expression.class.php
@@ -4,8 +4,10 @@
 
 use Chamilo\CoreBundle\Entity\Asset;
 use Chamilo\CoreBundle\Entity\AttemptFile;
+use Chamilo\CoreBundle\Entity\ResourceNode;
 use Chamilo\CoreBundle\Entity\TrackEAttempt;
 use Chamilo\CoreBundle\Framework\Container;
+use Chamilo\CoreBundle\Repository\ResourceNodeRepository;
 use Symfony\Component\Uid\Uuid;
 
 /**
@@ -17,6 +19,9 @@
  */
 class OralExpression extends Question
 {
+    public const RECORDING_TYPE_ATTEMPT  = 1;
+    public const RECORDING_TYPE_FEEDBACK = 2;
+
     public $typePicture = 'audio_question.png';
     public $explanationLangVar = 'Oral expression';
     public $available_extensions = ['wav', 'ogg'];
@@ -80,7 +85,8 @@ public function returnRecorder(int $trackExerciseId): string
             false
         );
 
-        $recordAudioView->assign('type', Asset::EXERCISE_ATTEMPT);
+        // Student recording
+        $recordAudioView->assign('type', self::RECORDING_TYPE_ATTEMPT);
         $recordAudioView->assign('t_exercise_id', $trackExerciseId);
         $recordAudioView->assign('question_id', $this->id);
 
@@ -89,30 +95,37 @@ public function returnRecorder(int $trackExerciseId): string
         return $recordAudioView->fetch($template);
     }
 
-    public static function saveAssetInQuestionAttempt($attemptId)
+    public static function saveAssetInQuestionAttempt($attemptId): void
     {
         $em = Container::getEntityManager();
 
+        /** @var TrackEAttempt|null $attempt */
         $attempt = $em->find(TrackEAttempt::class, $attemptId);
 
-        $variable = 'oral_expression_asset_'.$attempt->getQuestionId();
-
-        $asset = null;
-        $assetId = ChamiloSession::read($variable);
-        if (!empty($assetId)) {
-            $asset = Container::getAssetRepository()->find(Uuid::fromRfc4122($assetId));
+        if (null === $attempt) {
+            return;
         }
 
-        if (null === $asset) {
+        $variable = 'oral_expression_asset_'.$attempt->getQuestionId();
+        $resourceNodeId = ChamiloSession::read($variable);
+        ChamiloSession::erase($variable);
+
+        if (empty($resourceNodeId)) {
             return;
         }
 
-        ChamiloSession::erase($variable);
+        /** @var ResourceNodeRepository $resourceNodeRepo */
+        $resourceNodeRepo = Container::getResourceNodeRepository();
+
+        /** @var ResourceNode|null $node */
+        $node = $resourceNodeRepo->find($resourceNodeId);
 
-        $attemptFile = (new AttemptFile())
-            ->setAsset($asset)
-        ;
+        if (null === $node) {
+            return;
+        }
 
+        $attemptFile = new AttemptFile();
+        $attemptFile->setResourceNode($node);
         $attempt->addAttemptFile($attemptFile);
 
         $em->persist($attemptFile);
diff --git a/public/main/inc/ajax/exercise.ajax.php b/public/main/inc/ajax/exercise.ajax.php
index 39cde851ae0..91f394aa8d7 100644
--- a/public/main/inc/ajax/exercise.ajax.php
+++ b/public/main/inc/ajax/exercise.ajax.php
@@ -2,13 +2,17 @@
 
 /* For licensing terms, see /license.txt */
 
-use Chamilo\CoreBundle\Entity\Asset;
+use Chamilo\CoreBundle\Entity\ResourceFile;
+use Chamilo\CoreBundle\Entity\ResourceNode;
+use Chamilo\CoreBundle\Entity\ResourceType;
 use Chamilo\CoreBundle\Entity\TrackEExerciseConfirmation;
 use Chamilo\CoreBundle\Entity\TrackEExercise;
 use Chamilo\CoreBundle\Event\Events;
 use Chamilo\CoreBundle\Framework\Container;
 use Chamilo\CoreBundle\Event\ExerciseQuestionAnsweredEvent;
 use ChamiloSession as Session;
+use Doctrine\Persistence\ObjectRepository;
+use Symfony\Component\HttpFoundation\File\UploadedFile;
 
 require_once __DIR__.'/../global.inc.php';
 $current_course_tool = TOOL_QUIZ;
@@ -1073,6 +1077,7 @@ function (array $exercise) {
             exit;
         }
 
+        // Chunk upload "send" phase
         if (isset($_REQUEST['chunkAction']) && 'send' === $_REQUEST['chunkAction']) {
             if (!empty($_FILES)) {
                 $tempDirectory = api_get_path(SYS_ARCHIVE_PATH);
@@ -1085,7 +1090,11 @@ function (array $exercise) {
                 }
                 foreach ($fileList as $file) {
                     $tmpFile = disable_dangerous_file(api_replace_dangerous_char($file['name']));
-                    file_put_contents($tempDirectory.$tmpFile, fopen($file['tmp_name'], 'r'), FILE_APPEND);
+                    file_put_contents(
+                        $tempDirectory.$tmpFile,
+                        fopen($file['tmp_name'], 'r'),
+                        FILE_APPEND
+                    );
                 }
             }
             echo json_encode(['files' => $_FILES, 'errorStatus' => 0]);
@@ -1102,36 +1111,74 @@ function (array $exercise) {
             }
 
             $resultList = [];
-            $assetRepo = Container::getAssetRepository();
+
             $em = Container::getEntityManager();
+
+            /** @var ObjectRepository<ResourceType> $resourceTypeRepo */
+            $resourceTypeRepo = $em->getRepository(ResourceType::class);
+
+            /** @var ResourceType|null $resourceType */
+            $resourceType = $resourceTypeRepo->findOneBy(['title' => 'attempt_file']);
+            if (null === $resourceType) {
+                echo json_encode(['files' => [], 'error' => 'Missing ResourceType \"attempt_file\"']);
+                exit;
+            }
+
+            $resourceNodeRepo = Container::getResourceNodeRepository();
             $basePath = rtrim(api_get_path(WEB_PATH), '/');
 
             foreach ($fileList as $file) {
-                $originalName = api_replace_dangerous_char(disable_dangerous_file($file['name'] ?? 'file.bin'));
+                $originalName = api_replace_dangerous_char(
+                    disable_dangerous_file($file['name'] ?? 'file.bin')
+                );
                 $tmpPath = $file['tmp_name'];
+
                 if (isset($_REQUEST['chunkAction']) && 'done' === $_REQUEST['chunkAction']) {
                     $tmpPath = api_get_path(SYS_ARCHIVE_PATH).($file['name'] ?? $originalName);
                 }
 
-                $asset = (new Asset())
-                    ->setCategory(Asset::EXERCISE_ATTEMPT)
-                    ->setTitle($originalName);
+                $uploadedFile = new UploadedFile(
+                    $tmpPath,
+                    $originalName,
+                    $file['type'] ?? 'application/octet-stream',
+                    $file['error'] ?? UPLOAD_ERR_OK,
+                    true
+                );
+
+                $node = new ResourceNode();
+                $node->setTitle($originalName);
+                $node->setResourceType($resourceType);
+                $em->persist($node);
+
+                $resourceFile = new ResourceFile();
+                $resourceFile->setResourceNode($node);
+                $resourceFile->setFile($uploadedFile);
+                $em->persist($resourceFile);
 
-                $assetRepo->createFromRequest($asset, ['tmp_name' => $tmpPath]);
+                $em->flush();
 
                 if (isset($_REQUEST['chunkAction']) && 'done' === $_REQUEST['chunkAction']) {
                     @unlink($tmpPath);
                 }
 
-                $key = 'upload_answer_assets_'.$questionId;
+                $key     = 'upload_answer_assets_'.$questionId;
                 $current = (array) ChamiloSession::read($key);
-                $current[] = (string) $asset->getId();
+                $current[] = (int) $node->getId();
                 ChamiloSession::write($key, array_values(array_unique($current)));
 
+                $relativeUrl = '';
+                try {
+                    $relativeUrl = $resourceNodeRepo->getResourceFileUrl($node);
+                } catch (\Throwable $e) {
+                    $relativeUrl = '';
+                }
+
+                $url = $relativeUrl ? $basePath.$relativeUrl : '';
+
                 $resultList[] = [
                     'name'     => api_htmlentities($originalName),
-                    'asset_id' => (string) $asset->getId(),
-                    'url'      => $basePath.$assetRepo->getAssetUrl($asset),
+                    'asset_id' => (string) $node->getId(),
+                    'url'      => $url,
                     'size'     => isset($file['size']) ? format_file_size((int) $file['size']) : '',
                     'type'     => api_htmlentities($file['type'] ?? ''),
                     'result'   => Display::return_icon('accept.png', get_lang('Uploaded')),
diff --git a/public/main/inc/ajax/record_audio_rtc.ajax.php b/public/main/inc/ajax/record_audio_rtc.ajax.php
index c46f7b17449..b1d59ffca15 100644
--- a/public/main/inc/ajax/record_audio_rtc.ajax.php
+++ b/public/main/inc/ajax/record_audio_rtc.ajax.php
@@ -2,21 +2,26 @@
 
 /* For licensing terms, see /license.txt */
 
-use Chamilo\CoreBundle\Entity\Asset;
 use Chamilo\CoreBundle\Entity\AttemptFeedback;
 use Chamilo\CoreBundle\Entity\TrackEExercise;
+use Chamilo\CoreBundle\Entity\ResourceFile;
+use Chamilo\CoreBundle\Entity\ResourceNode;
+use Chamilo\CoreBundle\Entity\ResourceType;
+use Chamilo\CoreBundle\Entity\User;
 use Chamilo\CoreBundle\Framework\Container;
+use Doctrine\Persistence\ObjectRepository;
+use Symfony\Component\HttpFoundation\File\UploadedFile;
 
 require_once __DIR__.'/../global.inc.php';
+require_once api_get_path(SYS_CODE_PATH).'exercise/oral_expression.class.php';
 
 api_block_anonymous_users();
 
-$httpRequest = Container::getRequest();
-
-$type = $httpRequest->get('type');
+$httpRequest     = Container::getRequest();
+$type            = (int) $httpRequest->get('type');
 $trackExerciseId = (int) $httpRequest->get('t_exercise');
-$questionId = (int) $httpRequest->get('question');
-$userId = api_get_user_id();
+$questionId      = (int) $httpRequest->get('question');
+$userId          = api_get_user_id();
 
 if (empty($_FILES) || empty($_FILES['audio_blob'])) {
     Display::addFlash(
@@ -28,52 +33,127 @@
     exit;
 }
 
+$fileInfo     = $_FILES['audio_blob'];
+$originalName = $fileInfo['name'] ?? 'audio.webm';
+$mimeType     = $fileInfo['type'] ?? 'audio/webm';
+$errorCode    = $fileInfo['error'] ?? UPLOAD_ERR_OK;
+
+if (UPLOAD_ERR_OK !== $errorCode) {
+    Display::addFlash(
+        Display::return_message(
+            get_lang('Upload failed, please check maximum file size limits and folder rights.'),
+            'error'
+        )
+    );
+    exit;
+}
+
 $em = Container::getEntityManager();
-$assetRepo = Container::getAssetRepository();
 
-switch ($type) {
-    case Asset::EXERCISE_ATTEMPT:
-        $asset = (new Asset())
-            ->setCategory(Asset::EXERCISE_ATTEMPT)
-            ->setTitle($_FILES['audio_blob']['name'])
-        ;
+/** @var ObjectRepository<ResourceType> $resourceTypeRepo */
+$resourceTypeRepo = $em->getRepository(ResourceType::class);
+
+/**
+ * Create a ResourceNode + ResourceFile from an uploaded file and return the node.
+ *
+ * @param string               $title
+ * @param ResourceType         $resourceType
+ * @param array<string, mixed> $fileInfo
+ * @param int|null             $userId
+ */
+$createResourceNodeFromUploadedFile = static function (
+    string $title,
+    ResourceType $resourceType,
+    array $fileInfo,
+    ?int $userId = null
+) use ($em): ResourceNode {
+    $tmpName      = $fileInfo['tmp_name'];
+    $originalName = $fileInfo['name'] ?? 'file.bin';
+    $mimeType     = $fileInfo['type'] ?? 'application/octet-stream';
+    $errorCode    = $fileInfo['error'] ?? UPLOAD_ERR_OK;
+
+    $node = new ResourceNode();
+    $node->setTitle($title !== '' ? $title : $originalName);
+    $node->setResourceType($resourceType);
+
+    if (null !== $userId && method_exists($node, 'setCreator')) {
+        $user = $em->getRepository(User::class)->find($userId);
+        if (null !== $user) {
+            $node->setCreator($user);
+        }
+    }
 
-        $asset = $assetRepo->createFromRequest($asset, $_FILES['audio_blob']);
+    $em->persist($node);
 
-        ChamiloSession::write("oral_expression_asset_$questionId", $asset->getId()->toRfc4122());
-        break;
+    $uploadedFile = new UploadedFile(
+        $tmpName,
+        $originalName,
+        $mimeType,
+        $errorCode,
+        true
+    );
+
+    $resourceFile = new ResourceFile();
+    $resourceFile->setResourceNode($node);
+    $resourceFile->setFile($uploadedFile);
 
-    case Asset::EXERCISE_FEEDBACK:
-        /** @var TrackEExercise|null $exeAttempt */
-        $exeAttempt = Container::getTrackEExerciseRepository()->find($trackExerciseId);
+    $em->persist($resourceFile);
+    $em->flush();
 
-        if (null === $exeAttempt) {
-            exit;
+    return $node;
+};
+
+switch ($type) {
+    case OralExpression::RECORDING_TYPE_ATTEMPT:
+        // Student oral expression attempt → ResourceType "attempt_file".
+        /** @var ResourceType|null $resourceType */
+        $resourceType = $resourceTypeRepo->findOneBy(['title' => 'attempt_file']);
+        if (null === $resourceType) {
+            throw new RuntimeException('ResourceType "attempt_file" not found. Audio recording cannot be stored.');
         }
 
-        // Make feedback asset unique per attempt + question (not only per question)
-        $assetTitle = sprintf('feedback_%d_%d', $questionId, $trackExerciseId);
-        $asset = (new Asset())
-            ->setCategory(Asset::EXERCISE_FEEDBACK)
-            ->setTitle($assetTitle)
-        ;
+        $title = "oral_expression_attempt_q{$questionId}_u{$userId}";
+        $node  = $createResourceNodeFromUploadedFile($title, $resourceType, $fileInfo, $userId);
+
+        // Keep the session key name for backward compatibility.
+        ChamiloSession::write(
+            'oral_expression_asset_'.$questionId,
+            (string) $node->getId()
+        );
 
-        $asset = $assetRepo->createFromRequest($asset, $_FILES['audio_blob']);
+        break;
+
+    case OralExpression::RECORDING_TYPE_FEEDBACK:
+        // Teacher feedback → ResourceType "attempt_feedback".
+        /** @var ResourceType|null $resourceType */
+        $resourceType = $resourceTypeRepo->findOneBy(['title' => 'attempt_feedback']);
+        if (null === $resourceType) {
+            throw new RuntimeException('ResourceType "attempt_feedback" not found. Audio feedback cannot be stored.');
+        }
 
-        $attemptFeedback = (new AttemptFeedback())
-            ->setAsset($asset);
+        $title = "oral_feedback_q{$questionId}_u{$userId}";
+        $node  = $createResourceNodeFromUploadedFile($title, $resourceType, $fileInfo, $userId);
 
-        $attempt = $exeAttempt->getAttemptByQuestionId($questionId);
+        /** @var TrackEExercise|null $exerciseAttempt */
+        $exerciseAttempt = Container::getTrackEExerciseRepository()->find($trackExerciseId);
+        if (null === $exerciseAttempt) {
+            break;
+        }
 
+        $attempt = $exerciseAttempt->getAttemptByQuestionId($questionId);
         if (null === $attempt) {
-            exit;
+            break;
         }
 
+        $attemptFeedback = new AttemptFeedback();
+        $attemptFeedback->setResourceNode($node);
         $attempt->addAttemptFeedback($attemptFeedback);
 
         $em->persist($attemptFeedback);
         $em->flush();
+
         break;
+
     default:
-        throw new \Exception('Unexpected value');
+        throw new RuntimeException('Unexpected audio recording type.');
 }
diff --git a/public/main/inc/lib/exercise.lib.php b/public/main/inc/lib/exercise.lib.php
index 63313156981..0e0033022e8 100644
--- a/public/main/inc/lib/exercise.lib.php
+++ b/public/main/inc/lib/exercise.lib.php
@@ -2,14 +2,15 @@
 
 /* For licensing terms, see /license.txt */
 
-use Chamilo\CoreBundle\Entity\Asset;
 use Chamilo\CoreBundle\Entity\Course as CourseEntity;
+use Chamilo\CoreBundle\Entity\ResourceNode;
 use Chamilo\CoreBundle\Entity\Session as SessionEntity;
 use Chamilo\CoreBundle\Entity\GradebookCategory;
 use Chamilo\CoreBundle\Entity\TrackEExercise;
 use Chamilo\CoreBundle\Enums\ActionIcon;
 use Chamilo\CoreBundle\Framework\Container;
 use Chamilo\CoreBundle\Helpers\ChamiloHelper;
+use Chamilo\CoreBundle\Repository\ResourceNodeRepository;
 use Chamilo\CourseBundle\Entity\CLpItem;
 use Chamilo\CourseBundle\Entity\CLpItemView;
 use Chamilo\CourseBundle\Entity\CQuiz;
@@ -5529,26 +5530,34 @@ public static function getFeedbackText($message)
     public static function getOralFeedbackForm($attemptId, $questionId)
     {
         $view = new Template('', false, false, false, false, false, false);
-        $view->assign('type', Asset::EXERCISE_FEEDBACK);
+
+        $view->assign('type', OralExpression::RECORDING_TYPE_FEEDBACK);
         $view->assign('question_id', $questionId);
         $view->assign('t_exercise_id', $attemptId);
+
         $template = $view->get_template('exercise/oral_expression.html.twig');
 
         return $view->fetch($template);
     }
 
     /**
-     * Retrieves the generated audio files for an oral question in an exercise attempt.
+     * Get oral file audio for a given exercise attempt and question.
      *
-     * @param int  $trackExerciseId The ID of the tracked exercise.
-     * @param int  $questionId      The ID of the question.
-     * @param bool $returnUrls      (Optional) If set to true, only the URLs of the audio files are returned. Default is false.
+     * If $returnUrls is true, returns an array of URLs.
+     * Otherwise returns the HTML string with <audio> players.
      *
-     * @return array|string If $returnUrls is true, returns an array of URLs of the audio files. Otherwise, returns an HTML string with audio tags.
+     * @param int  $trackExerciseId
+     * @param int  $questionId
+     * @param bool $returnUrls
+     *
+     * @return array|string
      */
-    public static function getOralFileAudio(int $trackExerciseId, int $questionId, bool $returnUrls = false): array|string
-    {
-        /** @var TrackEExercise $trackExercise */
+    public static function getOralFileAudio(
+        int $trackExerciseId,
+        int $questionId,
+        bool $returnUrls = false
+    ) {
+        /** @var TrackEExercise|null $trackExercise */
         $trackExercise = Container::getTrackEExerciseRepository()->find($trackExerciseId);
 
         if (null === $trackExercise) {
@@ -5561,115 +5570,214 @@ public static function getOralFileAudio(int $trackExerciseId, int $questionId, b
             return $returnUrls ? [] : '';
         }
 
-        $basePath = rtrim(api_get_path(WEB_PATH), '/');
-        $assetRepo = Container::getAssetRepository();
+        $attemptId = method_exists($questionAttempt, 'getId')
+            ? (int) $questionAttempt->getId()
+            : 0;
 
-        if ($returnUrls) {
-            $urls = [];
-            foreach ($questionAttempt->getAttemptFiles() as $attemptFile) {
-                $urls[] = $basePath.$assetRepo->getAssetUrl($attemptFile->getAsset());
+        // Collect feedback ResourceNode IDs to avoid duplicate players
+        $feedbackNodeIds = [];
+        if (method_exists($questionAttempt, 'getAttemptFeedbacks')) {
+            foreach ($questionAttempt->getAttemptFeedbacks() as $feedback) {
+                if (null === $feedback) {
+                    continue;
+                }
+
+                $feedbackNode = method_exists($feedback, 'getResourceNode')
+                    ? $feedback->getResourceNode()
+                    : null;
+
+                if (null === $feedbackNode) {
+                    continue;
+                }
+
+                if (method_exists($feedbackNode, 'getId')) {
+                    $feedbackNodeIds[] = (int) $feedbackNode->getId();
+                }
             }
 
-            return $urls;
-        } else {
-            $html = '';
-            foreach ($questionAttempt->getAttemptFiles() as $attemptFile) {
-                $html .= Display::tag(
-                    'audio',
-                    '',
-                    [
-                        'src' => $basePath.$assetRepo->getAssetUrl($attemptFile->getAsset()),
-                        'controls' => '',
-                    ]
-                );
+            $feedbackNodeIds = array_unique($feedbackNodeIds);
+        }
+
+        $filesCollection = $questionAttempt->getAttemptFiles();
+        $filesCount = is_countable($filesCollection) ? count($filesCollection) : 0;
+
+        if (0 === $filesCount) {
+            return $returnUrls ? [] : '';
+        }
+
+        $urls = [];
+
+        foreach ($filesCollection as $attemptFile) {
+            if (!$attemptFile) {
+                continue;
             }
 
-            return $html;
+            $attemptFileId = method_exists($attemptFile, 'getId')
+                ? (string) $attemptFile->getId()
+                : 'n/a';
+
+            $resourceNode = method_exists($attemptFile, 'getResourceNode')
+                ? $attemptFile->getResourceNode()
+                : null;
+
+            if (null === $resourceNode) {
+                continue;
+            }
+
+            $nodeId = method_exists($resourceNode, 'getId')
+                ? (int) $resourceNode->getId()
+                : 0;
+
+            // Skip files whose ResourceNode is used by feedback (avoid duplicate players)
+            if (!empty($feedbackNodeIds) && in_array($nodeId, $feedbackNodeIds, true)) {
+                continue;
+            }
+
+            $url = self::getPublicUrlForResourceNode($resourceNode);
+            if (empty($url)) {
+                continue;
+            }
+
+            $urls[] = $url;
+        }
+
+        if (empty($urls)) {
+            return $returnUrls ? [] : '';
         }
+
+        if ($returnUrls) {
+            return $urls;
+        }
+
+        // Build HTML <audio> tags using the resolved URLs (student attempts only)
+        $html = '';
+
+        foreach ($urls as $url) {
+            $html .= Display::tag(
+                'audio',
+                '',
+                [
+                    'src' => $url,
+                    'controls' => '',
+                ]
+            );
+        }
+
+        return $html;
     }
 
     /**
-     * Get the audio component for a teacher audio feedback.
+     * Returns the HTML audio player for the latest oral feedback
+     * of a given question attempt.
+     *
+     * @param int  $attemptId   TrackEExercise id (exercise attempt)
+     * @param int  $questionId  Question id inside the attempt
+     * @param bool $wrap        Kept for backward compatibility (currently unused)
+     *
+     * @return string           HTML <audio> tag or empty string if none
      */
-    public static function getOralFeedbackAudio(int $attemptId, int $questionId): string
-    {
-        /** @var TrackEExercise|null $tExercise */
-        $tExercise = Container::getTrackEExerciseRepository()->find($attemptId);
+    public static function getOralFeedbackAudio(
+        int $attemptId,
+        int $questionId,
+        bool $wrap = true
+    ): string {
+        /** @var TrackEExercise|null $exercise */
+        $exercise = Container::getTrackEExerciseRepository()->find($attemptId);
 
-        if (null === $tExercise) {
+        if (null === $exercise) {
             return '';
         }
 
-        $qAttempt = $tExercise->getAttemptByQuestionId($questionId);
-
-        if (null === $qAttempt) {
+        $attempt = $exercise->getAttemptByQuestionId($questionId);
+        if (null === $attempt) {
             return '';
         }
 
-        $feedbacks = $qAttempt->getAttemptFeedbacks();
-
-        if ($feedbacks->isEmpty()) {
-            return '';
-        }
+        $html = '';
 
-        $latestFeedback = null;
+        // We keep only the latest feedback to avoid duplicated players.
+        foreach ($attempt->getAttemptFeedbacks() as $feedback) {
+            $node = $feedback->getResourceNode();
 
-        foreach ($feedbacks as $feedback) {
-            // Skip feedbacks without asset, just in case
-            if (null === $feedback->getAsset()) {
+            if (null === $node) {
+                // Old data might still be asset-based; migration can handle that later.
                 continue;
             }
 
-            if (null === $latestFeedback) {
-                $latestFeedback = $feedback;
+            $url = self::getPublicUrlForResourceNode($node);
+
+            if ('' === $url) {
+                // URL could not be generated (missing file or routing issue).
                 continue;
             }
 
-            // Choose the feedback with the latest createdAt
-            if ($feedback->getCreatedAt() > $latestFeedback->getCreatedAt()) {
-                $latestFeedback = $feedback;
-            }
-        }
-
-        if (null === $latestFeedback) {
-            return '';
+            // Override previous HTML so that only the last feedback is rendered.
+            $html = Display::tag(
+                'audio',
+                '',
+                [
+                    'src' => $url,
+                    'controls' => '',
+                ]
+            );
         }
 
-        $assetRepo = Container::getAssetRepository();
-
-        return Display::tag(
-            'audio',
-            '',
-            [
-                'src' => $assetRepo->getAssetUrl($latestFeedback->getAsset()),
-                'controls' => '',
-            ]
-        );
+        return $html;
     }
 
+    /**
+     * Get uploaded answer files (resource-based) for a given attempt/question.
+     *
+     * If $returnUrls is true, returns an array of URLs.
+     * Otherwise returns a simple HTML list of links.
+     *
+     * @param int  $trackExerciseId
+     * @param int  $questionId
+     * @param bool $returnUrls
+     *
+     * @return array|string
+     */
     public static function getUploadAnswerFiles(int $trackExerciseId, int $questionId, bool $returnUrls = false)
     {
+        /** @var TrackEExercise|null $trackExercise */
         $trackExercise = Container::getTrackEExerciseRepository()->find($trackExerciseId);
-        if (!$trackExercise) { return $returnUrls ? [] : ''; }
+
+        if (null === $trackExercise) {
+            return $returnUrls ? [] : '';
+        }
+
         $attempt = $trackExercise->getAttemptByQuestionId($questionId);
-        if (!$attempt) { return $returnUrls ? [] : ''; }
 
-        $assetRepo = Container::getAssetRepository();
-        $basePath = rtrim(api_get_path(WEB_PATH), '/');
+        if (null === $attempt) {
+            return $returnUrls ? [] : '';
+        }
+
+        $urls = [];
 
-        if ($returnUrls) {
-            $urls = [];
-            foreach ($attempt->getAttemptFiles() as $af) {
-                $urls[] = $basePath.$assetRepo->getAssetUrl($af->getAsset());
+        // Loop over AttemptFile and use their ResourceNode to get public URLs
+        foreach ($attempt->getAttemptFiles() as $attemptFile) {
+            $resourceNode = $attemptFile->getResourceNode();
+            $url = self::getPublicUrlForResourceNode($resourceNode);
+
+            if (!empty($url)) {
+                $urls[] = $url;
             }
+        }
+
+        if ($returnUrls) {
             return $urls;
         }
 
+        // Legacy simple HTML (used by some views)
         $html = '';
-        foreach ($attempt->getAttemptFiles() as $af) {
-            $url = $basePath.$assetRepo->getAssetUrl($af->getAsset());
-            $html .= Display::url(basename($url), $url, ['target' => '_blank']).'<br />';
+
+        foreach ($urls as $url) {
+            $path = parse_url($url, PHP_URL_PATH);
+            $name = $path ? basename($path) : $url;
+
+            $html .= Display::url($name, $url, ['target' => '_blank']).'<br />';
         }
+
         return $html;
     }
 
@@ -6891,4 +6999,43 @@ public static function getUserQuestionScoreGlobal(
 
         return $questionScore;
     }
+
+    /**
+     * Build a public URL for a ResourceNode file used in exercises.
+     * Returns an empty string when the node is null or when the underlying
+     * file/route cannot be resolved (we do not want to break the exercise view).
+     *
+     * @param ResourceNode|null $resourceNode
+     * @param array                                        $extraParams
+     *
+     * @return string
+     */
+    public static function getPublicUrlForResourceNode(?ResourceNode $resourceNode): string
+    {
+        if (null === $resourceNode) {
+            return '';
+        }
+
+        try {
+            /** @var ResourceNodeRepository $resourceNodeRepo */
+            $resourceNodeRepo = Container::getResourceNodeRepository();
+            $resourceType = $resourceNode->getResourceType();
+            $tool         = $resourceType?->getTool();
+            $url = $resourceNodeRepo->getResourceFileUrl($resourceNode);
+
+            return $url;
+        } catch (Throwable $e) {
+            error_log(sprintf(
+                '[ORAL_FILE_AUDIO][node=%s] Exception in getPublicUrlForResourceNode(): %s (%s) at %s:%d',
+                $resourceNode?->getId() ?? 'null',
+                $e->getMessage(),
+                get_class($e),
+                $e->getFile(),
+                $e->getLine()
+            ));
+
+            return '';
+        }
+    }
+
 }
diff --git a/public/main/inc/lib/exercise_show_functions.lib.php b/public/main/inc/lib/exercise_show_functions.lib.php
index 33f556a9503..c714993dd57 100644
--- a/public/main/inc/lib/exercise_show_functions.lib.php
+++ b/public/main/inc/lib/exercise_show_functions.lib.php
@@ -106,10 +106,19 @@ public static function display_calculated_answer(
     }
 
     /**
-     * Shows the answer to an upload question.
+     * Display the uploaded files for an exercise question, using Tailwind-based markup.
      *
-     * @param float|null $questionScore   Only used to check if > 0
-     * @param int        $resultsDisabled Unused
+     * This method now relies on getUploadAnswerFiles() which already resolves
+     * ResourceNode → ResourceFile → public URL.
+     *
+     * @param string $feedbackType
+     * @param string $answer
+     * @param int    $exeId
+     * @param int    $questionId
+     * @param mixed  $questionScore
+     * @param int    $resultsDisabled
+     *
+     * @return void
      */
     public static function displayUploadAnswer(
         string $feedbackType,
@@ -119,23 +128,8 @@ public static function displayUploadAnswer(
                $questionScore = null,
                $resultsDisabled = 0
     ) {
-        $urls = [];
-
-        $trackExercise = Container::getTrackEExerciseRepository()->find($exeId);
-        if (null !== $trackExercise) {
-            $questionAttempt = $trackExercise->getAttemptByQuestionId($questionId);
-            if (null !== $questionAttempt) {
-                $assetRepo = Container::getAssetRepository();
-                $basePath  = rtrim(api_get_path(WEB_PATH), '/');
-
-                foreach ($questionAttempt->getAttemptFiles() as $attemptFile) {
-                    $asset = $attemptFile->getAsset();
-                    if (null !== $asset) {
-                        $urls[] = $basePath.$assetRepo->getAssetUrl($asset);
-                    }
-                }
-            }
-        }
+        // URLs resolved from ResourceNode (resource-based storage)
+        $urls = ExerciseLib::getUploadAnswerFiles($exeId, $questionId, true);
 
         if (!empty($urls)) {
             echo '<tr><td>';
@@ -147,7 +141,7 @@ public static function displayUploadAnswer(
                 $safeName = api_htmlentities($name);
                 $ext = strtolower(pathinfo($name, PATHINFO_EXTENSION));
 
-                // Simple inline icon per file type (SVGs kept tiny)
+                // Simple inline icon per file type (SVG kept small and neutral)
                 switch ($ext) {
                     case 'pdf':
                         $icon = '<svg xmlns="http://www.w3.org/2000/svg" class="h-5 w-5" viewBox="0 0 20 20" fill="currentColor"><path d="M4 2a2 2 0 00-2 2v12a2 2 0 002 2h8l6-6V4a2 2 0 00-2-2H4z"/><path d="M12 14v4l4-4h-4z"/></svg>';
@@ -184,10 +178,11 @@ public static function displayUploadAnswer(
             echo '</td></tr>';
         }
 
+        // Feedback / correction status (unchanged logic)
         if (EXERCISE_FEEDBACK_TYPE_EXAM != $feedbackType) {
             $comments = Event::get_comments($exeId, $questionId);
             if ($questionScore > 0 || !empty($comments)) {
-                // Handled elsewhere
+                // Correction is handled elsewhere.
             } else {
                 echo '<tr>';
                 echo Display::tag('td', ExerciseLib::getNotCorrectedYetText());
@@ -230,12 +225,17 @@ public static function display_free_answer(
     }
 
     /**
-     * @param $feedback_type
-     * @param $answer
-     * @param $trackExerciseId
-     * @param $questionId
-     * @param int $resultsDisabled
-     * @param int $questionScore
+     * Display oral expression answer: student audio, text answer, and correction status.
+     *
+     * @param string $feedback_type
+     * @param string $answer
+     * @param int    $trackExerciseId
+     * @param int    $questionId
+     * @param int    $resultsDisabled
+     * @param float  $questionScore
+     * @param bool   $showAlertIfNotCorrected
+     *
+     * @return void
      */
     public static function display_oral_expression_answer(
         $feedback_type,
@@ -246,43 +246,49 @@ public static function display_oral_expression_answer(
         $questionScore = 0,
         $showAlertIfNotCorrected = false
     ) {
-        /** @var TrackEExercise $trackExercise */
+        /** @var TrackEExercise|null $trackExercise */
         $trackExercise = Container::getTrackEExerciseRepository()->find($trackExerciseId);
 
-        if (null === $trackExerciseId) {
+        if (null === $trackExercise) {
             return;
         }
 
-        $questionAttempt = $trackExercise->getAttemptByQuestionId($questionId);
-
-        if (null === $questionAttempt) {
-            return;
-        }
+        // Student recorded answer(s)
+        // getOralFileAudio() ya NO debe incluir los ResourceNode usados en AttemptFeedback.
+        $studentAudioHtml = ExerciseLib::getOralFileAudio($trackExerciseId, $questionId);
 
-        $assetRepo = Container::getAssetRepository();
-
-        foreach ($questionAttempt->getAttemptFiles() as $attemptFile) {
-            echo Display::tag(
-                'audio',
-                '',
-                [
-                    'src' => $assetRepo->getAssetUrl($attemptFile->getAsset()),
-                    'controls' => '',
-                ]
-            );
+        if (!empty($studentAudioHtml)) {
+            echo $studentAudioHtml;
         }
 
+        // Optional text answer written by the student
         if (!empty($answer)) {
             echo Display::tag('p', Security::remove_XSS($answer));
         }
 
+        // Teacher correction: comments and audio feedback
         $comment = Event::get_comments($trackExerciseId, $questionId);
         $teacherAudio = ExerciseLib::getOralFeedbackAudio(
-                        $trackExerciseId,
-                        $questionId
-                    );
+            $trackExerciseId,
+            $questionId
+        );
 
-        if ($showAlertIfNotCorrected && !$questionScore && EXERCISE_FEEDBACK_TYPE_EXAM != $feedback_type && empty($comment) && empty($teacherAudio)) {
+        if (!empty($teacherAudio)) {
+            echo $teacherAudio;
+        }
+
+        if (!empty($comment)) {
+            echo Display::tag('p', Security::remove_XSS($comment));
+        }
+
+        // Optional "not corrected yet" warning
+        if (
+            $showAlertIfNotCorrected &&
+            !$questionScore &&
+            EXERCISE_FEEDBACK_TYPE_EXAM != $feedback_type &&
+            empty($comment) &&
+            empty($teacherAudio)
+        ) {
             echo Display::tag('p', ExerciseLib::getNotCorrectedYetText());
         }
     }
diff --git a/src/CoreBundle/Entity/AttemptFeedback.php b/src/CoreBundle/Entity/AttemptFeedback.php
index aae6af39841..a76743d62f7 100644
--- a/src/CoreBundle/Entity/AttemptFeedback.php
+++ b/src/CoreBundle/Entity/AttemptFeedback.php
@@ -31,9 +31,8 @@ class AttemptFeedback
     #[ORM\JoinColumn(name: 'user_id', referencedColumnName: 'id', onDelete: 'CASCADE')]
     protected User $user;
 
-    #[ORM\ManyToOne(targetEntity: Asset::class, cascade: ['remove'])]
-    #[ORM\JoinColumn(name: 'asset_id', referencedColumnName: 'id', onDelete: 'CASCADE')]
-    protected ?Asset $asset = null;
+    #[ORM\ManyToOne(targetEntity: ResourceNode::class)]
+    protected ?ResourceNode $resourceNode = null;
 
     #[ORM\Column(name: 'comment', type: 'text', nullable: false)]
     protected string $comment;
@@ -73,14 +72,22 @@ public function setUser(User $user): self
         return $this;
     }
 
-    public function getAsset(): ?Asset
+    public function getResourceNode(): ?ResourceNode
     {
-        return $this->asset;
+        return $this->resourceNode;
     }
 
-    public function setAsset(?Asset $asset): self
+    public function setResourceNode(?ResourceNode $resourceNode): self
     {
-        $this->asset = $asset;
+        $this->resourceNode = $resourceNode;
+
+        return $this;
+    }
+
+    public function clearResourceNode(): self
+    {
+        // Detach the resource node reference when feedback file is removed.
+        $this->resourceNode = null;
 
         return $this;
     }
diff --git a/src/CoreBundle/Entity/AttemptFile.php b/src/CoreBundle/Entity/AttemptFile.php
index 19f6e10e541..897017d308e 100644
--- a/src/CoreBundle/Entity/AttemptFile.php
+++ b/src/CoreBundle/Entity/AttemptFile.php
@@ -26,9 +26,8 @@ class AttemptFile
     #[ORM\JoinColumn(name: 'attempt_id', referencedColumnName: 'id', onDelete: 'CASCADE')]
     protected TrackEAttempt $attempt;
 
-    #[ORM\ManyToOne(targetEntity: Asset::class, cascade: ['remove'])]
-    #[ORM\JoinColumn(name: 'asset_id', referencedColumnName: 'id', onDelete: 'CASCADE')]
-    protected ?Asset $asset = null;
+    #[ORM\ManyToOne(targetEntity: ResourceNode::class)]
+    protected ?ResourceNode $resourceNode = null;
 
     #[ORM\Column(name: 'comment', type: 'text', nullable: false)]
     protected string $comment;
@@ -56,14 +55,22 @@ public function setAttempt(TrackEAttempt $attempt): self
         return $this;
     }
 
-    public function getAsset(): ?Asset
+    public function getResourceNode(): ?ResourceNode
     {
-        return $this->asset;
+        return $this->resourceNode;
     }
 
-    public function setAsset(?Asset $asset): self
+    public function setResourceNode(?ResourceNode $resourceNode): self
     {
-        $this->asset = $asset;
+        $this->resourceNode = $resourceNode;
+
+        return $this;
+    }
+
+    public function clearResourceNode(): self
+    {
+        // Detach the resource node reference when the file is removed.
+        $this->resourceNode = null;
 
         return $this;
     }
diff --git a/src/CoreBundle/Migrations/Schema/V200/Version20251130011600.php b/src/CoreBundle/Migrations/Schema/V200/Version20251130011600.php
new file mode 100644
index 00000000000..60fdf0b2454
--- /dev/null
+++ b/src/CoreBundle/Migrations/Schema/V200/Version20251130011600.php
@@ -0,0 +1,187 @@
+<?php
+
+declare(strict_types=1);
+
+/* For licensing terms, see /license.txt */
+
+namespace Chamilo\CoreBundle\Migrations\Schema\V200;
+
+use Chamilo\CoreBundle\Migrations\AbstractMigrationChamilo;
+use Doctrine\DBAL\Schema\Schema;
+
+final class Version20251130011600 extends AbstractMigrationChamilo
+{
+    public function getDescription(): string
+    {
+        return 'Add resource_node_id to attempt_file/attempt_feedback and declare new resource types for them.';
+    }
+
+    public function up(Schema $schema): void
+    {
+        // --- attempt_file ---
+        if ($schema->hasTable('attempt_file')) {
+            $table = $schema->getTable('attempt_file');
+
+            if (!$table->hasColumn('resource_node_id')) {
+                // Add nullable FK column. We place it after asset_id to keep legacy column nearby.
+                $this->addSql(
+                    'ALTER TABLE attempt_file
+                     ADD resource_node_id INT DEFAULT NULL AFTER asset_id'
+                );
+
+                // Index for FK performance.
+                $this->addSql(
+                    'CREATE INDEX IDX_ATTEMPT_FILE_RESOURCE_NODE
+                     ON attempt_file (resource_node_id)'
+                );
+
+                // FK to resource_node.id.
+                $this->addSql(
+                    'ALTER TABLE attempt_file
+                     ADD CONSTRAINT FK_ATTEMPT_FILE_RESOURCE_NODE
+                     FOREIGN KEY (resource_node_id)
+                     REFERENCES resource_node (id)
+                     ON DELETE CASCADE'
+                );
+            }
+        }
+
+        // --- attempt_feedback ---
+        if ($schema->hasTable('attempt_feedback')) {
+            $table = $schema->getTable('attempt_feedback');
+
+            if (!$table->hasColumn('resource_node_id')) {
+                $this->addSql(
+                    'ALTER TABLE attempt_feedback
+                     ADD resource_node_id INT DEFAULT NULL AFTER asset_id'
+                );
+
+                $this->addSql(
+                    'CREATE INDEX IDX_ATTEMPT_FEEDBACK_RESOURCE_NODE
+                     ON attempt_feedback (resource_node_id)'
+                );
+
+                $this->addSql(
+                    'ALTER TABLE attempt_feedback
+                     ADD CONSTRAINT FK_ATTEMPT_FEEDBACK_RESOURCE_NODE
+                     FOREIGN KEY (resource_node_id)
+                     REFERENCES resource_node (id)
+                     ON DELETE CASCADE'
+                );
+            }
+        }
+
+        $this->declareNewResourceTypes();
+    }
+
+    public function down(Schema $schema): void
+    {
+        // --- attempt_file ---
+        if ($schema->hasTable('attempt_file')) {
+            $table = $schema->getTable('attempt_file');
+
+            if ($table->hasColumn('resource_node_id')) {
+                // Drop FK if it exists.
+                if ($table->hasForeignKey('FK_ATTEMPT_FILE_RESOURCE_NODE')) {
+                    $this->addSql(
+                        'ALTER TABLE attempt_file
+                         DROP FOREIGN KEY FK_ATTEMPT_FILE_RESOURCE_NODE'
+                    );
+                }
+
+                // Drop index if it exists.
+                if ($table->hasIndex('IDX_ATTEMPT_FILE_RESOURCE_NODE')) {
+                    $this->addSql(
+                        'DROP INDEX IDX_ATTEMPT_FILE_RESOURCE_NODE
+                         ON attempt_file'
+                    );
+                }
+
+                // Drop the column.
+                $this->addSql(
+                    'ALTER TABLE attempt_file
+                     DROP COLUMN resource_node_id'
+                );
+            }
+        }
+
+        // --- attempt_feedback ---
+        if ($schema->hasTable('attempt_feedback')) {
+            $table = $schema->getTable('attempt_feedback');
+
+            if ($table->hasColumn('resource_node_id')) {
+                if ($table->hasForeignKey('FK_ATTEMPT_FEEDBACK_RESOURCE_NODE')) {
+                    $this->addSql(
+                        'ALTER TABLE attempt_feedback
+                         DROP FOREIGN KEY FK_ATTEMPT_FEEDBACK_RESOURCE_NODE'
+                    );
+                }
+
+                if ($table->hasIndex('IDX_ATTEMPT_FEEDBACK_RESOURCE_NODE')) {
+                    $this->addSql(
+                        'DROP INDEX IDX_ATTEMPT_FEEDBACK_RESOURCE_NODE
+                         ON attempt_feedback'
+                    );
+                }
+
+                $this->addSql(
+                    'ALTER TABLE attempt_feedback
+                     DROP COLUMN resource_node_id'
+                );
+            }
+        }
+
+        $this->removeNewResourceTypes();
+    }
+
+    /**
+     * Declare new resource types for attempt_file and attempt_feedback.
+     *
+     * They are linked to the "quiz" tool so that ResourceNode::getResourceType()->getTool()
+     * is always initialized correctly.
+     */
+    private function declareNewResourceTypes(): void
+    {
+        // Create resource_type "attempt_file" if it does not exist yet.
+        $this->addSql(
+            "INSERT INTO resource_type (title, tool_id, created_at, updated_at)
+         SELECT 'attempt_file', t.id, NOW(), NOW()
+         FROM tool t
+         WHERE t.title = 'quiz'
+           AND NOT EXISTS (
+               SELECT 1 FROM resource_type WHERE title = 'attempt_file'
+           )"
+        );
+
+        // Create resource_type "attempt_feedback" if it does not exist yet.
+        $this->addSql(
+            "INSERT INTO resource_type (title, tool_id, created_at, updated_at)
+         SELECT 'attempt_feedback', t.id, NOW(), NOW()
+         FROM tool t
+         WHERE t.title = 'quiz'
+           AND NOT EXISTS (
+               SELECT 1 FROM resource_type WHERE title = 'attempt_feedback'
+           )"
+        );
+
+        // Safety net: if rows already exist but have tool_id = NULL, link them to quiz as well.
+        $this->addSql(
+            "UPDATE resource_type rt
+         JOIN tool t ON t.title = 'quiz'
+         SET rt.tool_id = t.id
+         WHERE rt.title IN ('attempt_file', 'attempt_feedback')
+           AND (rt.tool_id IS NULL OR rt.tool_id = 0)"
+        );
+    }
+
+    /**
+     * Remove the newly declared resource types (used in down()).
+     */
+    private function removeNewResourceTypes(): void
+    {
+        $this->addSql(
+            "DELETE FROM resource_type
+             WHERE title IN ('attempt_file', 'attempt_feedback')"
+        );
+    }
+}
diff --git a/src/CoreBundle/Migrations/Schema/V200/Version20251130111400.php b/src/CoreBundle/Migrations/Schema/V200/Version20251130111400.php
new file mode 100644
index 00000000000..a06b6c0c9e2
--- /dev/null
+++ b/src/CoreBundle/Migrations/Schema/V200/Version20251130111400.php
@@ -0,0 +1,753 @@
+<?php
+
+declare(strict_types=1);
+
+/* For licensing terms, see /license.txt */
+
+namespace Chamilo\CoreBundle\Migrations\Schema\V200;
+
+use Chamilo\CoreBundle\Entity\Asset;
+use Chamilo\CoreBundle\Entity\ResourceFile;
+use Chamilo\CoreBundle\Entity\ResourceNode;
+use Chamilo\CoreBundle\Entity\ResourceType;
+use Chamilo\CoreBundle\Migrations\AbstractMigrationChamilo;
+use Chamilo\CoreBundle\Repository\AssetRepository;
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Persistence\ManagerRegistry;
+use Symfony\Component\HttpFoundation\File\UploadedFile;
+use Throwable;
+
+final class Version20251130111400 extends AbstractMigrationChamilo
+{
+    private const DRY_RUN = false;
+
+    public function getDescription(): string
+    {
+        return 'Migrate attempt_file / attempt_feedback assets to ResourceNode/ResourceFile and fill resource_node_id, then cleanup asset references and orphan nodes.';
+    }
+
+    /**
+     * This migration runs outside a global DB transaction.
+     * We want to be able to skip broken rows without rolling back everything.
+     */
+    public function isTransactional(): bool
+    {
+        return false;
+    }
+
+    public function up(Schema $schema): void
+    {
+        $this->ensureEntityManagerIsOpen();
+
+        $resourceTypeRepo = $this->entityManager->getRepository(ResourceType::class);
+
+        /** @var ResourceType|null $attemptFileType */
+        $attemptFileType = $resourceTypeRepo->findOneBy(['title' => 'attempt_file']);
+        /** @var ResourceType|null $attemptFeedbackType */
+        $attemptFeedbackType = $resourceTypeRepo->findOneBy(['title' => 'attempt_feedback']);
+
+        if (null === $attemptFileType || null === $attemptFeedbackType) {
+            error_log('[MIGRATION] ResourceType "attempt_file" or "attempt_feedback" not found. Aborting data migration.');
+
+            return;
+        }
+
+        /** @var AssetRepository $assetRepo */
+        $assetRepo = $this->getAssetRepository();
+
+        // 1) Main migrations (create ResourceNode/ResourceFile, clear asset_id, delete unused Asset).
+        $this->migrateAttemptFiles($assetRepo, $attemptFileType);
+        $this->migrateAttemptFeedback($assetRepo, $attemptFeedbackType);
+
+        // 2) Cleanup: ensure there are no resource_node_id values without a ResourceFile.
+        $this->cleanupOrphanNodesWithoutFile();
+    }
+
+    public function down(Schema $schema): void
+    {
+        // No-op: data migration is not reversible in a safe way.
+    }
+
+    /**
+     * Migrate and/or cleanup attempt_file rows:
+     * - If resource_node_id IS NULL: create ResourceNode/ResourceFile and then clear asset_id.
+     * - If resource_node_id IS NOT NULL: only clear asset_id (row was already migrated).
+     */
+    private function migrateAttemptFiles(
+        AssetRepository $assetRepo,
+        ResourceType $attemptFileType
+    ): void {
+        $sql = 'SELECT id, attempt_id, asset_id, resource_node_id
+                FROM attempt_file
+                WHERE asset_id IS NOT NULL';
+
+        $stmt = $this->connection->executeQuery($sql);
+
+        $processed = 0;
+        $migrated = 0;
+        $cleanedOnly = 0;
+
+        error_log('[MIGRATION][attempt_file] Starting migration for attempt_file rows.');
+
+        while (false !== ($row = $stmt->fetchAssociative())) {
+            $processed++;
+
+            $rowId = $row['id'];             // binary(16) UUID or similar
+            $attemptId = $row['attempt_id']; // int or other scalar
+            $assetId = $row['asset_id'];     // binary(16) UUID
+            $resourceNodeId = $row['resource_node_id']; // int|null
+
+            $rowIdForLog = $this->formatIdForLog($rowId);
+            $attemptIdForLog = $this->formatIdForLog($attemptId);
+            $assetIdForLog = $this->formatIdForLog($assetId);
+
+            if (0 === $processed % 200) {
+                error_log(
+                    sprintf(
+                        '[MIGRATION][attempt_file] Progress: processed=%d, migrated=%d, cleanedOnly=%d (last rowId=%s)',
+                        $processed,
+                        $migrated,
+                        $cleanedOnly,
+                        $rowIdForLog
+                    )
+                );
+            }
+
+            try {
+                $this->ensureEntityManagerIsOpen();
+
+                /** @var Asset|null $asset */
+                $asset = $assetRepo->find($assetId);
+
+                if (null === $asset) {
+                    // Asset record is gone, just clear the asset_id reference.
+                    $this->connection->update(
+                        'attempt_file',
+                        ['asset_id' => null],
+                        ['id' => $rowId]
+                    );
+
+                    error_log(
+                        sprintf(
+                            '[MIGRATION][attempt_file] Cleared asset_id for attempt_file.id=%s (attemptId=%s assetId=%s) because Asset is missing.',
+                            $rowIdForLog,
+                            $attemptIdForLog,
+                            $assetIdForLog
+                        )
+                    );
+
+                    continue;
+                }
+
+                if (null === $resourceNodeId) {
+                    // Not migrated yet: create ResourceNode/ResourceFile then cleanup the Asset reference.
+                    $ok = $this->migrateSingleAssetToResourceNode(
+                        $assetRepo,
+                        'attempt_file',
+                        'attempt_file',
+                        $rowId,
+                        $asset,
+                        $attemptFileType
+                    );
+
+                    if ($ok) {
+                        $migrated++;
+                    }
+                } else {
+                    // Already has a resource_node_id: only cleanup asset_id and possibly delete the Asset if unused.
+                    $this->clearAssetReference(
+                        $assetRepo,
+                        'attempt_file',
+                        'attempt_file',
+                        $rowId,
+                        $rowIdForLog,
+                        $asset
+                    );
+                    $cleanedOnly++;
+                }
+            } catch (Throwable $e) {
+                error_log(
+                    sprintf(
+                        '[MIGRATION][attempt_file] Error for attempt_file.id=%s (attemptId=%s): %s',
+                        $rowIdForLog,
+                        $attemptIdForLog,
+                        $e->getMessage()
+                    )
+                );
+
+                $this->ensureEntityManagerIsOpen();
+            }
+
+            if (0 === $processed % 50) {
+                // Free some memory for long-running migrations.
+                $this->entityManager->clear(ResourceNode::class);
+                $this->entityManager->clear(ResourceFile::class);
+                $this->entityManager->clear(Asset::class);
+            }
+        }
+
+        error_log(
+            sprintf(
+                '[MIGRATION][attempt_file] Finished. Processed=%d, Migrated=%d, CleanedOnly=%d',
+                $processed,
+                $migrated,
+                $cleanedOnly
+            )
+        );
+    }
+
+    /**
+     * Same logic as attempt_file but for attempt_feedback.
+     */
+    private function migrateAttemptFeedback(
+        AssetRepository $assetRepo,
+        ResourceType $attemptFeedbackType
+    ): void {
+        $sql = 'SELECT id, attempt_id, asset_id, resource_node_id
+                FROM attempt_feedback
+                WHERE asset_id IS NOT NULL';
+
+        $stmt = $this->connection->executeQuery($sql);
+
+        $processed = 0;
+        $migrated = 0;
+        $cleanedOnly = 0;
+
+        error_log('[MIGRATION][attempt_feedback] Starting migration for attempt_feedback rows.');
+
+        while (false !== ($row = $stmt->fetchAssociative())) {
+            $processed++;
+
+            $rowId = $row['id'];             // binary(16) UUID or similar
+            $attemptId = $row['attempt_id']; // int or other scalar
+            $assetId = $row['asset_id'];     // binary(16) UUID
+            $resourceNodeId = $row['resource_node_id']; // int|null
+
+            $rowIdForLog = $this->formatIdForLog($rowId);
+            $attemptIdForLog = $this->formatIdForLog($attemptId);
+            $assetIdForLog = $this->formatIdForLog($assetId);
+
+            if (0 === $processed % 200) {
+                error_log(
+                    sprintf(
+                        '[MIGRATION][attempt_feedback] Progress: processed=%d, migrated=%d, cleanedOnly=%d (last rowId=%s)',
+                        $processed,
+                        $migrated,
+                        $cleanedOnly,
+                        $rowIdForLog
+                    )
+                );
+            }
+
+            try {
+                $this->ensureEntityManagerIsOpen();
+
+                /** @var Asset|null $asset */
+                $asset = $assetRepo->find($assetId);
+
+                if (null === $asset) {
+                    // Asset record is gone, just clear the asset_id reference.
+                    $this->connection->update(
+                        'attempt_feedback',
+                        ['asset_id' => null],
+                        ['id' => $rowId]
+                    );
+
+                    error_log(
+                        sprintf(
+                            '[MIGRATION][attempt_feedback] Cleared asset_id for attempt_feedback.id=%s (attemptId=%s assetId=%s) because Asset is missing.',
+                            $rowIdForLog,
+                            $attemptIdForLog,
+                            $assetIdForLog
+                        )
+                    );
+
+                    continue;
+                }
+
+                if (null === $resourceNodeId) {
+                    $ok = $this->migrateSingleAssetToResourceNode(
+                        $assetRepo,
+                        'attempt_feedback',
+                        'attempt_feedback',
+                        $rowId,
+                        $asset,
+                        $attemptFeedbackType
+                    );
+
+                    if ($ok) {
+                        $migrated++;
+                    }
+                } else {
+                    $this->clearAssetReference(
+                        $assetRepo,
+                        'attempt_feedback',
+                        'attempt_feedback',
+                        $rowId,
+                        $rowIdForLog,
+                        $asset
+                    );
+                    $cleanedOnly++;
+                }
+            } catch (Throwable $e) {
+                error_log(
+                    sprintf(
+                        '[MIGRATION][attempt_feedback] Error for attempt_feedback.id=%s (attemptId=%s): %s',
+                        $rowIdForLog,
+                        $attemptIdForLog,
+                        $e->getMessage()
+                    )
+                );
+
+                $this->ensureEntityManagerIsOpen();
+            }
+
+            if (0 === $processed % 50) {
+                $this->entityManager->clear(ResourceNode::class);
+                $this->entityManager->clear(ResourceFile::class);
+                $this->entityManager->clear(Asset::class);
+            }
+        }
+
+        error_log(
+            sprintf(
+                '[MIGRATION][attempt_feedback] Finished. Processed=%d, Migrated=%d, CleanedOnly=%d',
+                $processed,
+                $migrated,
+                $cleanedOnly
+            )
+        );
+    }
+
+    /**
+     * Shared logic for attempt_file and attempt_feedback:
+     *  - Create ResourceNode with the given ResourceType.
+     *  - Create ResourceFile with setFile() (Vich) using an UploadedFile from the Asset.
+     *  - Update resource_node_id AND clear asset_id in the corresponding table.
+     *  - If the Asset has no more references, delete it (DB + filesystem).
+     *
+     * @return bool true if the migration succeeded, false if it was skipped.
+     */
+    private function migrateSingleAssetToResourceNode(
+        AssetRepository $assetRepo,
+        string $context,
+        string $tableName,
+        string $rowId,
+        Asset $asset,
+        ResourceType $resourceType
+    ): bool {
+        $rowIdForLog = $this->formatIdForLog($rowId);
+
+        if (self::DRY_RUN) {
+            error_log(
+                sprintf(
+                    '[MIGRATION][DRY_RUN][%s] Would create ResourceNode/ResourceFile for table=%s rowId=%s (Asset id=%s)',
+                    $context,
+                    $tableName,
+                    $rowIdForLog,
+                    (string) $asset->getId()
+                )
+            );
+
+            return true;
+        }
+
+        // 1) Build an UploadedFile from the existing Asset file using streams.
+        $uploadedFile = $this->createUploadedFileFromAsset($assetRepo, $asset, $context);
+
+        if (null === $uploadedFile) {
+            error_log(
+                sprintf(
+                    '[MIGRATION][%s] Skipping rowId=%s because UploadedFile could not be created (Asset id=%s).',
+                    $context,
+                    $rowIdForLog,
+                    (string) $asset->getId()
+                )
+            );
+
+            return false;
+        }
+
+        try {
+            // 2) Create ResourceNode
+            $this->ensureEntityManagerIsOpen();
+
+            $node = new ResourceNode();
+            $node->setTitle($asset->getTitle() ?: 'attempt_' . $context);
+            $node->setResourceType($resourceType);
+            $this->entityManager->persist($node);
+
+            // 3) Create ResourceFile with Vich file
+            $resourceFile = new ResourceFile();
+            $resourceFile->setResourceNode($node);
+            $resourceFile->setFile($uploadedFile);
+            $this->entityManager->persist($resourceFile);
+
+            $this->entityManager->flush();
+
+            // 4) Update the link table: set resource_node_id AND clear asset_id
+            $this->connection->update(
+                $tableName,
+                [
+                    'resource_node_id' => $node->getId(),
+                    'asset_id' => null,
+                ],
+                ['id' => $rowId]
+            );
+
+            // 5) Clean up the temporary file if it still exists
+            $realPath = $uploadedFile->getRealPath();
+            if ($realPath && is_file($realPath)) {
+                @unlink($realPath);
+            }
+
+            // 6) Delete Asset if there are no more references in attempt_file/attempt_feedback
+            $this->cleanupAssetIfUnused($assetRepo, $asset);
+
+            error_log(
+                sprintf(
+                    '[MIGRATION][%s] Migrated rowId=%s to ResourceNode id=%d and cleared asset reference (Asset id=%s)',
+                    $context,
+                    $rowIdForLog,
+                    (int) $node->getId(),
+                    (string) $asset->getId()
+                )
+            );
+
+            return true;
+        } catch (Throwable $e) {
+            error_log(
+                sprintf(
+                    '[MIGRATION][%s] Failed to migrate rowId=%s (Asset id=%s): %s',
+                    $context,
+                    $rowIdForLog,
+                    (string) $asset->getId(),
+                    $e->getMessage()
+                )
+            );
+
+            $this->ensureEntityManagerIsOpen();
+
+            $realPath = $uploadedFile->getRealPath();
+            if ($realPath && is_file($realPath)) {
+                @unlink($realPath);
+            }
+
+            return false;
+        }
+    }
+
+    /**
+     * Clear asset_id for a single row and delete the Asset if there are no remaining references.
+     */
+    private function clearAssetReference(
+        AssetRepository $assetRepo,
+        string $context,
+        string $tableName,
+        string $rowId,
+        string $rowIdForLog,
+        Asset $asset
+    ): void {
+        // Clear asset_id for this row
+        $this->connection->update(
+            $tableName,
+            ['asset_id' => null],
+            ['id' => $rowId]
+        );
+
+        // Try to delete the Asset if it has no more references
+        $this->cleanupAssetIfUnused($assetRepo, $asset);
+
+        error_log(
+            sprintf(
+                '[MIGRATION][%s] Cleared asset_id for %s.id=%s (Asset id=%s, maybe deleted if unused).',
+                $context,
+                $tableName,
+                $rowIdForLog,
+                (string) $asset->getId()
+            )
+        );
+    }
+
+    /**
+     * Delete the Asset (DB + filesystem) if it is no longer referenced
+     * by attempt_file or attempt_feedback.
+     */
+    private function cleanupAssetIfUnused(AssetRepository $assetRepo, Asset $asset): void
+    {
+        $assetId = $asset->getId();
+
+        $refs = (int) $this->connection->fetchOne(
+            'SELECT
+                 (SELECT COUNT(*) FROM attempt_file WHERE asset_id = :asset_id) +
+                 (SELECT COUNT(*) FROM attempt_feedback WHERE asset_id = :asset_id) AS total_refs',
+            ['asset_id' => $assetId]
+        );
+
+        if ($refs > 0) {
+            // Still referenced somewhere, do not delete.
+            return;
+        }
+
+        // No more references: delete Asset from DB and filesystem
+        $assetRepo->delete($asset);
+
+        error_log(
+            sprintf(
+                '[MIGRATION][asset] Deleted Asset id=%s because it has no remaining references.',
+                $this->formatIdForLog($assetId)
+            )
+        );
+    }
+
+    /**
+     * Cleanup step after migration:
+     * Ensure that there are no resource_node_id values without a ResourceFile
+     * in attempt_file / attempt_feedback, and delete orphan ResourceNode entries.
+     */
+    private function cleanupOrphanNodesWithoutFile(): void
+    {
+        error_log('[MIGRATION][cleanup] Starting orphan ResourceNode cleanup for attempts.');
+
+        // 1) attempt_file: nodes without ResourceFile
+        $nodeIds = $this->connection->fetchFirstColumn(
+            'SELECT DISTINCT af.resource_node_id
+             FROM attempt_file af
+             LEFT JOIN resource_file rf ON rf.resource_node_id = af.resource_node_id
+             WHERE af.resource_node_id IS NOT NULL
+               AND rf.id IS NULL'
+        );
+
+        if (!empty($nodeIds)) {
+            // Remove resource_node_id from attempt_file
+            $this->connection->executeStatement(
+                'UPDATE attempt_file
+                 SET resource_node_id = NULL
+                 WHERE resource_node_id IN (?)',
+                [$nodeIds],
+                [\Doctrine\DBAL\Connection::PARAM_INT_ARRAY]
+            );
+
+            // Delete orphan ResourceNode entries that do not have any ResourceFile
+            $this->connection->executeStatement(
+                'DELETE rn
+                 FROM resource_node rn
+                 LEFT JOIN resource_file rf ON rf.resource_node_id = rn.id
+                 WHERE rn.id IN (?)
+                   AND rf.id IS NULL',
+                [$nodeIds],
+                [\Doctrine\DBAL\Connection::PARAM_INT_ARRAY]
+            );
+
+            error_log(
+                sprintf(
+                    '[MIGRATION][cleanup] Cleaned orphan attempt_file nodes without ResourceFile. Count=%d',
+                    \count($nodeIds)
+                )
+            );
+        } else {
+            error_log('[MIGRATION][cleanup] No orphan attempt_file nodes without ResourceFile found.');
+        }
+
+        // 2) attempt_feedback: nodes without ResourceFile
+        $fbNodeIds = $this->connection->fetchFirstColumn(
+            'SELECT DISTINCT af.resource_node_id
+             FROM attempt_feedback af
+             LEFT JOIN resource_file rf ON rf.resource_node_id = af.resource_node_id
+             WHERE af.resource_node_id IS NOT NULL
+               AND rf.id IS NULL'
+        );
+
+        if (!empty($fbNodeIds)) {
+            $this->connection->executeStatement(
+                'UPDATE attempt_feedback
+                 SET resource_node_id = NULL
+                 WHERE resource_node_id IN (?)',
+                [$fbNodeIds],
+                [\Doctrine\DBAL\Connection::PARAM_INT_ARRAY]
+            );
+
+            $this->connection->executeStatement(
+                'DELETE rn
+                 FROM resource_node rn
+                 LEFT JOIN resource_file rf ON rf.resource_node_id = rn.id
+                 WHERE rn.id IN (?)
+                   AND rf.id IS NULL',
+                [$fbNodeIds],
+                [\Doctrine\DBAL\Connection::PARAM_INT_ARRAY]
+            );
+
+            error_log(
+                sprintf(
+                    '[MIGRATION][cleanup] Cleaned orphan attempt_feedback nodes without ResourceFile. Count=%d',
+                    \count($fbNodeIds)
+                )
+            );
+        } else {
+            error_log('[MIGRATION][cleanup] No orphan attempt_feedback nodes without ResourceFile found.');
+        }
+    }
+
+    /**
+     * Create an UploadedFile from an Asset using Flysystem streams.
+     * This avoids loading the whole file content as a single string in memory.
+     */
+    private function createUploadedFileFromAsset(
+        AssetRepository $assetRepo,
+        Asset $asset,
+        string $context
+    ): ?UploadedFile {
+        $filePath = '';
+        $stream = null;
+        $tmpPath = false;
+
+        try {
+            $filePath = $assetRepo->getStorage()->resolveUri($asset);
+            $fs = $assetRepo->getFileSystem();
+
+            if (!$fs->fileExists($filePath)) {
+                error_log(
+                    sprintf(
+                        '[MIGRATION][%s] File does not exist in filesystem for Asset id=%s, path=%s',
+                        $context,
+                        (string) $asset->getId(),
+                        $filePath
+                    )
+                );
+
+                return null;
+            }
+
+            $stream = $fs->readStream($filePath);
+            if (false === $stream) {
+                error_log(
+                    sprintf(
+                        '[MIGRATION][%s] Could not open read stream for Asset id=%s, path=%s',
+                        $context,
+                        (string) $asset->getId(),
+                        $filePath
+                    )
+                );
+
+                return null;
+            }
+
+            $tmpPath = tempnam(sys_get_temp_dir(), 'asset_migrate_');
+            if (false === $tmpPath) {
+                error_log(
+                    sprintf(
+                        '[MIGRATION][%s] Failed to create temporary file for Asset id=%s',
+                        $context,
+                        (string) $asset->getId()
+                    )
+                );
+
+                fclose($stream);
+
+                return null;
+            }
+
+            $tmpHandle = fopen($tmpPath, 'wb');
+            if (false === $tmpHandle) {
+                error_log(
+                    sprintf(
+                        '[MIGRATION][%s] Failed to open temporary file for writing: %s (Asset id=%s)',
+                        $context,
+                        $tmpPath,
+                        (string) $asset->getId()
+                    )
+                );
+
+                fclose($stream);
+                @unlink($tmpPath);
+
+                return null;
+            }
+
+            stream_copy_to_stream($stream, $tmpHandle);
+            fclose($stream);
+            fclose($tmpHandle);
+
+            $originalName = $asset->getTitle() ?: basename($filePath);
+
+            $mimeType = 'application/octet-stream';
+            if (method_exists($asset, 'getMimeType') && null !== $asset->getMimeType()) {
+                $mimeType = (string) $asset->getMimeType();
+            }
+
+            // last argument "true" => test mode, do not check HTTP upload.
+            return new UploadedFile($tmpPath, $originalName, $mimeType, null, true);
+        } catch (Throwable $e) {
+            error_log(
+                sprintf(
+                    '[MIGRATION][%s] Exception while creating UploadedFile for Asset id=%s, path=%s: %s',
+                    $context,
+                    (string) $asset->getId(),
+                    $filePath,
+                    $e->getMessage()
+                )
+            );
+
+            if (is_resource($stream)) {
+                fclose($stream);
+            }
+
+            if (false !== $tmpPath && is_file($tmpPath)) {
+                @unlink($tmpPath);
+            }
+
+            return null;
+        }
+    }
+
+    /**
+     * Always get an EntityManager that is open and in sync with Doctrine.
+     * This is important if a previous flush closed the EM.
+     */
+    private function ensureEntityManagerIsOpen(): void
+    {
+        /** @var ManagerRegistry $doctrine */
+        $doctrine = $this->container->get('doctrine');
+
+        $em = $doctrine->getManager();
+
+        if (!$em->isOpen()) {
+            $doctrine->resetManager();
+            $em = $doctrine->getManager();
+
+            error_log('[MIGRATION] EntityManager was closed and has been reset.');
+        }
+
+        $this->entityManager = $em;
+    }
+
+    /**
+     * Always get an AssetRepository bound to the current EntityManager.
+     */
+    private function getAssetRepository(): AssetRepository
+    {
+        /** @var AssetRepository $assetRepo */
+        $assetRepo = $this->container->get(AssetRepository::class);
+
+        return $assetRepo;
+    }
+
+    /**
+     * Format any kind of primary key / UUID value for logging.
+     * - If it is a binary string, log hex.
+     * - If it is an int, log the numeric value.
+     * - If it is null, log "NULL".
+     */
+    private function formatIdForLog(mixed $value): string
+    {
+        if (null === $value) {
+            return 'NULL';
+        }
+
+        if (\is_string($value)) {
+            return bin2hex($value);
+        }
+
+        return (string) $value;
+    }
+}
diff --git a/src/CoreBundle/Tool/Exercise.php b/src/CoreBundle/Tool/Exercise.php
index 3f6a928aeb6..c81bfbe44ab 100644
--- a/src/CoreBundle/Tool/Exercise.php
+++ b/src/CoreBundle/Tool/Exercise.php
@@ -6,6 +6,8 @@
 
 namespace Chamilo\CoreBundle\Tool;
 
+use Chamilo\CoreBundle\Entity\AttemptFeedback;
+use Chamilo\CoreBundle\Entity\AttemptFile;
 use Chamilo\CourseBundle\Entity\CQuiz;
 use Chamilo\CourseBundle\Entity\CQuizCategory;
 use Chamilo\CourseBundle\Entity\CQuizQuestion;
@@ -45,6 +47,8 @@ public function getResourceTypes(): ?array
             'questions' => CQuizQuestion::class,
             'question_categories' => CQuizQuestionCategory::class,
             'exercise_categories' => CQuizCategory::class,
+            'attempt_file'        => AttemptFile::class,
+            'attempt_feedback'    => AttemptFeedback::class,
         ];
     }
 }