@runnerpro/backend 1.34.0 → 1.35.0

package/lib/cjs/mediaProcessing/correccionTranscripcion.js

@@ -0,0 +1,313 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizar = exports.GLOSARIO_RUNNING = exports.corregirTranscripcion = void 0;
+// ✅ Capa de corrección de transcripciones: un modelo de texto propone, el código decide.
+//
+// Sin filtro esta capa es peligrosa: en pruebas convirtió «Bernabéu» en «RunnerPro», «La Elipa» en
+// «10K» y «zona» en «suegra». Con el filtro de abajo solo pasan sustituciones cuyo reemplazo es jerga
+// de running o un nombre del contexto, que suenan parecido a lo que había y que no tocan números:
+// 10 aceptadas (todas correctas) y 18 rechazadas sobre 72 transcripciones reales (06-sep-2026).
+const index_1 = require("../prompt/index");
+// ✅ Vocabulario que el reconocedor destroza si no se le ayuda (fartlek → «Farley», Hyrox → «Airox»,
+// Garmin → «garam»). Alimenta la phraseList de Speech y el filtro de esta capa. Cada palabra nueva
+// abre una puerta más al filtro: solo jerga y marcas, nunca palabras comunes.
+const GLOSARIO_RUNNING = [
+    'fartlek',
+    'series',
+    'rodaje',
+    'tirada larga',
+    'progresivo',
+    'tempo',
+    'umbral',
+    'zona 2',
+    'VAM',
+    'VO2max',
+    'cuestas',
+    'cadencia',
+    'pulsaciones',
+    'pulsómetro',
+    'banda de pecho',
+    'RPE',
+    'agujetas',
+    'sobrecarga',
+    'fascitis plantar',
+    'periostitis',
+    'cintilla iliotibial',
+    'tendón de Aquiles',
+    'isquiotibiales',
+    'cuádriceps',
+    'gemelo',
+    'sóleo',
+    'glúteo',
+    'psoas',
+    'lumbar',
+    'cervical',
+    'Garmin',
+    'Garmin Connect',
+    'Suunto',
+    'Polar',
+    'Coros',
+    'Strava',
+    'TrainingPeaks',
+    'Hyrox',
+    'DEKA',
+    'media maratón',
+    'maratón',
+    'trail',
+    'RunnerPro',
+    'Bizum',
+    'Revolut',
+    'prueba de esfuerzo',
+    'fisio',
+    'hidratos',
+    'proteína',
+    'Enantyum',
+    'ibuprofeno',
+    'Aquarius',
+];
+exports.GLOSARIO_RUNNING = GLOSARIO_RUNNING;
+// ✅ Por debajo de esto no hay nada que corregir («Gracias Rubén»)
+const CORRECCION_MIN_CARACTERES = 15;
+// ✅ Si el modelo no contesta a tiempo se guarda la transcripción sin corregir: esta capa nunca bloquea
+const CORRECCION_TIMEOUT_MS = 15000;
+// ✅ Parecido mínimo entre lo transcrito y el reemplazo ("farley" → "fartlek" da 0,43; "zona" → "suegra" da 0,17)
+const SIMILITUD_MINIMA = 0.4;
+/**
+ * Normaliza para comparar: minúsculas, sin acentos, solo letras, dígitos y espacios
+ *
+ * @param texto - Texto de entrada
+ * @returns Texto normalizado
+ */
+const normalizar = (texto) => (texto || '')
+    .toLowerCase()
+    .normalize('NFD')
+    .replace(/[̀-ͯ]/g, '')
+    .replace(/[^a-z0-9ñ ]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+exports.normalizar = normalizar;
+const palabras = (texto) => normalizar(texto).split(' ').filter(Boolean);
+const levenshtein = (a, b) => {
+    if (!a.length)
+        return b.length;
+    if (!b.length)
+        return a.length;
+    let previa = Array.from({ length: b.length + 1 }, (_, j) => j);
+    for (let i = 1; i <= a.length; i++) {
+        const actual = [i];
+        for (let j = 1; j <= b.length; j++) {
+            actual[j] = Math.min(previa[j] + 1, actual[j - 1] + 1, previa[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+        }
+        previa = actual;
+    }
+    return previa[b.length];
+};
+const similitud = (a, b) => 1 - levenshtein(a, b) / Math.max(a.length, b.length, 1);
+/**
+ * Alinea dos listas de palabras (subsecuencia común más larga) y devuelve los tramos que difieren,
+ * con su posición en la lista original
+ *
+ * @param original - Palabras normalizadas de la transcripción
+ * @param propuesta - Palabras normalizadas de la propuesta del modelo
+ * @returns Tramos distintos: palabras originales, palabras propuestas y rango [desde, hasta) en `original`
+ */
+const alinear = (original, propuesta) => {
+    const lcs = Array.from({ length: original.length + 1 }, () => new Array(propuesta.length + 1).fill(0));
+    for (let i = original.length - 1; i >= 0; i--) {
+        for (let j = propuesta.length - 1; j >= 0; j--) {
+            lcs[i][j] = original[i] === propuesta[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+        }
+    }
+    const tramos = [];
+    let i = 0;
+    let j = 0;
+    let pendiente = null;
+    const cerrar = () => {
+        if (pendiente && (pendiente.de.length || pendiente.a.length))
+            tramos.push(pendiente);
+        pendiente = null;
+    };
+    const abrir = () => {
+        if (!pendiente)
+            pendiente = { de: [], a: [], desde: i, hasta: i };
+    };
+    while (i < original.length && j < propuesta.length) {
+        if (original[i] === propuesta[j]) {
+            cerrar();
+            i++;
+            j++;
+        }
+        else if (lcs[i + 1][j] >= lcs[i][j + 1]) {
+            abrir();
+            pendiente.de.push(original[i]);
+            i++;
+            pendiente.hasta = i;
+        }
+        else {
+            abrir();
+            pendiente.a.push(propuesta[j]);
+            j++;
+        }
+    }
+    while (i < original.length) {
+        abrir();
+        pendiente.de.push(original[i]);
+        i++;
+        pendiente.hasta = i;
+    }
+    while (j < propuesta.length) {
+        abrir();
+        pendiente.a.push(propuesta[j]);
+        j++;
+    }
+    cerrar();
+    return tramos;
+};
+/**
+ * Forma escrita de un reemplazo aceptado: la entrada del glosario o el nombre que coincide, y si no, tal cual
+ *
+ * @param reemplazo - Palabras normalizadas del reemplazo
+ * @param canonicas - Mapa forma normalizada → forma escrita (glosario + nombres)
+ * @returns Reemplazo con mayúsculas y acentos correctos
+ */
+const formaEscrita = (reemplazo, canonicas) => {
+    const entera = canonicas.get(reemplazo.join(' '));
+    if (entera)
+        return entera;
+    return reemplazo.map((palabra) => canonicas.get(palabra) || canonicas.get(palabra.replace(/s$/, '')) || palabra).join(' ');
+};
+/**
+ * Aplica sobre el texto original (conservando puntuación y mayúsculas) las sustituciones aceptadas.
+ * Si la tokenización del original no casa con sus palabras normalizadas, no se toca nada.
+ *
+ * @param texto - Transcripción original
+ * @param tramos - Tramos aceptados, con su rango de palabras en el original
+ * @param canonicas - Mapa forma normalizada → forma escrita
+ * @returns Texto corregido
+ */
+const aplicar = (texto, tramos, canonicas) => {
+    const tokens = texto.match(/[\p{L}\p{N}]+|[^\p{L}\p{N}]+/gu) || [];
+    const indicesPalabra = [];
+    tokens.forEach((token, idx) => {
+        if (/[\p{L}\p{N}]/u.test(token))
+            indicesPalabra.push(idx);
+    });
+    if (indicesPalabra.length !== palabras(texto).length)
+        return texto;
+    const salida = [...tokens];
+    for (const tramo of tramos) {
+        const primero = indicesPalabra[tramo.desde];
+        const ultimo = indicesPalabra[tramo.hasta - 1];
+        if (primero === undefined || ultimo === undefined)
+            continue;
+        let reemplazo = formaEscrita(tramo.a, canonicas);
+        if (/^\p{Lu}/u.test(tokens[primero]) && /^\p{Ll}/u.test(reemplazo))
+            reemplazo = reemplazo[0].toUpperCase() + reemplazo.slice(1);
+        salida[primero] = reemplazo;
+        for (let k = primero + 1; k <= ultimo; k++)
+            salida[k] = '';
+    }
+    return salida.join('');
+};
+const nombreCliente = (contexto) => { var _a; return (((_a = contexto.nombres) === null || _a === void 0 ? void 0 : _a[0]) || 'un cliente').trim(); };
+const promptCorreccion = (texto, contexto) => {
+    const entrenadores = (contexto.nombres || []).slice(1).filter(Boolean).join(' y ') || 'su entrenador';
+    const previos = (contexto.previos || [])
+        .map((mensaje) => `- ${mensaje.quien === 'cliente' ? nombreCliente(contexto) : 'Entrenador'}: ${(mensaje.texto || '').replace(/\s+/g, ' ').trim()}`)
+        .join('\n');
+    return `Eres un corrector de transcripciones automáticas. Te doy la transcripción de una nota de voz que ${nombreCliente(contexto)} (cliente) manda a su entrenador (${entrenadores}) en RunnerPro, una app de running.
+
+Tu ÚNICA tarea: corregir palabras que el transcriptor haya escrito mal por sonar parecidas a un nombre propio, una marca o un término de running. Ejemplos: "Farley" → "fartlek", "garam" → "Garmin", "Airox" → "Hyrox", "Runnea Pro" → "RunnerPro".
+Prohibido: añadir palabras, quitar palabras, reordenar, cambiar el sentido, corregir gramática o estilo, tocar números. Si no hay nada que corregir, devuelve el texto tal cual.
+
+Últimos mensajes del chat:
+${previos || '(ninguno)'}
+
+Vocabulario: ${GLOSARIO_RUNNING.join(', ')}.
+
+Transcripción:
+${texto}
+
+Devuelve SOLO la transcripción corregida, sin comentarios.`;
+};
+/**
+ * Pide al modelo LITE una propuesta de corrección; si no llega a tiempo, devuelve null
+ *
+ * @param prompt - Prompt de corrección
+ * @returns Texto propuesto, o null
+ */
+const pedirPropuesta = (prompt) => __awaiter(void 0, void 0, void 0, function* () {
+    const llamada = (0, index_1.generateText)({
+        model: (0, index_1.createGoogleModel)('LITE'),
+        prompt,
+        // ⭐ Sin registro en LLM CACHE: una transcripción no vale como clave y engorda la tabla
+        log: false,
+        providerOptions: { openai: { reasoningEffort: 'low' } },
+    }).then((resultado) => ((resultado === null || resultado === void 0 ? void 0 : resultado.text) || '').trim());
+    const timeout = new Promise((resolve) => setTimeout(() => resolve(null), CORRECCION_TIMEOUT_MS));
+    return Promise.race([llamada, timeout]);
+});
+/**
+ * Corrige jerga y nombres de una transcripción con el modelo LITE, dejando pasar solo las
+ * sustituciones que el filtro determinista acepta. Nunca lanza: ante cualquier fallo devuelve el
+ * texto tal cual.
+ *
+ * @param texto - Transcripción tal como sale del reconocedor
+ * @param contexto - Nombres y últimos mensajes del chat
+ * @returns Texto corregido y la lista de sustituciones propuestas con su veredicto
+ *
+ * @example
+ * ```typescript
+ * const { texto, sustituciones } = await corregirTranscripcion('Hoy he hecho Farley con el garam', { nombres: ['Ana', 'Rubén'] });
+ * // texto: 'Hoy he hecho fartlek con el Garmin'
+ * ```
+ */
+const corregirTranscripcion = (texto, contexto) => __awaiter(void 0, void 0, void 0, function* () {
+    const sinCambios = { texto, sustituciones: [] };
+    if (!texto || texto.length < CORRECCION_MIN_CARACTERES || process.env.TRANSCRIPCION_CORRECCION === 'off')
+        return sinCambios;
+    try {
+        const propuesta = yield pedirPropuesta(promptCorreccion(texto, contexto || {}));
+        if (!propuesta || normalizar(propuesta) === normalizar(texto))
+            return sinCambios;
+        const nombres = ((contexto === null || contexto === void 0 ? void 0 : contexto.nombres) || []).filter(Boolean);
+        const canonicas = new Map();
+        for (const entrada of [...GLOSARIO_RUNNING, ...nombres]) {
+            canonicas.set(normalizar(entrada), entrada.trim());
+            for (const palabra of palabras(entrada))
+                if (!canonicas.has(palabra))
+                    canonicas.set(palabra, palabra);
+        }
+        const admitidas = new Set(canonicas.keys());
+        const sustituciones = [];
+        const aceptadas = [];
+        for (const tramo of alinear(palabras(texto), palabras(propuesta))) {
+            const de = tramo.de.join(' ');
+            const a = tramo.a.join(' ');
+            const aceptada = tramo.de.length > 0 &&
+                tramo.a.length > 0 &&
+                !/\d/.test(de + a) &&
+                tramo.a.every((palabra) => admitidas.has(palabra) || admitidas.has(palabra.replace(/s$/, ''))) &&
+                similitud(de.replace(/ /g, ''), a.replace(/ /g, '')) >= SIMILITUD_MINIMA;
+            sustituciones.push({ de, a, aceptada });
+            if (aceptada)
+                aceptadas.push(tramo);
+        }
+        return { texto: aceptadas.length ? aplicar(texto, aceptadas, canonicas) : texto, sustituciones };
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.error('[corregirTranscripcion] Se guarda sin corregir:', (error === null || error === void 0 ? void 0 : error.message) || error);
+        return sinCambios;
+    }
+});
+exports.corregirTranscripcion = corregirTranscripcion;

package/lib/cjs/mediaProcessing/ffmpegUtils.js

@@ -12,10 +12,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SPEECH_SAMPLE_RATE = exports.FFMPEG_TIMEOUT_MS = exports.withTempDir = exports.probeMedia = exports.runFfmpeg = exports.ffmpeg = void 0;
+exports.SIN_VOZ_DB = exports.SIN_VOZ_DB_CLIP_CORTO = exports.SIN_VOZ_DURACION_MAX_S = exports.SPEECH_SAMPLE_RATE = exports.FFMPEG_TIMEOUT_MS = exports.withTempDir = exports.esAudioSinVoz = exports.measureLoudness = exports.probeMedia = exports.runFfmpeg = exports.ffmpeg = void 0;
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
 const fluent_ffmpeg_1 = __importDefault(require("fluent-ffmpeg"));
 exports.ffmpeg = fluent_ffmpeg_1.default;
 const ffmpeg_static_1 = __importDefault(require("ffmpeg-static"));
@@ -26,9 +27,19 @@ fluent_ffmpeg_1.default.setFfprobePath(ffprobe_static_1.default.path);
 // a borrar el temporal (que en Cloud Run vive en RAM) y el adjunto se queda sin FILE TEXT
 const FFMPEG_TIMEOUT_MS = 120000;
 exports.FFMPEG_TIMEOUT_MS = FFMPEG_TIMEOUT_MS;
-// ✅ Formato que espera Speech-to-Text: WAV PCM 16 bits, mono, 16 kHz
+// ✅ Formato del WAV que se manda a los motores de transcripción: PCM 16 bits, mono, 16 kHz
 const SPEECH_SAMPLE_RATE = 16000;
 exports.SPEECH_SAMPLE_RATE = SPEECH_SAMPLE_RATE;
+// ✅ Umbrales de la guarda física: por debajo no hay voz que transcribir y no se llama a ningún motor.
+// Medidos sobre 74 notas de voz reales: los dos clips vacíos (0,5 s a −45 dB y 1,2 s a −66 dB) caen
+// dentro; el audio con voz más bajo (−43 dB, 41 s) y uno con una tele de fondo (−55 dB) quedan fuera.
+// El umbral absoluto es deliberadamente bajo: mejor transcribir de más que callar un audio con voz.
+const SIN_VOZ_DURACION_MAX_S = 2;
+exports.SIN_VOZ_DURACION_MAX_S = SIN_VOZ_DURACION_MAX_S;
+const SIN_VOZ_DB_CLIP_CORTO = -40;
+exports.SIN_VOZ_DB_CLIP_CORTO = SIN_VOZ_DB_CLIP_CORTO;
+const SIN_VOZ_DB = -60;
+exports.SIN_VOZ_DB = SIN_VOZ_DB;
 /**
  * Ejecuta un comando de ffmpeg como promesa, matándolo si se pasa del tiempo máximo
  *
@@ -82,6 +93,34 @@ const probeMedia = (inputPath) => new Promise((resolve, reject) => {
     });
 });
 exports.probeMedia = probeMedia;
+/**
+ * Mide el volumen medio de un audio con el filtro `volumedetect` de ffmpeg. Nunca lanza.
+ *
+ * @param inputPath - Ruta del audio en disco (cualquier formato que ffmpeg decodifique)
+ * @returns Volumen medio en dB, o null si no se pudo medir
+ */
+const measureLoudness = (inputPath) => new Promise((resolve) => {
+    (0, child_process_1.execFile)(ffmpeg_static_1.default, ['-hide_banner', '-nostats', '-i', inputPath, '-vn', '-af', 'volumedetect', '-f', 'null', '-'], { timeout: FFMPEG_TIMEOUT_MS, maxBuffer: 8 * 1024 * 1024 }, (error, _stdout, stderr) => {
+        const match = /mean_volume:\s*(-?[\d.]+)\s*dB/.exec(String(stderr || ''));
+        if (!match) {
+            // eslint-disable-next-line no-console
+            console.error('[measureLoudness] No se pudo medir el volumen:', (error === null || error === void 0 ? void 0 : error.message) || 'sin mean_volume en la salida de ffmpeg');
+            return resolve(null);
+        }
+        resolve(Number(match[1]));
+    });
+});
+exports.measureLoudness = measureLoudness;
+/**
+ * Decide si un audio no tiene voz que transcribir: muy corto y bajo, o directamente en silencio.
+ * Sin medida de volumen nunca se marca: mejor transcribir de más que callar un audio con voz.
+ *
+ * @param duration - Duración en segundos (0 si no se conoce)
+ * @param meanDb - Volumen medio en dB, o null si no se pudo medir
+ * @returns true si no merece la pena llamar a ningún motor
+ */
+const esAudioSinVoz = (duration, meanDb) => meanDb !== null && ((duration > 0 && duration < SIN_VOZ_DURACION_MAX_S && meanDb < SIN_VOZ_DB_CLIP_CORTO) || meanDb < SIN_VOZ_DB);
+exports.esAudioSinVoz = esAudioSinVoz;
 /**
  * Crea un directorio temporal, ejecuta el trabajo y lo borra pase lo que pase.
  * En Cloud Run el temporal vive en RAM, así que dejarlo sin borrar cuesta memoria.

package/lib/cjs/mediaProcessing/index.js

@@ -12,10 +12,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FILE_KIND = exports.reprocessRecentMedia = exports.processMediaFile = exports.analyzeFile = exports.classifyFile = exports.describeOpaqueFile = exports.describeTextFile = exports.describePdf = exports.describeVideo = exports.describeImage = exports.transcribeAudio = void 0;
+exports.MARCADORES_AUDIO = exports.MARCADOR_NO_TRANSCRITO = exports.MARCADOR_SIN_VOZ = exports.GLOSARIO_RUNNING = exports.corregirTranscripcion = exports.FILE_KIND = exports.reprocessMediaByIds = exports.reprocessRecentMedia = exports.processMediaFile = exports.analyzeFile = exports.classifyFile = exports.describeOpaqueFile = exports.describeTextFile = exports.describePdf = exports.describeVideo = exports.describeImage = exports.transcribeAudio = void 0;
 const path_1 = __importDefault(require("path"));
 const index_1 = require("../db/index");
-const index_2 = require("../err/index");
+const almacenamiento_1 = require("../almacenamiento");
 const audio_1 = require("./audio");
 Object.defineProperty(exports, "transcribeAudio", { enumerable: true, get: function () { return audio_1.transcribeAudio; } });
 const image_1 = require("./image");
@@ -114,6 +114,7 @@ exports.classifyFile = classifyFile;
  * @param fileBuffer - Buffer del archivo
  * @param mimetype - Tipo MIME del archivo
  * @param filename - Nombre original del archivo
+ * @param contexto - Idioma, nombres y últimos mensajes del cliente; solo lo usan audio y vídeo
  * @returns Promise<string> - Transcripción, descripción, resumen o ficha del archivo
  *
  * @example
@@ -122,19 +123,19 @@ exports.classifyFile = classifyFile;
  * // "Analítica de sangre del 3 de junio con ferritina de 28 ng/ml..."
  * ```
  */
-const analyzeFile = (fileBuffer, mimetype, filename) => __awaiter(void 0, void 0, void 0, function* () {
+const analyzeFile = (fileBuffer, mimetype, filename, contexto) => __awaiter(void 0, void 0, void 0, function* () {
     const kind = classifyFile(mimetype, filename, fileBuffer);
     const fallback = () => (0, documents_1.describeOpaqueFile)(mimetype, filename, (fileBuffer === null || fileBuffer === void 0 ? void 0 : fileBuffer.length) || 0);
     let fileText;
     switch (kind) {
         case FILE_KIND.AUDIO:
-            fileText = yield (0, audio_1.transcribeAudio)(fileBuffer, mimetype, filename);
+            fileText = yield (0, audio_1.transcribeAudio)(fileBuffer, mimetype, filename, contexto);
             break;
         case FILE_KIND.IMAGE:
             fileText = yield (0, image_1.describeImage)(fileBuffer, mimetype);
             break;
         case FILE_KIND.VIDEO:
-            fileText = yield (0, video_1.describeVideo)(fileBuffer, mimetype, filename);
+            fileText = yield (0, video_1.describeVideo)(fileBuffer, mimetype, filename, contexto);
             break;
         case FILE_KIND.PDF:
             fileText = yield (0, documents_1.describePdf)(fileBuffer, filename);
@@ -152,6 +153,45 @@ const analyzeFile = (fileBuffer, mimetype, filename) => __awaiter(void 0, void 0
     return clean || fallback();
 });
 exports.analyzeFile = analyzeFile;
+/**
+ * Carga lo que ayuda a transcribir una nota de voz: idioma del cliente, nombres (cliente y
+ * entrenadores, para la lista de frases y el filtro de corrección) y los últimos mensajes del chat.
+ * Si falla, se transcribe sin contexto: nunca bloquea.
+ *
+ * @param idMessage - ID del mensaje en CHAT MESSAGE
+ * @returns Contexto, o null si no se pudo cargar
+ */
+const cargarContextoTranscripcion = (idMessage) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const [fila] = yield (0, index_1.query)(`SELECT c."PREFERRED LANGUAGE" AS idioma, c."NAME" AS cliente, e1."NAME" AS entrenador1, e2."NAME" AS entrenador2,
+              (SELECT json_agg(json_build_object(
+                        'quien', CASE WHEN p."ID SENDER" = m."ID CLIENTE" THEN 'cliente' ELSE 'entrenador' END,
+                        'texto', left(CASE WHEN p."MIMETYPE" IS NOT NULL THEN p."FILE TEXT" ELSE p."TEXT" END, 300)) ORDER BY p."DATE")
+               FROM (SELECT * FROM "CHAT MESSAGE" p2
+                     WHERE p2."ID CLIENTE" = m."ID CLIENTE" AND p2."DATE" < m."DATE" AND p2."ID" <> m."ID"
+                       AND COALESCE(p2."ELIMINADO", false) = false AND COALESCE(p2."SHOW CLIENT", true) = true
+                     ORDER BY p2."DATE" DESC LIMIT 6) p) AS previos
+       FROM "CHAT MESSAGE" m
+       JOIN "CLIENTE" c ON c."ID" = m."ID CLIENTE"
+       LEFT JOIN "ENTRENADOR" e1 ON e1."ID" = c."ID ENTRENADOR PRINCIPAL"
+       LEFT JOIN "ENTRENADOR" e2 ON e2."ID" = c."ID ENTRENADOR SECUNDARIO"
+       WHERE m."ID" = ?`, [idMessage]);
+        if (!fila)
+            return null;
+        return {
+            idMensaje: idMessage,
+            idioma: fila.idioma || null,
+            // ⭐ El primero es siempre el cliente (aunque no tenga nombre): la corrección cuenta con ese orden
+            nombres: [fila.cliente, fila.entrenador1, fila.entrenador2].map((nombre) => (nombre || '').trim()),
+            previos: (fila.previos || []).filter((mensaje) => mensaje === null || mensaje === void 0 ? void 0 : mensaje.texto),
+        };
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.error(`[processMediaFile] Sin contexto para transcribir el mensaje ${idMessage}:`, (error === null || error === void 0 ? void 0 : error.message) || error);
+        return null;
+    }
+});
 /**
  * Procesa un adjunto de chat y guarda su texto en la base de datos.
  * Pensado para llamarse sin await (fire-and-forget) desde el envío del archivo.
@@ -170,25 +210,65 @@ exports.analyzeFile = analyzeFile;
  */
 const processMediaFile = (idMessage, fileBuffer, mimetype, filename) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const fileText = yield analyzeFile(fileBuffer, mimetype, filename);
+        // ⭐ Idioma, nombres y últimos mensajes solo hacen falta para transcribir voz
+        const kind = classifyFile(mimetype, filename, fileBuffer);
+        const contexto = kind === FILE_KIND.AUDIO || kind === FILE_KIND.VIDEO ? yield cargarContextoTranscripcion(idMessage) : null;
+        const fileText = yield analyzeFile(fileBuffer, mimetype, filename, contexto);
         // ✅ Guardar el resultado en la base de datos
         yield (0, index_1.query)('UPDATE [CHAT MESSAGE] SET [FILE TEXT] = ? WHERE [ID] = ?', [fileText, idMessage]);
     }
     catch (error) {
-        (0, index_2.err)(null, null, error, null);
+        // eslint-disable-next-line no-console
+        console.error(`[processMediaFile] Error procesando el mensaje ${idMessage}:`, (error === null || error === void 0 ? void 0 : error.message) || error);
     }
 });
 exports.processMediaFile = processMediaFile;
 /**
- * Reprocesa los adjuntos recientes (últimos 2 días) que no tienen FILE TEXT,
- * sea cual sea su tipo. Útil para rellenar mensajes anteriores al deploy.
+ * Almacenamiento donde viven los adjuntos del chat (`Chat/<id>`), construido con la configuración
+ * del propio servicio (`CLOUD_STORAGE_BUCKET` + clave de la cuenta de Azure).
  *
- * @param bucket - Instancia del bucket de Google Cloud Storage
+ * @returns Contenedor con `file(ruta).exists()` y `download()`
+ */
+const almacenamientoAdjuntos = () => new almacenamiento_1.Storage().bucket(process.env.CLOUD_STORAGE_BUCKET);
+/**
+ * Vuelve a procesar un adjunto ya subido a Storage: descarga, analiza con el mismo router que en
+ * vivo y guarda FILE TEXT (salvo en simulación).
+ *
+ * @param bucket - Contenedor con `file(ruta).exists()` y `download()`
+ * @param message - Fila con id, mimetype, text (nombre original del archivo) y, si se leyó, fileText actual
+ * @param dryRun - true para calcular el texto nuevo sin guardarlo
+ * @returns Texto anterior y nuevo, o null si el archivo no está en Storage
+ */
+const reprocesarMensaje = (bucket, message, dryRun = false) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const [fileExists] = yield bucket.file(`Chat/${message.id}`).exists();
+    if (!fileExists) {
+        // eslint-disable-next-line no-console
+        console.log(`[reprocessMedia] Archivo no encontrado: Chat/${message.id}`);
+        return null;
+    }
+    const [fileBuffer] = yield bucket.file(`Chat/${message.id}`).download();
+    const kind = classifyFile(message.mimetype, message.text, fileBuffer);
+    const contexto = kind === FILE_KIND.AUDIO || kind === FILE_KIND.VIDEO ? yield cargarContextoTranscripcion(message.id) : null;
+    // ⭐ Mismo router que en el envío en vivo
+    const fileText = yield analyzeFile(fileBuffer, message.mimetype, message.text, contexto);
+    if (!dryRun)
+        yield (0, index_1.query)('UPDATE [CHAT MESSAGE] SET [FILE TEXT] = ? WHERE [ID] = ?', [fileText, message.id]);
+    // eslint-disable-next-line no-console
+    console.log(`[reprocessMedia] ${dryRun ? '🔍 Simulado' : '✅ Procesado'} mensaje ${message.id}: ${fileText.substring(0, 50)}...`);
+    return { id: message.id, antes: (_a = message.fileText) !== null && _a !== void 0 ? _a : null, despues: fileText, guardado: !dryRun };
+});
+/**
+ * Reprocesa los adjuntos recientes (últimos 2 días) que no tienen FILE TEXT o cuya transcripción
+ * quedó en un marcador de fallo transitorio, sea cual sea su tipo. Útil tras un deploy o una caída
+ * del motor de transcripción. El marcador «sin voz» no se reintenta: es definitivo.
+ *
+ * @param bucket - Contenedor con `file(ruta).exists()` y `download()`; si no se pasa, el del propio servicio
  * @returns Promise<{ processed: number; errors: number }> - Estadísticas del reprocesamiento
  *
  * @example
  * ```typescript
- * const stats = await reprocessRecentMedia(bucket);
+ * const stats = await reprocessRecentMedia();
  * // Resultado: { processed: 5, errors: 1 }
  * ```
  */
