@hed-hog/lms 0.0.358 → 0.0.364

package/src/course/lms-setting.controller.ts

@@ -1,6 +1,7 @@
+import { Role } from '@hed-hog/api';
+import { PrismaService } from '@hed-hog/api-prisma';
 import { SettingService } from '@hed-hog/core';
 import { Controller, forwardRef, Get, Inject } from '@nestjs/common';
-import { Role } from '@hed-hog/api';
 
 @Role()
 @Controller('lms/settings')
@@ -8,6 +9,8 @@ export class LmsSettingController {
   constructor(
     @Inject(forwardRef(() => SettingService))
     private readonly settingService: SettingService,
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prismaService: PrismaService,
   ) {}
 
   @Get()
@@ -18,13 +21,37 @@ export class LmsSettingController {
       'lms-audio-transcription-enabled',
       'lms-youtube-provider-enabled',
       'lms-vimeo-provider-enabled',
+      'lms-bulk-upload-storage-profile-id',
+      'lms-bulk-upload-lambda-role-arn',
+      'lms-bulk-upload-sts-duration-seconds',
     ]);
+
+    const bulkUploadStorageProfileId =
+      Number(v['lms-bulk-upload-storage-profile-id'] || 0) || null;
+
+    let bulkUploadBucketName = '';
+    if (bulkUploadStorageProfileId) {
+      const profile = await this.prismaService.integration_profile.findUnique({
+        where: { id: bulkUploadStorageProfileId },
+        select: { config: true },
+      });
+      bulkUploadBucketName = String((profile?.config as any)?.bucket ?? '').trim();
+    }
+
     return {
       videoConversionEnabled: v['lms-video-conversion-enabled'] !== false,
       imageExtractionEnabled: v['lms-image-extraction-enabled'] !== false,
       transcriptionEnabled: v['lms-audio-transcription-enabled'] !== false,
       youtubeEnabled: v['lms-youtube-provider-enabled'] !== false,
       vimeoEnabled: v['lms-vimeo-provider-enabled'] !== false,
+      bulkUploadStorageProfileId,
+      bulkUploadBucketName,
+      bulkUploadLambdaRoleArn:
+        typeof v['lms-bulk-upload-lambda-role-arn'] === 'string'
+          ? v['lms-bulk-upload-lambda-role-arn'].trim()
+          : '',
+      bulkUploadStsDurationSeconds:
+        Number(v['lms-bulk-upload-sts-duration-seconds'] || 3600) || 3600,
     };
   }
 }

package/src/lesson-xp-map/dto/create-lesson-xp-map.dto.ts

@@ -0,0 +1,17 @@
+import { IsInt, IsOptional, IsString, MaxLength, Min } from 'class-validator';
+
+export class CreateLessonXpMapDto {
+  @IsInt()
+  @Min(1)
+  courseLessonId: number;
+
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  version?: number;
+
+  @IsOptional()
+  @IsString()
+  @MaxLength(100)
+  aiModelVersion?: string | null;
+}

package/src/lesson-xp-map/dto/create-lesson-xp-segment.dto.ts

@@ -0,0 +1,102 @@
+import { Type } from 'class-transformer';
+import {
+  IsArray,
+  IsBoolean,
+  IsEnum,
+  IsInt,
+  IsNumber,
+  IsOptional,
+  IsString,
+  Max,
+  Min,
+  ValidateNested,
+} from 'class-validator';
+
+export class SegmentAreaDto {
+  @IsInt()
+  @Min(1)
+  xpAreaId: number;
+
+  @IsNumber()
+  @Min(0.01)
+  @Max(100)
+  weightPercent: number;
+}
+
+export class SegmentSkillDto {
+  @IsInt()
+  @Min(1)
+  xpSkillId: number;
+
+  @IsNumber()
+  @Min(0.01)
+  @Max(100)
+  weightPercent: number;
+}
+
+export class SegmentLearningTypeDto {
+  @IsInt()
+  @Min(1)
+  xpLearningTypeId: number;
+
+  @IsNumber()
+  @Min(0.01)
+  @Max(100)
+  weightPercent: number;
+}
+
+export const SEGMENT_DIFFICULTY_VALUES = ['easy', 'medium', 'hard', 'expert'] as const;
+export type SegmentDifficulty = (typeof SEGMENT_DIFFICULTY_VALUES)[number];
+
+export class CreateLessonXpSegmentDto {
+  @IsNumber()
+  @Min(0)
+  startSeconds: number;
+
+  @IsNumber()
+  @Min(0)
+  endSeconds: number;
+
+  @IsInt()
+  @Min(0)
+  xpValue: number;
+
+  @IsEnum(SEGMENT_DIFFICULTY_VALUES)
+  difficulty: SegmentDifficulty;
+
+  @IsBoolean()
+  shouldGrantXp: boolean;
+
+  @IsOptional()
+  @IsString()
+  aiSummary?: string | null;
+
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  @Max(1)
+  aiConfidence?: number | null;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  sortOrder?: number;
+
+  @IsOptional()
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => SegmentAreaDto)
+  areas?: SegmentAreaDto[];
+
+  @IsOptional()
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => SegmentSkillDto)
+  skills?: SegmentSkillDto[];
+
+  @IsOptional()
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => SegmentLearningTypeDto)
+  learningTypes?: SegmentLearningTypeDto[];
+}