@@ -196,43 +276,88 @@ const reprocessRecentMedia = (bucket) => __awaiter(void 0, void 0, void 0, funct
     let processed = 0;
     let errors = 0;
     try {
+        const contenedor = bucket || almacenamientoAdjuntos();
         // ✅ Cualquier adjunto sin FILE TEXT, no solo audio e imagen
-        const messages = yield (0, index_1.query)(`SELECT "ID", "MIMETYPE", "TEXT" FROM "CHAT MESSAGE"
+        const messages = yield (0, index_1.query)(`SELECT "ID", "MIMETYPE", "TEXT", "FILE TEXT" FROM "CHAT MESSAGE"
        WHERE "DATE" >= NOW() - INTERVAL '2 days'
-       AND "FILE TEXT" IS NULL
        AND "MIMETYPE" IS NOT NULL
-       ORDER BY "DATE" DESC`, []);
+       AND ("FILE TEXT" IS NULL OR "FILE TEXT" IN (?, ?))
+       ORDER BY "DATE" DESC`, [audio_1.MARCADOR_NO_TRANSCRITO, audio_1.MARCADOR_ANTIGUO]);
         // eslint-disable-next-line no-console
         console.log(`[reprocessRecentMedia] Encontrados ${messages.length} mensajes para procesar`);
         for (const message of messages) {
             try {
-                // ⭐ Descargar archivo de Storage
-                const [fileExists] = yield bucket.file(`Chat/${message.id}`).exists();
-                if (!fileExists) {
-                    // eslint-disable-next-line no-console
-                    console.log(`[reprocessRecentMedia] Archivo no encontrado: Chat/${message.id}`);
-                    errors++;
-                    continue;
-                }
-                const [fileBuffer] = yield bucket.file(`Chat/${message.id}`).download();
-                // ⭐ Mismo router que en el envío en vivo
-                const fileText = yield analyzeFile(fileBuffer, message.mimetype, message.text);
-                // ⭐ Guardar en BD
-                yield (0, index_1.query)('UPDATE [CHAT MESSAGE] SET [FILE TEXT] = ? WHERE [ID] = ?', [fileText, message.id]);
-                // eslint-disable-next-line no-console
-                console.log(`[reprocessRecentMedia] ✅ Procesado mensaje ${message.id}: ${fileText.substring(0, 50)}...`);
-                processed++;
+                (yield reprocesarMensaje(contenedor, message)) ? processed++ : errors++;
             }
             catch (msgError) {
                 // eslint-disable-next-line no-console
-                console.log(`[reprocessRecentMedia] ❌ Error procesando mensaje ${message.id}:`, msgError);
+                console.error(`[reprocessRecentMedia] ❌ Error procesando mensaje ${message.id}:`, (msgError === null || msgError === void 0 ? void 0 : msgError.message) || msgError);
                 errors++;
             }
         }
     }
     catch (error) {
-        (0, index_2.err)(null, null, error, null);
+        // eslint-disable-next-line no-console
+        console.error('[reprocessRecentMedia] Error:', (error === null || error === void 0 ? void 0 : error.message) || error);
     }
     return { processed, errors };
 });
 exports.reprocessRecentMedia = reprocessRecentMedia;