package/src/lesson-xp-map/dto/review-lesson-xp-map.dto.ts

@@ -0,0 +1,7 @@
+import { IsOptional, IsString } from 'class-validator';
+
+export class RejectLessonXpMapDto {
+  @IsOptional()
+  @IsString()
+  reviewNotes?: string;
+}

package/src/lesson-xp-map/dto/update-lesson-xp-map.dto.ts

@@ -0,0 +1,36 @@
+import { IsEnum, IsInt, IsOptional, IsString, MaxLength, Min } from 'class-validator';
+
+export const LESSON_XP_MAP_STATUS_VALUES = [
+  'pending',
+  'processing',
+  'ready',
+  'needs_review',
+  'approved',
+  'rejected',
+] as const;
+
+export type LessonXpMapStatus = (typeof LESSON_XP_MAP_STATUS_VALUES)[number];
+
+export class UpdateLessonXpMapDto {
+  @IsOptional()
+  @IsEnum(LESSON_XP_MAP_STATUS_VALUES)
+  status?: LessonXpMapStatus;
+
+  @IsOptional()
+  @IsString()
+  reviewNotes?: string | null;
+
+  @IsOptional()
+  @IsString()
+  @MaxLength(100)
+  aiModelVersion?: string | null;
+
+  @IsOptional()
+  @IsString()
+  processingError?: string | null;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  totalXp?: number;
+}

package/src/lesson-xp-map/dto/update-lesson-xp-segment.dto.ts

@@ -0,0 +1,78 @@
+import { Type } from 'class-transformer';
+import {
+  IsArray,
+  IsBoolean,
+  IsEnum,
+  IsInt,
+  IsNumber,
+  IsOptional,
+  IsString,
+  Max,
+  Min,
+  ValidateNested,
+} from 'class-validator';
+import {
+  SEGMENT_DIFFICULTY_VALUES,
+  SegmentAreaDto,
+  SegmentLearningTypeDto,
+  SegmentSkillDto,
+  type SegmentDifficulty,
+} from './create-lesson-xp-segment.dto';
+
+export class UpdateLessonXpSegmentDto {
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  startSeconds?: number;
+
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  endSeconds?: number;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  xpValue?: number;
+
+  @IsOptional()
+  @IsEnum(SEGMENT_DIFFICULTY_VALUES)
+  difficulty?: SegmentDifficulty;
+
+  @IsOptional()
+  @IsBoolean()
+  shouldGrantXp?: boolean;
+
+  @IsOptional()
+  @IsString()
+  aiSummary?: string | null;
+
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  @Max(1)
+  aiConfidence?: number | null;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  sortOrder?: number;
+
+  @IsOptional()
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => SegmentAreaDto)
+  areas?: SegmentAreaDto[];
+
+  @IsOptional()
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => SegmentSkillDto)
+  skills?: SegmentSkillDto[];
+
+  @IsOptional()
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => SegmentLearningTypeDto)
+  learningTypes?: SegmentLearningTypeDto[];
+}

package/src/lesson-xp-map/lesson-xp-ai-calculation.service.ts