+/**
+ * Reprocesa una lista concreta de adjuntos (p. ej. transcripciones que se sabe que salieron mal)
+ * con el pipeline actual. Con `dryRun` calcula el texto nuevo sin guardarlo, para ver antes y
+ * después. Sin `dryRun` escribe FILE TEXT: ejecutar a mano y con criterio.
+ *
+ * @param ids - IDs de CHAT MESSAGE
+ * @param opts - `dryRun` para simular; `bucket` para usar otro almacenamiento que el del propio servicio
+ * @returns Estadísticas y, por mensaje, texto anterior y nuevo
+ *
+ * @example
+ * ```typescript
+ * const { resultados } = await reprocessMediaByIds([523437, 501309], { dryRun: true });
+ * // resultados[0]: { id: 523437, antes: 'Hola Víctor…', despues: '[Audio sin voz reconocible]', guardado: false }
+ * ```
+ */
+const reprocessMediaByIds = (ids, opts = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    let processed = 0;
+    let errors = 0;
+    const resultados = [];
+    // ⭐ Solo enteros: la lista va incrustada en el SQL
+    const validos = [...new Set((ids || []).map(Number).filter(Number.isInteger))];
+    if (!validos.length)
+        return { processed, errors, resultados };
+    try {
+        const contenedor = opts.bucket || almacenamientoAdjuntos();
+        const messages = yield (0, index_1.query)(`SELECT "ID", "MIMETYPE", "TEXT", "FILE TEXT" FROM "CHAT MESSAGE" WHERE "MIMETYPE" IS NOT NULL AND "ID" IN (${validos.join(',')}) ORDER BY "ID"`, []);
+        for (const message of messages) {
+            try {
+                const resultado = yield reprocesarMensaje(contenedor, message, !!opts.dryRun);
+                if (resultado) {
+                    resultados.push(resultado);
+                    processed++;
+                }
+                else {
+                    errors++;
+                }
+            }
+            catch (msgError) {
+                // eslint-disable-next-line no-console
+                console.error(`[reprocessMediaByIds] ❌ Error procesando mensaje ${message.id}:`, (msgError === null || msgError === void 0 ? void 0 : msgError.message) || msgError);
+                errors++;
+            }
+        }
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.error('[reprocessMediaByIds] Error:', (error === null || error === void 0 ? void 0 : error.message) || error);
+    }
+    return { processed, errors, resultados };
+});
+exports.reprocessMediaByIds = reprocessMediaByIds;
+var correccionTranscripcion_1 = require("./correccionTranscripcion");
+Object.defineProperty(exports, "corregirTranscripcion", { enumerable: true, get: function () { return correccionTranscripcion_1.corregirTranscripcion; } });
+Object.defineProperty(exports, "GLOSARIO_RUNNING", { enumerable: true, get: function () { return correccionTranscripcion_1.GLOSARIO_RUNNING; } });
+var audio_2 = require("./audio");
+Object.defineProperty(exports, "MARCADOR_SIN_VOZ", { enumerable: true, get: function () { return audio_2.MARCADOR_SIN_VOZ; } });
+Object.defineProperty(exports, "MARCADOR_NO_TRANSCRITO", { enumerable: true, get: function () { return audio_2.MARCADOR_NO_TRANSCRITO; } });
+Object.defineProperty(exports, "MARCADORES_AUDIO", { enumerable: true, get: function () { return audio_2.MARCADORES_AUDIO; } });