@@ -0,0 +1,396 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { buildAiConfigFromIntegration, SettingService } from '@hed-hog/core';
+import { DatabaseQueueProvider, IJobHandler, QueueHandlerRegistry } from '@hed-hog/queue';
+import {
+    BadRequestException,
+    forwardRef,
+    Inject,
+    Injectable,
+    Logger,
+    OnModuleInit,
+} from '@nestjs/common';
+import axios from 'axios';
+
+type XpSegmentAiResult = {
+  startSeconds: number;
+  endSeconds: number;
+  xpValue: number;
+  difficulty: 'easy' | 'medium' | 'hard' | 'expert';
+  shouldGrantXp: boolean;
+  aiSummary: string;
+  aiConfidence: number;
+  areas: { xpAreaId: number; weightPercent: number }[];
+  skills: { xpSkillId: number; weightPercent: number }[];
+  learningTypes: { xpLearningTypeId: number; weightPercent: number }[];
+};
+
+@Injectable()
+export class LessonXpAiCalculationService implements OnModuleInit, IJobHandler {
+  private readonly logger = new Logger(LessonXpAiCalculationService.name);
+
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prisma: PrismaService,
+    @Inject(forwardRef(() => SettingService))
+    private readonly settingService: SettingService,
+    @Inject(forwardRef(() => QueueHandlerRegistry))
+    private readonly registry: QueueHandlerRegistry,
+    @Inject(forwardRef(() => DatabaseQueueProvider))
+    private readonly dbQueue: DatabaseQueueProvider,
+  ) {}
+
+  onModuleInit() {
+    this.registry.register('lms.lesson.xp.calculate', this);
+    this.logger.log('Registered handler for "lms.lesson.xp.calculate"');
+  }
+
+  async triggerCalculation(lessonId: number, userId: number) {
+    const segments = await this.prisma.$queryRawUnsafe<{ id: number }[]>(
+      `SELECT id FROM course_lesson_transcription_segment WHERE course_lesson_id = $1::int LIMIT 1`,
+      lessonId,
+    );
+
+    if (!segments.length) {
+      throw new BadRequestException(
+        'Esta aula ainda não possui transcrição. Gere ou importe a transcrição antes de calcular o XP.',
+      );
+    }
+
+    const existing = await this.prisma.$queryRawUnsafe<{ id: number }[]>(
+      `SELECT id FROM lesson_xp_map WHERE course_lesson_id = $1::int`,
+      lessonId,
+    );
+
+    let mapId: number;
+
+    if (existing.length) {
+      mapId = existing[0].id;
+      await this.prisma.$executeRawUnsafe(
+        `UPDATE lesson_xp_map
+            SET status = 'processing'::lesson_xp_map_status_d4e5f6a7b8_enum,
+                processing_error = NULL,
+                updated_at = NOW()
+          WHERE id = $1`,
+        mapId,
+      );
+    } else {
+      const created = await this.prisma.$queryRawUnsafe<{ id: number }[]>(
+        `INSERT INTO lesson_xp_map (course_lesson_id, version, total_xp, status, created_at, updated_at)
+         VALUES ($1, 1, 0, 'processing'::lesson_xp_map_status_d4e5f6a7b8_enum, NOW(), NOW())
+         RETURNING id`,
+        lessonId,
+      );
+      mapId = created[0].id;
+    }
+
+    try {
+      await this.dbQueue.enqueue({
+        type: 'lms.lesson.xp.calculate',
+        queueName: 'lms.lesson.xp.calculate',
+        payload: { lessonId, mapId, userId },
+        maxAttempts: 3,
+        sourceModule: 'lms',
+        sourceEntity: 'course_lesson',
+        sourceEntityId: String(lessonId),
+        userId,
+      });
+    } catch (err: any) {
+      // P2002 = unique constraint — a job for this lesson is already queued/running
+      if (err?.code !== 'P2002') throw err;
+    }
+
+    const rows = await this.prisma.$queryRawUnsafe<any[]>(
+      `SELECT
+          m.id,
+          m.course_lesson_id AS "courseLessonId",
+          m.version,
+          m.total_xp AS "totalXp",
+          m.status::text AS status,
+          m.generated_at::text AS "generatedAt",
+          m.processing_error AS "processingError",
+          m.created_at::text AS "createdAt",
+          m.updated_at::text AS "updatedAt"
+        FROM lesson_xp_map m WHERE m.id = $1`,
+      mapId,
+    );
+    return { ...rows[0], segments: [] };
+  }
+
+  async handle(job: {
+    id: number;
+    type: string;
+    queue_name: string;
+    payload: Record<string, any>;
+    attempts: number;
+    max_attempts: number;
+  }): Promise<void> {
+    const { lessonId, mapId } = job.payload as { lessonId: number; mapId: number };
+
+    this.logger.log(`Starting XP calculation for lesson ${lessonId}, map ${mapId}`);
+
+    try {
+      const transcriptionRows = await this.prisma.$queryRawUnsafe<
+        { startSeconds: number; endSeconds: number; text: string }[]
+      >(
+        `SELECT start_seconds::float AS "startSeconds", end_seconds::float AS "endSeconds", text
+           FROM course_lesson_transcription_segment
+          WHERE course_lesson_id = $1
+          ORDER BY start_seconds ASC`,
+        lessonId,
+      );
+
+      if (!transcriptionRows.length) {
+        await this.markError(mapId, 'Aula sem segmentos de transcrição.');
+        return;
+      }
+
+      const [areas, skills, learningTypes] = await Promise.all([
+        this.prisma.$queryRawUnsafe<{ id: number; slug: string; name: string }[]>(
+          `SELECT a.id, a.slug, COALESCE(al.name, a.slug) AS name
+             FROM xp_area a
+             LEFT JOIN xp_area_locale al ON al.xp_area_id = a.id
+             LEFT JOIN locale l ON l.id = al.locale_id AND l.code = 'pt'
+            WHERE a.status = 'active'
+            ORDER BY a.sort_order ASC`,
+        ),
+        this.prisma.$queryRawUnsafe<{ id: number; slug: string; name: string; areaId: number | null }[]>(
+          `SELECT s.id, s.slug, COALESCE(sl.name, s.slug) AS name, s.xp_area_id AS "areaId"
+             FROM xp_skill s
+             LEFT JOIN xp_skill_locale sl ON sl.xp_skill_id = s.id
+             LEFT JOIN locale l ON l.id = sl.locale_id AND l.code = 'pt'
+            WHERE s.status = 'active'
+            ORDER BY s.sort_order ASC`,
+        ),
+        this.prisma.$queryRawUnsafe<{ id: number; slug: string; name: string; multiplier: number }[]>(
+          `SELECT lt.id, lt.slug, COALESCE(ltl.name, lt.slug) AS name, lt.multiplier::float AS multiplier
+             FROM xp_learning_type lt
+             LEFT JOIN xp_learning_type_locale ltl ON ltl.xp_learning_type_id = lt.id
+             LEFT JOIN locale l ON l.id = ltl.locale_id AND l.code = 'pt'
+            WHERE lt.status = 'active'
+            ORDER BY lt.sort_order ASC`,
+        ),
+      ]);
+
+      const settings = await this.settingService.getSettingValues(['ai-openai-profile-id']);
+      const profileId = Number(settings['ai-openai-profile-id']);
+
+      if (!profileId) {
+        await this.markError(mapId, 'Perfil de IA OpenAI não configurado em Settings → AI.');
+        return;
+      }
+
+      const profile = await (this.prisma as any).integration_profile.findUnique({
+        where: { id: profileId },
+        include: { integration_provider: { select: { slug: true } } },
+      });
+
+      if (!profile) {
+        await this.markError(mapId, 'Perfil de IA não encontrado.');
+        return;
+      }
+
+      const aiConfig = buildAiConfigFromIntegration(profile.integration_provider.slug, profile.config);
+
+      const transcriptionText = transcriptionRows
+        .map((s) => {
+          const start = this.formatSeconds(s.startSeconds);
+          const end = this.formatSeconds(s.endSeconds);
+          return `[${start} - ${end}] ${s.text}`;
+        })
+        .join('\n');
+
+      const prompt = this.buildPrompt(transcriptionText, areas, skills, learningTypes);
+
+      const response = await axios.post(
+        'https://api.openai.com/v1/chat/completions',
+        {
+          model: 'gpt-4o',
+          temperature: 0.2,
+          response_format: { type: 'json_object' },
+          messages: [
+            {
+              role: 'system',
+              content:
+                'Você é um especialista em design instrucional e mapeia competências técnicas de aulas de programação. Responda apenas com JSON válido.',
+            },
+            { role: 'user', content: prompt },
+          ],
+        },
+        {
+          headers: { Authorization: `Bearer ${aiConfig.apiKey}`, 'Content-Type': 'application/json' },
+          timeout: 120_000,
+        },
+      );
+
+      const rawContent: string = response.data?.choices?.[0]?.message?.content ?? '{}';
+      let parsed: { segments?: any[] };
+      try {
+        parsed = JSON.parse(rawContent);
+      } catch {
+        await this.markError(mapId, `IA retornou JSON inválido: ${rawContent.slice(0, 200)}`);
+        return;
+      }
+
+      const rawSegments: any[] = Array.isArray(parsed.segments) ? parsed.segments : [];
+      const areaIds = new Set(areas.map((a) => a.id));
+      const skillIds = new Set(skills.map((s) => s.id));
+      const ltIds = new Set(learningTypes.map((l) => l.id));
+
+      const validSegments: XpSegmentAiResult[] = rawSegments
+        .map((s: any) => ({
+          startSeconds: Number(s.startSeconds) || 0,
+          endSeconds: Number(s.endSeconds) || 60,
+          xpValue: Math.min(Math.max(Math.round(Number(s.xpValue) || 0), 0), 200),
+          difficulty: (['easy', 'medium', 'hard', 'expert'] as const).includes(s.difficulty)
+            ? s.difficulty
+            : 'medium',
+          shouldGrantXp: Boolean(s.shouldGrantXp),
+          aiSummary: String(s.aiSummary || '').slice(0, 500),
+          aiConfidence: Math.min(Math.max(Number(s.aiConfidence) || 0.5, 0), 1),
+          areas: (Array.isArray(s.areas) ? s.areas : [])
+            .filter((a: any) => areaIds.has(Number(a.xpAreaId)))
+            .map((a: any) => ({ xpAreaId: Number(a.xpAreaId), weightPercent: Number(a.weightPercent) || 0 })),
+          skills: (Array.isArray(s.skills) ? s.skills : [])
+            .filter((sk: any) => skillIds.has(Number(sk.xpSkillId)))
+            .map((sk: any) => ({ xpSkillId: Number(sk.xpSkillId), weightPercent: Number(sk.weightPercent) || 0 })),
+          learningTypes: (Array.isArray(s.learningTypes) ? s.learningTypes : [])
+            .filter((lt: any) => ltIds.has(Number(lt.xpLearningTypeId)))
+            .map((lt: any) => ({
+              xpLearningTypeId: Number(lt.xpLearningTypeId),
+              weightPercent: Number(lt.weightPercent) || 0,
+            })),
+        }))
+        .filter((s) => s.endSeconds > s.startSeconds);
+
+      await this.prisma.$executeRawUnsafe(
+        `DELETE FROM lesson_xp_segment WHERE lesson_xp_map_id = $1`,
+        mapId,
+      );
+
+      for (let i = 0; i < validSegments.length; i++) {
+        const seg = validSegments[i];
+        const inserted = await this.prisma.$queryRawUnsafe<{ id: number }[]>(
+          `INSERT INTO lesson_xp_segment
+             (lesson_xp_map_id, start_seconds, end_seconds, xp_value, difficulty,
+              should_grant_xp, ai_summary, ai_confidence, sort_order, created_at, updated_at)
+           VALUES ($1, $2, $3, $4, $5::lesson_xp_segment_difficulty_e5f6a7b8c9_enum,
+                   $6, $7, $8, $9, NOW(), NOW())
+           RETURNING id`,
+          mapId, seg.startSeconds, seg.endSeconds, seg.xpValue,
+          seg.difficulty, seg.shouldGrantXp, seg.aiSummary,
+          seg.aiConfidence, i,
+        );
+        const segId = inserted[0].id;
+
+        for (const area of seg.areas) {
+          await this.prisma.$executeRawUnsafe(
+            `INSERT INTO lesson_xp_segment_area (lesson_xp_segment_id, xp_area_id, weight_percent, created_at, updated_at)
+             VALUES ($1, $2, $3, NOW(), NOW())`,
+            segId, area.xpAreaId, area.weightPercent,
+          );
+        }
+        for (const skill of seg.skills) {
+          await this.prisma.$executeRawUnsafe(
+            `INSERT INTO lesson_xp_segment_skill (lesson_xp_segment_id, xp_skill_id, weight_percent, created_at, updated_at)
+             VALUES ($1, $2, $3, NOW(), NOW())`,
+            segId, skill.xpSkillId, skill.weightPercent,
+          );
+        }
+        for (const lt of seg.learningTypes) {
+          await this.prisma.$executeRawUnsafe(
+            `INSERT INTO lesson_xp_segment_learning_type (lesson_xp_segment_id, xp_learning_type_id, weight_percent, created_at, updated_at)
+             VALUES ($1, $2, $3, NOW(), NOW())`,
+            segId, lt.xpLearningTypeId, lt.weightPercent,
+          );
+        }
+      }
+
+      await this.prisma.$executeRawUnsafe(
+        `UPDATE lesson_xp_map
+            SET status = 'ready'::lesson_xp_map_status_d4e5f6a7b8_enum,
+                generated_at = NOW(),
+                ai_model_version = 'gpt-4o',
+                processing_error = NULL,
+                total_xp = COALESCE(
+                  (SELECT SUM(xp_value) FROM lesson_xp_segment
+                    WHERE lesson_xp_map_id = $1 AND should_grant_xp = true),
+                  0
+                ),
+                updated_at = NOW()
+          WHERE id = $1`,
+        mapId,
+      );
+
+      this.logger.log(
+        `XP calculation done for lesson ${lessonId}: ${validSegments.length} segments saved.`,
+      );
+    } catch (err: any) {
+      this.logger.error(`XP calculation failed for lesson ${lessonId}: ${err?.message}`);
+      await this.markError(mapId, err?.message ?? 'Erro desconhecido');
+    }
+  }
+
+  private async markError(mapId: number, message: string) {
+    await this.prisma.$executeRawUnsafe(
+      `UPDATE lesson_xp_map
+          SET status = 'needs_review'::lesson_xp_map_status_d4e5f6a7b8_enum,
+              processing_error = $1,
+              updated_at = NOW()
+        WHERE id = $2`,
+      message.slice(0, 1000),
+      mapId,
+    );
+  }
+
+  private buildPrompt(
+    transcription: string,
+    areas: { id: number; slug: string; name: string }[],
+    skills: { id: number; slug: string; name: string; areaId: number | null }[],
+    learningTypes: { id: number; slug: string; name: string; multiplier: number }[],
+  ): string {
+    return `Analise a transcrição abaixo e mapeie as competências técnicas de cada segmento de ~60 segundos.
+
+CATÁLOGO DE ÁREAS MACRO (use APENAS estes IDs):
+${JSON.stringify(areas.map((a) => ({ id: a.id, slug: a.slug, name: a.name })))}
+
+CATÁLOGO DE SKILLS (use APENAS estes IDs):
+${JSON.stringify(skills.map((s) => ({ id: s.id, slug: s.slug, name: s.name, areaId: s.areaId })))}
+
+CATÁLOGO DE TIPOS DE APRENDIZADO (use APENAS estes IDs):
+${JSON.stringify(learningTypes.map((l) => ({ id: l.id, slug: l.slug, name: l.name, multiplier: l.multiplier })))}
+
+TRANSCRIÇÃO DA AULA:
+${transcription}
+
+Retorne um JSON com a chave "segments" contendo um array onde cada item representa um segmento de ~60s:
+{
+  "segments": [
+    {
+      "startSeconds": 0,
+      "endSeconds": 60,
+      "xpValue": 10,
+      "difficulty": "medium",
+      "shouldGrantXp": true,
+      "aiSummary": "Resumo curto do conteúdo do segmento",
+      "aiConfidence": 0.9,
+      "areas": [{"xpAreaId": 1, "weightPercent": 70}, {"xpAreaId": 2, "weightPercent": 30}],
+      "skills": [{"xpSkillId": 5, "weightPercent": 100}],
+      "learningTypes": [{"xpLearningTypeId": 2, "weightPercent": 100}]
+    }
+  ]
+}
+
+Regras obrigatórias:
+- Use APENAS IDs do catálogo acima. Nunca invente IDs.
+- xpValue entre 0 e 50 por segmento. Segmentos com conteúdo irrelevante (intro, pausa, avisos) devem ter shouldGrantXp=false e xpValue=0.
+- Os weightPercent de areas, skills e learningTypes devem somar 100 cada.
+- difficulty: easy (conceitos básicos), medium (aplicação), hard (avançado), expert (arquitetura/otimização).
+- aiConfidence: 0 a 1, indica certeza do mapeamento.`;
+  }
+
+  private formatSeconds(s: number): string {
+    const m = Math.floor(s / 60);
+    const sec = Math.floor(s % 60);
+    return `${String(m).padStart(2, '0')}:${String(sec).padStart(2, '0')}`;
+  }
+}