Upload 10 files

refinement/introspection.py

@@ -0,0 +1,297 @@
+"""Mòdul per a l'agent d'"introspection".
+
+Implementa:
+
+- Un procés d'entrenament que aprèn de les correccions HITL comparant
+  `une_ad` automàtic (MoE/Salamandra) amb `une_ad` de la versió HITL.
+- Un pas d'introspecció que aplica aquestes regles a un nou SRT utilitzant
+  GPT-4o-mini.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import sqlite3
+from pathlib import Path
+from typing import Iterable, List, Optional, Tuple
+
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import HumanMessage, SystemMessage
+
+
+logger = logging.getLogger(__name__)
+
+
+# --- Rutes i constants ---
+
+BASE_DIR = Path(__file__).resolve().parent
+# Estructura esperada: .../hf_spaces/engine/refinement/introspection.py
+# Per tant, la "root" del repo és el pare immediat de "engine".
+REPO_ROOT = BASE_DIR.parents[1]
+DEMO_DIR = REPO_ROOT / "demo"
+DEMO_TEMP_DIR = DEMO_DIR / "temp"
+
+REFINEMENT_TEMP_DIR = BASE_DIR / "temp"
+REFINEMENT_TEMP_DIR.mkdir(exist_ok=True, parents=True)
+
+FEW_SHOT_PATH = REFINEMENT_TEMP_DIR / "few_shot_examples.txt"
+RULES_PATH = REFINEMENT_TEMP_DIR / "rules.txt"
+
+AUDIODESCRIPTIONS_DB_PATH = DEMO_TEMP_DIR / "audiodescriptions.db"
+
+
+def _get_llm() -> Optional[ChatOpenAI]:
+    """Retorna una instància de GPT-4o-mini o None si no hi ha API key."""
+
+    api_key = os.environ.get("OPENAI_API_KEY")
+    if not api_key:
+        logger.warning("OPENAI_API_KEY no está configurada; se omite la introspection.")
+        return None
+    try:
+        return ChatOpenAI(model="gpt-4o-mini", temperature=0.0, api_key=api_key)
+    except Exception as exc:  # pragma: no cover - errors de client extern
+        logger.error("No se pudo inicializar ChatOpenAI para introspection: %s", exc)
+        return None
+
+
+# --- Lectura de dades d'entrenament ---
+
+def _iter_une_vs_hitl_pairs() -> Iterable[Tuple[str, str, str]]:
+    """Itera sobre (sha1sum, une_ad_auto, une_ad_hitl).
+
+    A partir d'ara:
+    - une_ad_auto: versió automàtica (MoE o Salamandra), camp ``une_ad``.
+    - une_ad_hitl: versió corregida HITL guardada al mateix registre, camp ``ok_une_ad``.
+    """
+
+    if not AUDIODESCRIPTIONS_DB_PATH.exists():
+        logger.warning("audiodescriptions.db no encontrado en %s", AUDIODESCRIPTIONS_DB_PATH)
+        return
+
+    conn = sqlite3.connect(str(AUDIODESCRIPTIONS_DB_PATH))
+    conn.row_factory = sqlite3.Row
+    try:
+        cur = conn.cursor()
+        try:
+            cur.execute(
+                """
+                SELECT sha1sum, version, une_ad, ok_une_ad
+                FROM audiodescriptions
+                WHERE version IN ('MoE', 'Salamandra')
+                """
+            )
+        except sqlite3.OperationalError:
+            logger.warning("Tabla audiodescriptions no disponible en %s", AUDIODESCRIPTIONS_DB_PATH)
+            return
+
+        rows = cur.fetchall()
+        for row in rows:
+            sha1sum = row["sha1sum"]
+            une_auto = (row["une_ad"] or "").strip()
+            une_hitl = (row["ok_une_ad"] or "").strip() if "ok_une_ad" in row.keys() else ""
+
+            if not une_auto or not une_hitl:
+                continue
+
+            if une_hitl == une_auto:
+                # No hi ha diferències; no aporta informació
+                continue
+
+            yield sha1sum, une_auto, une_hitl
+    finally:
+        conn.close()
+
+
+def _strip_markdown_fences(content: str) -> str:
+    """Elimina fences ```...``` alrededor de una respuesta JSON si existen."""
+
+    text = content.strip()
+    if text.startswith("```"):
+        lines = text.splitlines()
+        # descartar primera línea con ``` o ```json
+        lines = lines[1:]
+        # eliminar el cierre ``` (pueden existir varias líneas en blanco finales)
+        while lines and lines[-1].strip().startswith("```"):
+            lines.pop()
+        text = "\n".join(lines).strip()
+    return text
+
+
+def _analyze_correction_with_llm(llm: ChatOpenAI, une_auto: str, une_hitl: str) -> Tuple[str, str]:
+    """Demana al LLM que descrigui la correcció i extregui una regla general.
+
+    Retorna (few_shot_example, rule). Si falla, retorna cadenes buides.
+    """
+
+    system = SystemMessage(
+        content=(
+            "Ets un assistent que analitza correccions d'audiodescripcions UNE-153010. "
+            "Se't dona una versió automàtica i una versió corregida per humans (HITL). "
+            "La teva tasca és (1) descriure de forma concisa què s'ha corregit, amb "
+            "exemples concrets, i (2) proposar una regla general aplicable a futurs SRT. "
+            "Respon en format JSON amb les claus 'few_shot_example' i 'rule'."
+        )
+    )
+
+    user_content = {
+        "une_ad_auto": une_auto,
+        "une_ad_hitl": une_hitl,
+    }
+
+    msg = HumanMessage(content=json.dumps(user_content, ensure_ascii=False))
+
+    try:
+        resp = llm.invoke([system, msg])
+    except Exception as exc:  # pragma: no cover - errors externs
+        logger.error("Error llamando al LLM en introspection training: %s", exc)
+        return "", ""
+
+    raw = resp.content if isinstance(resp.content, str) else str(resp.content)
+    text = _strip_markdown_fences(raw)
+    try:
+        data = json.loads(text)
+    except json.JSONDecodeError:
+        logger.warning("La respuesta del LLM no es JSON válido: %s", raw[:2000])
+        return raw.strip(), ""
+
+    few = data.get("few_shot_example", "")
+    # Aceptamos tanto string como objeto; si es objeto, lo "bonificamos" a texto legible
+    if isinstance(few, dict):
+        try:
+            few_shot = json.dumps(few, ensure_ascii=False, indent=2)
+        except Exception:
+            few_shot = str(few)
+    else:
+        few_shot = str(few)
+
+    rule = str(data.get("rule", "")).strip()
+    return few_shot.strip(), rule
+
+
+def train_introspection_rules(max_examples: Optional[int] = None) -> None:
+    """Entrena regles d'introspecció a partir de les correccions HITL.
+
+    - Recorre audiodescriptions.db buscant parelles (MoE/Salamandra, HITL).
+    - Per a cada parella amb diferències significatives, demana al LLM:
+        * Un "few_shot_example" que descrigui la correcció.
+        * Una "rule" generalitzada.
+    - Afegeix els exemples a ``few_shot_examples.txt`` i les regles úniques a
+      ``rules.txt`` dins de ``engine/refinement/temp``.
+    """
+
+    llm = _get_llm()
+    if llm is None:
+        logger.info("Introspection training skipped: no LLM available.")
+        return
+
+    logger.info("Començant entrenament d'introspection a partir de %s", AUDIODESCRIPTIONS_DB_PATH)
+
+    # Carregar regles existents per no duplicar-les
+    existing_rules: List[str] = []
+    if RULES_PATH.exists():
+        try:
+            existing_rules = [line.strip() for line in RULES_PATH.read_text(encoding="utf-8").splitlines() if line.strip()]
+        except Exception:
+            existing_rules = []
+
+    seen_rules = set(existing_rules)
+
+    n_processed = 0
+    n_generated = 0
+
+    with FEW_SHOT_PATH.open("a", encoding="utf-8") as f_examples, RULES_PATH.open(
+        "a", encoding="utf-8"
+    ) as f_rules:
+        for sha1sum, une_auto, une_hitl in _iter_une_vs_hitl_pairs():
+            if max_examples is not None and n_processed >= max_examples:
+                break
+
+            n_processed += 1
+            logger.info("Analitzant correcció HITL per sha1sum=%s", sha1sum)
+
+            few_shot, rule = _analyze_correction_with_llm(llm, une_auto, une_hitl)
+            if not few_shot and not rule:
+                continue
+
+            if few_shot:
+                f_examples.write("# sha1sum=" + sha1sum + "\n")
+                f_examples.write(few_shot + "\n\n")
+
+            if rule and rule not in seen_rules:
+                seen_rules.add(rule)
+                f_rules.write(rule + "\n")
+
+            n_generated += 1
+
+    logger.info(
+        "Introspection training completat: %d parelles processades, %d entrades generades",
+        n_processed,
+        n_generated,
+    )
+
+
+def _load_text_file(path: Path) -> str:
+    if not path.exists():
+        return ""
+    try:
+        return path.read_text(encoding="utf-8")
+    except Exception:
+        return ""
+
+
+def refine_srt_with_introspection(srt_content: str) -> str:
+    """Aplica el pas d'introspecció sobre un SRT.
+
+    - Llegeix ``few_shot_examples.txt`` i ``rules.txt`` de ``engine/refinement/temp``.
+    - Demana a GPT-4o-mini que corregeixi el SRT tenint en compte aquests
+      exemples i regles.
+    - Si no hi ha LLM o fitxers, retorna el SRT original.
+    """
+
+    llm = _get_llm()
+    if llm is None:
+        return srt_content
+
+    few_shots = _load_text_file(FEW_SHOT_PATH)
+    rules = _load_text_file(RULES_PATH)
+
+    if not few_shots and not rules:
+        # Res a aplicar; no modifiquem el SRT
+        return srt_content
+
+    system_parts: List[str] = [
+        "Ets un assistent que millora audiodescripcions en format SRT.",
+        "Tens unes regles d'introspecció derivades de correccions humanes (HITL)",
+        "i alguns exemples de correccions anteriors (few-shot examples).",
+        "Has de produir un nou SRT que apliqui aquestes regles i millores,",
+        "mantenint l'estructura de temps i el format SRT.",
+        "Retorna únicament el SRT corregit, sense explicacions addicionals.",
+    ]
+
+    if rules:
+        system_parts.append("\nRegles d'introspecció (una per línia):\n" + rules)
+
+    if few_shots:
+        system_parts.append("\nExemples de correccions (few-shot examples):\n" + few_shots)
+
+    system_msg = SystemMessage(content="\n".join(system_parts))
+
+    user_msg = HumanMessage(
+        content=(
+            "A continuació tens un SRT generat automàticament. "
+            "Aplica les regles i l'estil observat als exemples per millorar-lo, "
+            "especialment en aquells aspectes que solen ser corregits pels humans.\n\n"
+            "SRT original:\n" + srt_content
+        )
+    )
+
+    try:
+        resp = llm.invoke([system_msg, user_msg])
+    except Exception as exc:  # pragma: no cover - errors externs
+        logger.error("Error llamando al LLM en introspection apply: %s", exc)
+        return srt_content
+
+    text = resp.content if isinstance(resp.content, str) else str(resp.content)
+    return text.strip() or srt_content

refinement/multiagent_refinement.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+from .reflection import refine_srt_with_reflection, refine_video_with_reflection
+from .reflection_ma import refine_srt_with_reflection_ma, refine_video_with_reflection_ma
+from .reflexion import refine_srt_with_reflexion
+from .introspection import refine_srt_with_introspection
+
+
+def _load_refinement_flags(config_path: Optional[Path] = None) -> dict:
+    """Carga los flags de refinamiento desde config.yaml.
+
+    Por defecto usa demo/config.yaml porque ahí están definidos los parámetros
+    `refinement.reflection_enabled`, `refinement.reflexion_enabled` e
+    `refinement.introspection_enabled`.
+    """
+
+    if config_path is None:
+        # Raíz del repo: .../hf_spaces
+        root = Path(__file__).resolve().parents[2]
+        config_path = root / "demo" / "config.yaml"
+
+    flags = {
+        "reflection_enabled": True,
+        "reflexion_enabled": False,
+        "introspection_enabled": False,
+        "reflection_ma_enabled": False,
+    }
+
+    try:
+        if config_path.exists():
+            with config_path.open("r", encoding="utf-8") as f:
+                cfg = yaml.safe_load(f) or {}
+            ref_cfg = cfg.get("refinement", {}) or {}
+            flags["reflection_enabled"] = bool(ref_cfg.get("reflection_enabled", flags["reflection_enabled"]))
+            flags["reflexion_enabled"] = bool(ref_cfg.get("reflexion_enabled", flags["reflexion_enabled"]))
+            flags["introspection_enabled"] = bool(ref_cfg.get("introspection_enabled", flags["introspection_enabled"]))
+            flags["reflection_ma_enabled"] = bool(ref_cfg.get("reflection_ma_enabled", flags["reflection_ma_enabled"]))
+    except Exception:
+        # Si algo falla, devolvemos los valores por defecto sin romper el flujo
+        pass
+
+    return flags
+
+
+def execute_refinement(initial_srt: str, *, config_path: Optional[Path] = None) -> str:
+    """Ejecuta el pipeline de refinamiento multi‑agente sobre un SRT.
+
+    - Lee `refinement.*` de config.yaml para decidir qué pasos aplicar.
+    - Aplica, en este orden, si están habilitados:
+      1) reflection (LangGraph principal)
+      2) reflexion (ajustes de longitud/filtrado de pistes AD via KNN+LLM)
+      3) introspection (aplicació de regles apreses de HITL via LLM)
+    - Devuelve el SRT final (o el original si ningún paso está activo).
+    """
+
+    flags = _load_refinement_flags(config_path)
+
+    srt = initial_srt
+
+    if flags.get("reflection_ma_enabled", False):
+        srt = refine_srt_with_reflection_ma(srt)
+    elif flags.get("reflection_enabled", False):
+        srt = refine_srt_with_reflection(srt)
+
+    if flags.get("reflexion_enabled", False):
+        srt = refine_srt_with_reflexion(srt)
+
+    if flags.get("introspection_enabled", False):
+        srt = refine_srt_with_introspection(srt)
+
+    return srt
+
+
+def execute_refinement_for_video(
+    sha1sum: str,
+    version: str,
+    *,
+    config_path: Optional[Path] = None,
+) -> str:
+    """Executa el pipeline de refinament per a un vídeo (sha1sum, version).
+
+    - Llegeix une_ad/json_ad/casting/scenarios des de les BDs de demo.
+    - Aplica, segons flags de config.yaml (o config_path):
+      1) reflection: via `refine_video_with_reflection(sha1sum, version)`
+      2) reflexion: ajustos de longitud/filtrat sobre el SRT resultat
+      3) introspection: aplicació de regles apreses sobre el SRT resultat
+    - Retorna el SRT final.
+    """
+
+    flags = _load_refinement_flags(config_path)
+
+    # 1) Reflection sobre el SRT UNE/JSON de la BD (imprescindible en aquest flux)
+    if flags.get("reflection_ma_enabled", False):
+        srt = refine_video_with_reflection_ma(sha1sum, version)
+    elif flags.get("reflection_enabled", False):
+        srt = refine_video_with_reflection(sha1sum, version)
+    else:
+        # Si es desactiva reflection, intentem igualment llegir une_ad de BD com a punt de partida
+        from demo.databases import get_audiodescription  # type: ignore
+
+        row = get_audiodescription(sha1sum, version)
+        if row is None or "une_ad" not in row.keys():
+            raise ValueError(
+                f"No s'ha trobat une_ad a audiodescriptions.db per sha1sum={sha1sum}, version={version}"
+            )
+        srt = row["une_ad"] or ""
+
+    # 2) Reflexion (dummy, treballa directament sobre el SRT en memòria)
+    if flags.get("reflexion_enabled", False):
+        srt = refine_srt_with_reflexion(srt)
+
+    # 3) Introspection (dummy)
+    if flags.get("introspection_enabled", False):
+        srt = refine_srt_with_introspection(srt)
+
+    return srt
+
+
+if __name__ == "__main__":  # Pequeña demo manual
+    demo_srt = """1\n00:00:00,000 --> 00:00:03,000\n(AD) Una noia entra a l'aula.\n"""
+    refined = execute_refinement(demo_srt)
+    print("=== SRT original ===")
+    print(demo_srt)
+    print("\n=== SRT refinat ===")
+    print(refined)

refinement/reflection.py

@@ -0,0 +1,672 @@
+import os
+import csv
+import json
+import logging
+import shutil
+import sqlite3
+from pathlib import Path
+from typing import TypedDict, Annotated, List, Dict, Union
+from langgraph.graph import StateGraph, END
+from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
+from langchain_openai import ChatOpenAI
+from operator import itemgetter
+
+# --- Configuración y Herramientas ---
+
+# Directorios de trabajo
+BASE_DIR = Path(__file__).resolve().parent
+REPO_ROOT = BASE_DIR.parents[2]
+DEMO_DIR = REPO_ROOT / "demo"
+DEMO_TEMP_DIR = DEMO_DIR / "temp"
+DEMO_DATA_DIR = DEMO_DIR / "data"
+
+TEMP_DIR = BASE_DIR / "temp"
+TEMP_DIR.mkdir(exist_ok=True)
+
+LOG_FILE = TEMP_DIR / "reflection.log"
+
+# Configurar el logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(levelname)s: %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler(LOG_FILE, encoding="utf-8")
+    ],
+)
+logger = logging.getLogger(__name__)
+
+# Asegúrate de configurar tu API Key.
+# En un entorno real, usa os.environ["OPENAI_API_KEY"]
+# Aquí usamos un placeholder para la demostración.
+if "OPENAI_API_KEY" not in os.environ:
+    logger.warning("OPENAI_API_KEY no está configurada. Usando un placeholder.")
+    os.environ["OPENAI_API_KEY"] = "sk-..." 
+
+# Inicializar LLM (se usa GPT-4o por su capacidad de razonamiento)
+# En producción, considera un modelo que soporte tus tokens y latencia requeridas.
+llm = ChatOpenAI(model="gpt-4o", temperature=0.3)
+
+# --- Ficheros de Ejemplo ---
+
+# Fichero SRT inicial (Narrador)
+INITIAL_SRT_CONTENT = """
+1
+00:00:00,000 --> 00:00:05,340
+[Sandra] Però de veritat crec que aquest projecte canviarà la nostra nota final.
+
+2
+00:00:04,340 --> 00:00:05,790
+[Lucía] Hem de donar-ho tot.
+
+3
+00:00:05,790 --> 00:00:08,790
+[Sandra] Ho sé, ho sé.
+
+4
+00:00:08,000 --> 00:00:10,000
+(AD) De sobte, són al parc.
+
+5
+00:00:10,000 --> 00:00:14,000
+(AD) Ara tallen menjar i fan una amanida a una cuina.
+"""
+
+# Fichero JSON de contexto (ejemplo de la respuesta anterior, pero simplificado para el Narrador)
+CONTEXT_JSON_CONTENT = """
+{
+  "segments": [
+    {"id": 1, "start": "00:00:00,000", "end": "00:00:05,340", "type": "dialog", "text": "[Sandra] Però de veritat crec que aquest projecte canviarà la nostra nota final."},
+    {"id": 2, "start": "00:00:04,340", "end": "00:00:05,790", "type": "dialog", "text": "[Lucía] Hem de donar-ho tot."},
+    {"id": 3, "start": "00:00:05,790", "end": "00:00:08,790", "type": "dialog", "text": "[Sandra] Ho sé, ho sé."},
+    {"id": 4, "start": "00:00:08,000", "end": "00:00:10,000", "type": "visual_context", "text": "Cambio de escena a un parque. Personajes caminando."},
+    {"id": 5, "start": "00:00:10,000", "end": "00:00:14,000", "type": "visual_context", "text": "Escena en una cocina. Los personajes están cortando vegetales y haciendo una ensalada."}
+  ]
+}
+"""
+
+# Fichero de Reglas UNE (Norma Técnica para el Crítico)
+# Nota: Aquí se usa un resumen de las reglas pertinentes para un LLM.
+UNE_RULES = """
+### Reglas UNE de Audiodescripción (Para el Crítico)
+1.  **Objetividad y Foco Visual:** La descripción debe ser puramente objetiva, describiendo solo lo que se ve. Debe priorizar la acción y los elementos relevantes (personajes, objetos, localización).
+2.  **Tiempo y Espacio (Sincronización):** Las audiodescripciones (AD) deben insertarse en los silencios del diálogo. El tiempo de la AD (entre START y END) debe ser suficiente para narrar el contenido sin solaparse con el diálogo o la música importante.
+3.  **Concisión y Claridad:** Usar lenguaje simple y conciso. Evitar redundancias y juicios de valor.
+4.  **Formato:** Cada segmento de AD debe tener un formato SRT válido, incluyendo el marcador (AD) al principio de la línea de texto.
+5.  **Utilidad:** Cada segmento de AD debe ser útil para la comprensión y nunca ser redundante. En caso de repetir algo ya explicado antes, mejor no decir nada.
+"""
+
+EVALUATION_CRITERIA = [
+    "Precisió Descriptiva",
+    "Sincronització Temporal",
+    "Claredat i Concisió",
+    "Inclusió de Diàleg/So",
+    "Contextualització",
+    "Flux i Ritme de la Narració",
+]
+
+CRITERIA_WEIGHTS = {
+    "Precisió Descriptiva": 1,
+    "Sincronització Temporal": 4,
+    "Claredat i Concisió": 1,
+    "Inclusió de Diàleg/So": 1,
+    "Contextualització": 1,
+    "Flux i Ritme de la Narració": 1,
+}
+
+def setup_files(initial_srt_content: str, context_json_content: str):
+    """Crea los ficheros iniciales necesarios en el sistema de archivos local."""
+    (TEMP_DIR / "une_ad_0.srt").write_text(initial_srt_content, encoding="utf-8")
+    (TEMP_DIR / "json_ad.json").write_text(context_json_content, encoding="utf-8")
+    logger.info("Ficheros iniciales 'une_ad_0.srt' y 'json_ad.json' creados.")
+
+
+def _load_audiodescription_from_db(sha1sum: str, version: str) -> tuple[str, str]:
+    """Carga une_ad y info_ad desde demo/temp/audiodescriptions.db.
+
+    Si info_ad no existeix o és nul, es fa servir CONTEXT_JSON_CONTENT com a
+    fallback per no trencar el pipeline.
+    """
+
+    db_path = DEMO_TEMP_DIR / "audiodescriptions.db"
+    if not db_path.exists():
+        raise FileNotFoundError(f"No s'ha trobat {db_path}")
+
+    conn = sqlite3.connect(str(db_path))
+    conn.row_factory = sqlite3.Row
+    try:
+        cur = conn.cursor()
+        cur.execute(
+            "SELECT * FROM audiodescriptions WHERE sha1sum=? AND version=?",
+            (sha1sum, version),
+        )
+        row = cur.fetchone()
+        if row is None:
+            raise ValueError(
+                f"No s'ha trobat cap registre a audiodescriptions.db per sha1sum={sha1sum}, version={version}"
+            )
+
+        une_ad = row["une_ad"] or ""
+        # info_ad és una columna de text amb el JSON de context (abans json_ad/preprocess.json)
+        info_ad_text = None
+        if "info_ad" in row.keys():
+            info_ad_text = row["info_ad"]
+        elif "json_ad" in row.keys():  # compatibilitat enrere
+            info_ad_text = row["json_ad"]
+
+        if not info_ad_text:
+            logger.warning("info_ad buit a audiodescriptions.db; fent servir CONTEXT_JSON_CONTENT de mostra.")
+            info_ad_text = CONTEXT_JSON_CONTENT
+
+        return une_ad, info_ad_text
+    finally:
+        conn.close()
+
+
+def _write_casting_csv_from_db(sha1sum: str) -> None:
+    """Reconstrueix TEMP_DIR/casting.csv a partir de demo/data/casting.db.
+
+    El format és simple: capçalera "name,description" i una fila per registre.
+    Si no hi ha BD o registres, el fitxer no es crea i l'agent d'identitat es
+    saltarà automàticament.
+    """
+
+    db_path = DEMO_DATA_DIR / "casting.db"
+    if not db_path.exists():
+        logger.warning("casting.db no trobat; no es generarà casting.csv")
+        return
+
+    conn = sqlite3.connect(str(db_path))
+    conn.row_factory = sqlite3.Row
+    try:
+        cur = conn.cursor()
+        cur.execute("SELECT name, description FROM casting WHERE sha1sum=?", (sha1sum,))
+        rows = cur.fetchall()
+        if not rows:
+            logger.info("Sense registres de casting per a sha1sum=%s", sha1sum)
+            return
+
+        out_path = TEMP_DIR / "casting.csv"
+        with out_path.open("w", encoding="utf-8", newline="") as f:
+            writer = csv.writer(f)
+            writer.writerow(["name", "description"])
+            for r in rows:
+                writer.writerow([r["name"], r["description"]])
+
+        logger.info("casting.csv generat a %s amb %d registres", out_path, len(rows))
+    finally:
+        conn.close()
+
+
+def _write_scenarios_csv_from_db(sha1sum: str) -> None:
+    """Reconstrueix TEMP_DIR/scenarios.csv a partir de demo/data/scenarios.db.
+
+    Format: capçalera "name,description" i una fila per escenari.
+    """
+
+    db_path = DEMO_DATA_DIR / "scenarios.db"
+    if not db_path.exists():
+        logger.warning("scenarios.db no trobat; no es generarà scenarios.csv")
+        return
+
+    conn = sqlite3.connect(str(db_path))
+    conn.row_factory = sqlite3.Row
+    try:
+        cur = conn.cursor()
+        cur.execute("SELECT name, description FROM scenarios WHERE sha1sum=?", (sha1sum,))
+        rows = cur.fetchall()
+        if not rows:
+            logger.info("Sense registres d'escenaris per a sha1sum=%s", sha1sum)
+            return
+
+        out_path = TEMP_DIR / "scenarios.csv"
+        with out_path.open("w", encoding="utf-8", newline="") as f:
+            writer = csv.writer(f)
+            writer.writerow(["name", "description"])
+            for r in rows:
+                writer.writerow([r["name"], r["description"]])
+
+        logger.info("scenarios.csv generat a %s amb %d registres", out_path, len(rows))
+    finally:
+        conn.close()
+
+# --- Utilidades ---
+def _strip_markdown_fences(content: str) -> str:
+    """Elimina fences ```...``` alrededor de una respuesta JSON si existen."""
+    text = content.strip()
+    if text.startswith("```"):
+        lines = text.splitlines()
+        # descartar primera línea con ``` o ```json
+        lines = lines[1:]
+        # eliminar el cierre ``` (pueden existir varias líneas en blanco finales)
+        while lines and lines[-1].strip() == "```":
+            lines.pop()
+        text = "\n".join(lines).strip()
+    return text
+
+
+def generate_evaluation_report(srt_content: str, iteration: int) -> tuple[float, float, Path]:
+    """Solicita al LLM una avaluació estructurada i guarda'n el CSV."""
+    criteria_formatted = "\n".join(f"- {name}" for name in EVALUATION_CRITERIA)
+    prompt = (
+        "Actua com un auditor UNE. Avalua l'SRT generat, puntuant cada característica de 0 a 7 "
+        "segons la qualitat observada. Dónega justificació breve però concreta per a cada cas. "
+        "Les característiques obligatòries són:\n"
+        f"{criteria_formatted}\n"
+        "Retorna ÚNICAMENT un array JSON d'objectes amb les claus: "
+        "'caracteristica', 'valoracio' (nombre enter de 0 a 7) i 'justificacio'."
+    )
+
+    response = llm.invoke(
+        [
+            SystemMessage(content=prompt),
+            HumanMessage(
+                content=(
+                    "# SRT AVALUAT\n"
+                    f"{srt_content}\n\n"
+                    "Assegura't de complir el format indicat."
+                )
+            ),
+        ]
+    )
+
+    cleaned = _strip_markdown_fences(response.content)
+    try:
+        data = json.loads(cleaned)
+        if not isinstance(data, list):
+            raise ValueError("La resposta no és una llista.")
+    except Exception as exc:
+        logger.error(
+            "Error al generar l'avaluació estructurada: %s. Resposta original: %s",
+            exc,
+            response.content,
+        )
+        data = [
+            {
+                "caracteristica": "Avaluació fallida",
+                "valoracio": 1,
+                "justificacio": "No s'ha pogut obtenir l'avaluació del LLM.",
+            }
+        ]
+
+    eval_path = TEMP_DIR / f"eval_{iteration}.csv"
+    with eval_path.open("w", encoding="utf-8", newline="") as csvfile:
+        writer = csv.writer(csvfile)
+        writer.writerow(["Caracteristica", "Valoracio (0-7)", "Justificacio"])
+        for item in data:
+            writer.writerow(
+                [
+                    item.get("caracteristica", ""),
+                    item.get("valoracio", 0),
+                    item.get("justificacio", ""),
+                ]
+            )
+
+    scores = []
+    weighted_sum = 0.0
+    total_weight = 0.0
+
+    for entry in data:
+        if not isinstance(entry, dict):
+            continue
+        try:
+            score = float(entry.get("valoracio", 0))
+        except (TypeError, ValueError):
+            score = 0.0
+        scores.append(score)
+
+        weight = CRITERIA_WEIGHTS.get(entry.get("caracteristica", ""), 1)
+        weighted_sum += score * weight
+        total_weight += weight
+
+    mean_score = sum(scores) / len(scores) if scores else 0.0
+    weighted_mean = weighted_sum / total_weight if total_weight else mean_score
+    return mean_score, weighted_mean, eval_path
+
+# --- Definición del Estado de la Gráfica (StateGraph) ---
+class ReflectionState(TypedDict):
+    """Representa el estado del bucle de reflexión."""
+    iteration: int  # Ciclo actual (empezando en 0)
+    current_srt_path: str  # Ruta al archivo SRT actual (e.g., une_ad_0.srt, une_ad_1.srt)
+    critic_report: Dict[str, Union[float, str]]  # Último informe del crítico (puntuación y texto)
+    history: List[SystemMessage] # Historial de mensajes entre agentes
+    evaluation_mean: float
+    best_iteration: int
+    best_weighted_mean: float
+    best_srt_path: str
+    best_eval_path: str
+
+# --- Nodos/Agentes de la Gráfica ---
+def narrator_agent(state: ReflectionState):
+    """
+    Agente que genera o reescribe el SRT.
+    - En el ciclo 0, genera el SRT inicial.
+    - En ciclos > 0, reescribe el SRT basándose en el critic_report.
+    """
+    iteration = state["iteration"]
+    critic_report = state["critic_report"]
+    history = state["history"]
+    
+    # Cargar contexto y último SRT
+    json_context = (TEMP_DIR / "json_ad.json").read_text(encoding="utf-8")
+    current_srt = Path(state["current_srt_path"]).read_text(encoding="utf-8")
+
+    # 1. Definir el prompt
+    if iteration == 0:
+        # Tarea inicial (aunque en este caso ya se proporciona une_ad_0.srt)
+        # Aquí se simula la generación inicial.
+        prompt = (
+            "Ets un Narrador expert en Audiodescripció (AD). La teva tasca inicial és generar "
+            "un fitxer SRT d'audiodescripcions basat en el JSON de context visual. "
+            "TOT I AIXÍ, per a aquesta primera iteració, l'SRT ja s'ha generat. "
+            "Simplement retorna el contingut de 'une_ad_0.srt' com si fos la teva sortida. "
+            "Assegura't que totes les audiodescripcions estiguin en català i que cadascuna pugui ser locutada "
+            "dins del temps disponible (utilitza un màxim aproximat d'11 caràcters per segon). Si el tram de temps "
+            "és massa curt (<1.5s), combina'l amb el bloc d'AD més proper i ajusta els timestamps perquè la narració sigui fluida. "
+            "Evita redundàncies: no repeteixis informació ja descrita en segments d'AD anteriors o al diàleg, i elimina qualsevol detall que no sigui essencial."
+        )
+        output_srt = current_srt
+        reflection_text = "Generación inicial. No hay reflexión."
+    else:
+        # Tarea de reflexión
+        prompt = (
+            "Ets un Narrador expert en Audiodescripció (AD). Has rebut una crítica sobre la teva última versió de l'SRT. "
+            "La teva tasca és REESCRIURE el contingut d'audiodescripció (línies amb '(AD)') del fitxer SRT, "
+            "assegurant que sigui coherent amb el JSON de context i, sobretot, que CORREGEIXIS TOTS els problemes "
+            "mencionats a l'Informe Crític adjunt. Mantén intactes els diàlegs (línies amb [Nom]) i escriu totes les audiodescripcions en català natural. "
+            "Garanteix que cada bloc d'AD pugui ser locutat dins del seu interval temporal disponible considerant un màxim d'11 caràcters per segon. "
+            "Si l'interval és massa curt (<1.5s), fusiona'l amb el bloc d'AD anterior o posterior més proper i ajusta els timestamps perquè quedin contínues. "
+            "Prefereix frases concises i accionables, prioritzant la informació visual essencial, i elimina redundàncies amb AD anteriors o amb els diàlegs."
+        )
+        
+        # Concatenar la entrada para el LLM
+        input_content = f"""
+        # INFORME CRÍTICO
+        Porcentaje de Fiabilidad Anterior: {critic_report.get('reliability_percentage')}
+        Crítica Cualitativa: {critic_report.get('qualitative_critique')}
+
+        # JSON DE CONTEXTO VISUAL (Guía para la AD)
+        {json_context}
+
+        # ÚLTIMO ARCHIVO SRT GENERADO (une_ad_{iteration-1}.srt)
+        {current_srt}
+
+        REGLAS: Tu respuesta debe ser *SOLAMENTE* el contenido completo del nuevo archivo SRT (incluyendo diálogos), sin ningún comentario o explicación adicional.
+        """
+        
+        # Llamada al LLM
+        response = llm.invoke(
+            [
+                SystemMessage(content=prompt),
+                HumanMessage(content=input_content)
+            ]
+        )
+        
+        output_srt = response.content
+        reflection_text = f"Reescrito en base al informe crítico: {critic_report.get('qualitative_critique', 'N/A')}"
+
+    # 2. Guardar la nueva salida
+    new_srt_path = TEMP_DIR / f"une_ad_{iteration}.srt"
+    new_srt_path.write_text(output_srt, encoding="utf-8")
+
+    # 3. Guardar el pensamiento (reflection_text)
+    (TEMP_DIR / f"thinking_{iteration}.txt").write_text(reflection_text, encoding="utf-8")
+
+    logger.info(f"Narrador: Generada la versión {iteration} del SRT en '{new_srt_path}'.")
+
+    # 4. Actualizar el estado
+    new_history = history + [AIMessage(content=f"Narrador v{iteration} completado. Razón de reflexión: {reflection_text}")]
+    return {
+        "iteration": iteration,
+        "current_srt_path": str(new_srt_path),
+        "history": new_history,
+        "evaluation_mean": state.get("evaluation_mean", 0.0),
+        "best_iteration": state.get("best_iteration", -1),
+        "best_weighted_mean": state.get("best_weighted_mean", 0.0),
+        "best_srt_path": state.get("best_srt_path", str(new_srt_path)),
+        "best_eval_path": state.get("best_eval_path", str(TEMP_DIR / f"eval_{iteration}.csv")),
+    }
+
+def critic_agent(state: ReflectionState):
+    """
+    Agente que evalúa la calidad del SRT generado por el Narrador basándose en las Reglas UNE.
+    Devuelve una puntuación y una crítica cualitativa.
+    """
+    iteration = state["iteration"]
+    history = state["history"]
+    current_srt = Path(state["current_srt_path"]).read_text(encoding="utf-8")
+    
+    prompt = (
+        "Ets un Crític d'Audiodescripció molt estricte. La teva tasca és avaluar l'SRT adjunt "
+        "únicament segons les Regles UNE proporcionades. L'avaluació ha de ser doble: "
+        "1. **Numèrica**: Un percentatge de fiabilitat (ex. 85.5) de 0 a 100%. "
+        "2. **Qualitativa**: Una crítica constructiva sobre les principals mancances de les AD respecte a les regles. "
+        "Has de ser EXTREMADAMENT estricte amb la sincronització (sense solapament amb el diàleg), "
+        "amb l'adequació temporal (velocitat màxima recomanada d'11 caràcters per segon) i amb l'absència de redundàncies. "
+        "Comprova també que totes les audiodescripcions estan escrites en català natural."
+    )
+    
+    input_content = f"""
+    # REGLAS UNE DE AUDIODESCRIPCIÓN:
+    {UNE_RULES}
+
+    # ARCHIVO SRT A EVALUAR (une_ad_{iteration}.srt):
+    {current_srt}
+
+    REGLAS DE RESPUESTA:
+    Tu respuesta debe ser *SOLAMENTE* un objeto JSON con dos claves:
+    1. "reliability_percentage": (float) El porcentaje de fiabilidad.
+    2. "qualitative_critique": (string) La crítica cualitativa y sugerencias de mejora.
+    Ejemplo de respuesta: {{"reliability_percentage": 75.0, "qualitative_critique": "El segmento 4 se solapa 0.34s con el diálogo de Sandra. El segmento 5 es demasiado genérico y no describe bien la acción."}}
+    """
+    
+    # Llamada al LLM
+    response = llm.invoke(
+        [
+            SystemMessage(content=prompt),
+            HumanMessage(content=input_content)
+        ]
+    )
+
+    # Intentar parsear la respuesta del LLM (puede fallar, por eso se usa un try/except)
+    try:
+        cleaned_response = _strip_markdown_fences(response.content)
+        report = json.loads(cleaned_response)
+        if not isinstance(report, dict) or 'reliability_percentage' not in report:
+            raise ValueError("Estructura JSON incorrecta.")
+    except Exception as e:
+        logger.error(f"Error al parsear el JSON del Crítico: {e}. Respuesta: {response.content}")
+        report = {"reliability_percentage": 1.0, "qualitative_critique": "El Crítico no devolvió un JSON válido. Reintentar."}
+
+    logger.info(f"Crítico: Evaluación completada. Fiabilidad: {report.get('reliability_percentage')}%.")
+    
+    mean_score, weighted_mean, eval_path = generate_evaluation_report(current_srt, iteration)
+
+    thinking_path = TEMP_DIR / f"thinking_{iteration}.txt"
+    if thinking_path.exists():
+        previous_text = thinking_path.read_text(encoding="utf-8")
+        thinking_path.write_text(
+            (
+                f"{previous_text}\n\nMitjana simple d'avaluació: {mean_score:.2f} / 7"
+                f"\nMitjana ponderada d'avaluació: {weighted_mean:.2f} / 7"
+            ),
+            encoding="utf-8",
+        )
+
+    best_iteration = state.get("best_iteration", -1)
+    best_weighted_mean = state.get("best_weighted_mean", -1.0)
+    best_srt_path = state.get("best_srt_path", state["current_srt_path"])
+    best_eval_path = state.get("best_eval_path", str(eval_path))
+
+    if weighted_mean > best_weighted_mean:
+        best_iteration = iteration
+        best_weighted_mean = weighted_mean
+        best_srt_path = state["current_srt_path"]
+        best_eval_path = str(eval_path)
+
+    new_history = history + [
+        AIMessage(
+            content=(
+                "Crítico v{iter} completado. Fiabilidad: {reliab}%. "
+                "Mitjana simple: {mean:.2f}/7. Mitjana ponderada: {wmean:.2f}/7"
+            ).format(
+                iter=iteration,
+                reliab=report.get("reliability_percentage"),
+                mean=mean_score,
+                wmean=weighted_mean,
+            )
+        )
+    ]
+    return {
+        "iteration": iteration + 1,
+        "critic_report": report,
+        "history": new_history,
+        "evaluation_mean": weighted_mean,
+        "best_iteration": best_iteration,
+        "best_weighted_mean": best_weighted_mean,
+        "best_srt_path": best_srt_path,
+        "best_eval_path": best_eval_path,
+    }
+
+
+# --- Condición de Salida del Bucle ---
+
+def should_continue(state: ReflectionState) -> str:
+    """
+    Función de chequeo que decide si continuar iterando o finalizar.
+    """
+    MAX_ITERATIONS = 5  # Número máximo de ciclos
+    MIN_AVERAGE_SCORE = 6.0  # Umbral de calidad sobre 7
+
+    iteration = state["iteration"]
+    mean_score = state.get("evaluation_mean", 0.0)
+
+    if mean_score >= MIN_AVERAGE_SCORE:
+        logger.info(f"FIN: Mitjana ponderada d'avaluació assolida ({mean_score:.2f} >= {MIN_AVERAGE_SCORE}).")
+        return "end"
+
+    if iteration >= MAX_ITERATIONS:
+        logger.info(f"FIN: S'ha assolit el màxim d'iteracions ({iteration} / {MAX_ITERATIONS}).")
+        return "end"
+
+    logger.info(f"CONTINUAR: Iteració {iteration} / {MAX_ITERATIONS}. Mitjana ponderada actual: {mean_score:.2f} / 7.")
+    return "continue"
+
+# --- Construcción de la Gráfica ---
+
+# 1. Configurar el estado inicial
+initial_state: ReflectionState = {
+    "iteration": 0,
+    "current_srt_path": str(TEMP_DIR / "une_ad_0.srt"),
+    "critic_report": {"reliability_percentage": 0.0, "qualitative_critique": "Inicializando el proceso."},
+    "history": [],
+    "evaluation_mean": 0.0,
+    "best_iteration": -1,
+    "best_weighted_mean": -1.0,
+    "best_srt_path": str(TEMP_DIR / "une_ad_0.srt"),
+    "best_eval_path": str(TEMP_DIR / "eval_0.csv"),
+}
+
+# 2. Definir la gráfica
+workflow = StateGraph(ReflectionState)
+
+# Nodos
+workflow.add_node("narrator", narrator_agent)
+workflow.add_node("critic", critic_agent)
+
+# Estructura del bucle: Narrator -> Critic -> Check
+workflow.set_entry_point("narrator")
+workflow.add_edge("narrator", "critic")
+
+# Condición (puente de ramificación)
+workflow.add_conditional_edges(
+    "critic",
+    should_continue,
+    {
+        "continue": "narrator", # Si no se cumple el umbral/ciclo, vuelve al narrador
+        "end": END               # Si se cumple, termina
+    }
+)
+
+# Compilar la gráfica
+app = workflow.compile()
+
+
+def run_reflection_pipeline(srt_content: str, context_json: str | None = None) -> str:
+    """Executa el grafo de reflexió sobre un SRT i retorna el SRT final.
+
+    - Escriu ``une_ad_0.srt`` i ``json_ad.json`` a ``TEMP_DIR``.
+    - Inicialitza l'estat del bucle de reflexió.
+    - Executa ``app.invoke(initial_state)``.
+    - Copia el millor SRT i eval als fitxers finals i retorna el contingut del
+      millor SRT.
+    """
+
+    # Preparar fitxers d'entrada per als agents
+    setup_files(srt_content, context_json or CONTEXT_JSON_CONTENT)
+
+    logger.info("--- Començant el bucle de reflexió (run_reflection_pipeline) ---")
+
+    # Executar la gràfica
+    final_state = app.invoke(initial_state)
+
+    best_srt_path = Path(final_state["best_srt_path"])
+    best_eval_path = Path(final_state["best_eval_path"])
+
+    # Copiar els millors resultats a fitxers finals estàndard
+    final_srt_path = TEMP_DIR / "une_ad.srt"
+    final_eval_path = TEMP_DIR / "eval.csv"
+
+    try:
+        shutil.copy(best_srt_path, final_srt_path)
+        shutil.copy(best_eval_path, final_eval_path)
+    except Exception as exc:  # pragma: no cover - errors de FS no crítics
+        logger.warning("No s'han pogut copiar els fitxers finals de reflexió: %s", exc)
+
+    return best_srt_path.read_text(encoding="utf-8")
+
+
+def refine_srt_with_reflection(srt_content: str, *, context_json: str | None = None) -> str:
+    """Refina un SRT usant el pipeline de reflexió definit en aquest mòdul.
+
+    Args:
+        srt_content: Contingut SRT inicial (cadena completa).
+        context_json: JSON de context visual (opcional). Si no es proporciona,
+            s'utilitza `CONTEXT_JSON_CONTENT` de mostra.
+
+    Returns:
+        Contingut del SRT final generat pel sistema de reflexió multiagent.
+    """
+
+    return run_reflection_pipeline(srt_content, context_json or CONTEXT_JSON_CONTENT)
+
+
+def refine_video_with_reflection(sha1sum: str, version: str) -> str:
+    """Refina un vídeo identificat per (sha1sum, version) usant les BDs de demo.
+
+    Flux:
+      1. Llegeix une_ad i info_ad des de demo/temp/audiodescriptions.db.
+      2. Regenera TEMP_DIR/casting.csv a partir de demo/data/casting.db.
+      3. Regenera TEMP_DIR/scenarios.csv a partir de demo/data/scenarios.db.
+      4. Executa el pipeline complet de reflexió (run_reflection_pipeline).
+
+    Retorna el contingut del SRT final refinat.
+    """
+
+    une_ad, info_ad = _load_audiodescription_from_db(sha1sum, version)
+
+    # Preparar fitxers necessaris perquè els agents puguin treballar
+    setup_files(une_ad, info_ad)
+    _write_casting_csv_from_db(sha1sum)
+    _write_scenarios_csv_from_db(sha1sum)
+
+    return run_reflection_pipeline(une_ad, info_ad)
+
+
+# --- Ejecución Principal ---
+
+if __name__ == "__main__":
+    # Exemple d'ús directe del mòdul
+    final_srt = refine_srt_with_reflection(INITIAL_SRT_CONTENT, context_json=CONTEXT_JSON_CONTENT)
+    print("\n--- Contingut del SRT Final ---")
+    print(final_srt)

refinement/reflection_ma.py

@@ -0,0 +1,337 @@
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import TypedDict, Dict, Union, List
+
+from langgraph.graph import StateGraph, END
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
+
+from .reflection import (
+    DEMO_TEMP_DIR,
+    DEMO_DATA_DIR,
+    TEMP_DIR,
+    _load_audiodescription_from_db,
+    _write_casting_csv_from_db,
+    _write_scenarios_csv_from_db,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class MultiReflectionState(TypedDict):
+    iteration: int
+    current_srt_path: str
+    critic_report: Dict[str, Union[float, str]]
+    history: List[SystemMessage]
+
+
+# LLM específic per al pipeline multiagent (més econòmic)
+_llm_ma = ChatOpenAI(model="gpt-4o-mini", temperature=0.2)
+
+
+def _read_text(path: Path) -> str:
+    try:
+        return path.read_text(encoding="utf-8")
+    except Exception:
+        return ""
+
+
+def _load_casting_for_sha1(sha1sum: str) -> str:
+    db_path = DEMO_DATA_DIR / "casting.db"
+    if not db_path.exists():
+        return ""
+    import sqlite3
+
+    conn = sqlite3.connect(str(db_path))
+    conn.row_factory = sqlite3.Row
+    try:
+        cur = conn.cursor()
+        cur.execute("SELECT name, description FROM casting WHERE sha1sum=?", (sha1sum,))
+        rows = cur.fetchall()
+        if not rows:
+            return ""
+        data = [dict(r) for r in rows]
+        return json.dumps(data, ensure_ascii=False, indent=2)
+    finally:
+        conn.close()
+
+
+def _load_scenarios_for_sha1(sha1sum: str) -> str:
+    db_path = DEMO_DATA_DIR / "scenarios.db"
+    if not db_path.exists():
+        return ""
+    import sqlite3
+
+    conn = sqlite3.connect(str(db_path))
+    conn.row_factory = sqlite3.Row
+    try:
+        cur = conn.cursor()
+        cur.execute("SELECT name, description FROM scenarios WHERE sha1sum=?", (sha1sum,))
+        rows = cur.fetchall()
+        if not rows:
+            return ""
+        data = [dict(r) for r in rows]
+        return json.dumps(data, ensure_ascii=False, indent=2)
+    finally:
+        conn.close()
+
+
+def narrator_initial(state: MultiReflectionState) -> MultiReflectionState:
+    """Primer pas del narrador: pren l'SRT inicial tal qual.
+
+    En aquest pipeline assumim que l'entrada ja és un SRT UNE inicial.
+    """
+
+    current_path = Path(state["current_srt_path"])
+    if not current_path.exists():
+        logger.warning("[reflection_ma] SRT inicial no trobat a %s", current_path)
+        content = ""
+    else:
+        content = _read_text(current_path)
+
+    history = state["history"] + [AIMessage(content="Narrador inicial: SRT de partida carregat.")]
+    return {
+        "iteration": state["iteration"],
+        "current_srt_path": str(current_path),
+        "critic_report": state.get("critic_report", {}),
+        "history": history,
+    }
+
+
+def identity_manager_agent(state: MultiReflectionState, *, sha1sum: str, info_ad: str) -> MultiReflectionState:
+    """Agent que revisa identitats/personatges a partir del casting i info_ad."""
+
+    srt_path = Path(state["current_srt_path"])
+    srt_content = _read_text(srt_path)
+    casting_json = _load_casting_for_sha1(sha1sum)
+
+    prompt = (
+        "Ets un gestor d'identitats per audiodescripcions. Se't proporciona un SRT "
+        "i informació de casting (personatges) i un JSON de context (info_ad). "
+        "La teva tasca és revisar si els noms i rols dels personatges al SRT són "
+        "coherents amb el casting i el context. Si cal, corregeix els noms/rols "
+        "perquè siguin consistents. Mantén el format SRT i retorna únicament el SRT modificat."
+    )
+
+    content = {
+        "srt": srt_content,
+        "casting": json.loads(casting_json) if casting_json else [],
+        "info_ad": json.loads(info_ad) if info_ad else {},
+    }
+
+    resp = _llm_ma.invoke(
+        [
+            SystemMessage(content=prompt),
+            HumanMessage(content=json.dumps(content, ensure_ascii=False)),
+        ]
+    )
+
+    new_srt = resp.content if isinstance(resp.content, str) else str(resp.content)
+    new_path = TEMP_DIR / "une_ad_ma_identity.srt"
+    new_path.write_text(new_srt, encoding="utf-8")
+
+    history = state["history"] + [AIMessage(content="Identity manager: SRT actualitzat amb identitats coherents.")]
+    return {
+        "iteration": state["iteration"],
+        "current_srt_path": str(new_path),
+        "critic_report": state.get("critic_report", {}),
+        "history": history,
+    }
+
+
+def background_descriptor_agent(state: MultiReflectionState, *, sha1sum: str) -> MultiReflectionState:
+    """Agent que revisa la descripció d'escenaris a partir de scenarios.db."""
+
+    srt_path = Path(state["current_srt_path"])
+    srt_content = _read_text(srt_path)
+    scenarios_json = _load_scenarios_for_sha1(sha1sum)
+
+    prompt = (
+        "Ets un expert en escenaris per audiodescripcions. Se't proporciona un SRT "
+        "i una llista d'escenaris amb noms oficials. La teva tasca és revisar les "
+        "descripcions de llocs al SRT i substituir referències genèriques per aquests "
+        "noms quan millorin la claredat, sense afegir informació inventada. Mantén el "
+        "format SRT i retorna únicament el SRT actualitzat."
+    )
+
+    content = {
+        "srt": srt_content,
+        "scenarios": json.loads(scenarios_json) if scenarios_json else [],
+    }
+
+    resp = _llm_ma.invoke(
+        [
+            SystemMessage(content=prompt),
+            HumanMessage(content=json.dumps(content, ensure_ascii=False)),
+        ]
+    )
+
+    new_srt = resp.content if isinstance(resp.content, str) else str(resp.content)
+    new_path = TEMP_DIR / "une_ad_ma_background.srt"
+    new_path.write_text(new_srt, encoding="utf-8")
+
+    history = state["history"] + [AIMessage(content="Background descriptor: SRT actualitzat amb escenaris contextualitzats.")]
+    return {
+        "iteration": state["iteration"],
+        "current_srt_path": str(new_path),
+        "critic_report": state.get("critic_report", {}),
+        "history": history,
+    }
+
+
+def narrator_refine_agent(state: MultiReflectionState, *, info_ad: str) -> MultiReflectionState:
+    """Segon pas del narrador: reescriu el SRT tenint en compte identitats i escenaris."""
+
+    srt_path = Path(state["current_srt_path"])
+    srt_content = _read_text(srt_path)
+
+    prompt = (
+        "Ets un Narrador d'audiodescripció UNE-153010. Has rebut un SRT on ja s'han "
+        "revisat les identitats dels personatges i els escenaris. La teva tasca és "
+        "refinar el text d'audiodescripció perquè sigui clar, coherent i ajustat al "
+        "temps disponible, mantenint el format SRT i sense alterar els diàlegs. "
+        "Retorna únicament el SRT final."
+    )
+
+    content = {
+        "srt": srt_content,
+        "info_ad": json.loads(info_ad) if info_ad else {},
+    }
+
+    resp = _llm_ma.invoke(
+        [
+            SystemMessage(content=prompt),
+            HumanMessage(content=json.dumps(content, ensure_ascii=False)),
+        ]
+    )
+
+    new_srt = resp.content if isinstance(resp.content, str) else str(resp.content)
+    new_path = TEMP_DIR / "une_ad_ma_final.srt"
+    new_path.write_text(new_srt, encoding="utf-8")
+
+    history = state["history"] + [AIMessage(content="Narrador: SRT refinat després de gestió d'identitats i escenaris.")]
+    return {
+        "iteration": state["iteration"] + 1,
+        "current_srt_path": str(new_path),
+        "critic_report": state.get("critic_report", {}),
+        "history": history,
+    }
+
+
+def critic_agent(state: MultiReflectionState) -> MultiReflectionState:
+    """Agent que avalua qualitativament el SRT final.
+
+    Per simplicitat, aquí no generem CSV ni mitjanes ponderades; només un resum.
+    """
+
+    srt_path = Path(state["current_srt_path"])
+    srt_content = _read_text(srt_path)
+
+    prompt = (
+        "Ets un crític d'audiodescripcions UNE-153010. Avalua breument la qualitat "
+        "del SRT proporcionat en termes de precisió descriptiva, sincronització "
+        "temporal, claredat i adequació dels noms de personatges i escenaris. "
+        "Retorna un text breu en català amb la teva valoració general."
+    )
+
+    resp = _llm_ma.invoke(
+        [
+            SystemMessage(content=prompt),
+            HumanMessage(content=srt_content),
+        ]
+    )
+
+    critique = resp.content if isinstance(resp.content, str) else str(resp.content)
+    report: Dict[str, Union[float, str]] = {
+        "qualitative_critique": critique,
+    }
+
+    history = state["history"] + [AIMessage(content="Crític: valoració final generada.")]
+    return {
+        "iteration": state["iteration"],
+        "current_srt_path": state["current_srt_path"],
+        "critic_report": report,
+        "history": history,
+    }
+
+
+# Construcció del graf
+_graph = StateGraph(MultiReflectionState)
+_graph.add_node("narrator_initial", narrator_initial)
+_graph.add_node("identity_manager", lambda s: identity_manager_agent(s, sha1sum=_graph.sha1sum, info_ad=_graph.info_ad))
+_graph.add_node("background_descriptor", lambda s: background_descriptor_agent(s, sha1sum=_graph.sha1sum))
+_graph.add_node("narrator_refine", lambda s: narrator_refine_agent(s, info_ad=_graph.info_ad))
+_graph.add_node("critic", critic_agent)
+
+_graph.set_entry_point("narrator_initial")
+_graph.add_edge("narrator_initial", "identity_manager")
+_graph.add_edge("identity_manager", "background_descriptor")
+_graph.add_edge("background_descriptor", "narrator_refine")
+_graph.add_edge("narrator_refine", "critic")
+_graph.add_edge("critic", END)
+
+
+def _compile_app(sha1sum: str, info_ad: str):
+    """Compila una instància de l'app de LangGraph amb paràmetres de vídeo."""
+
+    # Guardem paràmetres al propi objecte graf per a les lambdes
+    _graph.sha1sum = sha1sum  # type: ignore[attr-defined]
+    _graph.info_ad = info_ad  # type: ignore[attr-defined]
+    return _graph.compile()
+
+
+def refine_video_with_reflection_ma(sha1sum: str, version: str) -> str:
+    """Refina un vídeo (sha1sum, version) amb el pipeline multiagent de 4 agents.
+
+    - Llegeix une_ad i info_ad de audiodescriptions.db (demo/temp).
+    - Llegeix casting/scenarios per al mateix sha1sum.
+    - Executa el pipeline narrator -> identity_manager -> background_descriptor -> narrator -> critic.
+    - Retorna el SRT final generat.
+    """
+
+    une_ad, info_ad = _load_audiodescription_from_db(sha1sum, version)
+
+    # Preparar fitxer inicial d'entrada
+    TEMP_DIR.mkdir(exist_ok=True, parents=True)
+    initial_path = TEMP_DIR / "une_ad_ma_0.srt"
+    initial_path.write_text(une_ad or "", encoding="utf-8")
+
+    app = _compile_app(sha1sum, info_ad or "")
+    initial_state: MultiReflectionState = {
+        "iteration": 0,
+        "current_srt_path": str(initial_path),
+        "critic_report": {},
+        "history": [],
+    }
+
+    final_state = app.invoke(initial_state)
+    final_path = Path(final_state["current_srt_path"])
+    return _read_text(final_path)
+
+
+def refine_srt_with_reflection_ma(srt_content: str) -> str:
+    """Variant simplificada que només rep un SRT (sense info de BD).
+
+    Es limita a fer passar el SRT pel pipeline d'identitat/escenaris sense mirar casting/scenarios/info_ad.
+    Útil per a proves unitàries.
+    """
+
+    TEMP_DIR.mkdir(exist_ok=True, parents=True)
+    initial_path = TEMP_DIR / "une_ad_ma_0.srt"
+    initial_path.write_text(srt_content or "", encoding="utf-8")
+
+    # En aquest mode "standalone" no tenim sha1sum ni info_ad
+    app = _compile_app(sha1sum="", info_ad="{}")
+    initial_state: MultiReflectionState = {
+        "iteration": 0,
+        "current_srt_path": str(initial_path),
+        "critic_report": {},
+        "history": [],
+    }
+
+    final_state = app.invoke(initial_state)
+    final_path = Path(final_state["current_srt_path"])
+    return _read_text(final_path)

refinement/reflexion.py

@@ -0,0 +1,486 @@
+"""Mòdul per a l'agent de "reflexion".
+
+Entrenament:
+
+- A partir de parelles (une_ad_auto, une_ad_hitl) per a cada sha1sum, es
+  comparen les pistes d'audiodescripció (línies amb "(AD)") amb intervals
+  de temps coincidents.
+- Per a cada pista es calcula la durada i les longituds (caràcters i paraules)
+  i s'etiqueta el cas com S/E/R/X/C:
+    * S: mateixa longitud aproximada.
+    * E: alargament de la frase.
+    * R: reducció de la frase.
+    * X: eliminació de la frase a la versió HITL.
+    * C: creació de frase, la versió automàtica era buida/inexistent.
+- Es desa un CSV amb les mostres i s'entrena un KNN (K=5) que assigna
+  probabilitats a cadascun dels casos.
+
+Aplicació:
+
+- Per a un SRT donat, es calculen les mateixes variables per a cada pista
+  d'(AD) i s'aplica el model KNN per decidir S/E/R/X/C.
+- S/C: es deixa el text tal qual.
+- X: s'elimina la pista.
+- E/R: es demana a GPT-4o-mini que alargui/curti lleugerament la frase,
+  en una sola crida per a totes les frases afectades.
+"""
+
+from __future__ import annotations
+
+import csv
+import json
+import logging
+import math
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional, Tuple
+
+from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_openai import ChatOpenAI
+
+try:  # sklearn és opcional; si no hi és, el pas de reflexion es degrada a no-op
+    from sklearn.neighbors import KNeighborsClassifier
+    import joblib
+except Exception:  # pragma: no cover - entorns sense sklearn
+    KNeighborsClassifier = None  # type: ignore
+    joblib = None  # type: ignore
+
+from .introspection import _iter_une_vs_hitl_pairs  # reutilitzem el mateix parellador
+
+
+logger = logging.getLogger(__name__)
+
+
+BASE_DIR = Path(__file__).resolve().parent
+REFINEMENT_TEMP_DIR = BASE_DIR / "temp"
+REFINEMENT_TEMP_DIR.mkdir(exist_ok=True, parents=True)
+
+REFLEXION_CSV_PATH = REFINEMENT_TEMP_DIR / "reflexion.csv"
+REFLEXION_MODEL_PATH = REFINEMENT_TEMP_DIR / "reflexion_knn.joblib"
+
+
+@dataclass
+class AdCue:
+    start: float
+    end: float
+    text: str
+    block_lines: List[str]
+
+    @property
+    def duration(self) -> float:
+        return max(0.0, self.end - self.start)
+
+    @property
+    def char_len(self) -> int:
+        return len(self.text)
+
+    @property
+    def word_len(self) -> int:
+        return len(self.text.split())
+
+
+def _parse_timestamp(ts: str) -> float:
+    """Converteix un timestamp SRT HH:MM:SS,mmm a segons."""
+
+    try:
+        hh, mm, rest = ts.split(":")
+        ss, ms = rest.split(",")
+        return int(hh) * 3600 + int(mm) * 60 + int(ss) + int(ms) / 1000.0
+    except Exception:
+        return 0.0
+
+
+def _parse_srt_ad_cues(srt_content: str) -> List[AdCue]:
+    """Extreu pistes d'(AD) d'un SRT.
+
+    Retorna una llista d'AdCue amb start/end, text (sense el prefix "(AD)") i
+    les línies de bloc originals per poder reconstruir l'SRT.
+    """
+
+    lines = srt_content.splitlines()
+    i = 0
+    cues: List[AdCue] = []
+
+    while i < len(lines):
+        # Saltar línies buides
+        if not lines[i].strip():
+            i += 1
+            continue
+
+        # Pot ser el número de bloc
+        idx_line = lines[i].strip()
+        i += 1
+        if i >= len(lines):
+            break
+
+        # Línia de temps
+        if "-->" not in lines[i]:
+            # Format inesperat, busquem el següent bloc
+            continue
+
+        time_line = lines[i].strip()
+        i += 1
+        try:
+            start_str, end_str = [part.strip() for part in time_line.split("-->")]
+        except ValueError:
+            continue
+
+        start = _parse_timestamp(start_str)
+        end = _parse_timestamp(end_str)
+
+        text_lines: List[str] = []
+        while i < len(lines) and lines[i].strip():
+            text_lines.append(lines[i])
+            i += 1
+
+        # Ara i és sobre la línia buida (o final); la saltarem al pròxim loop
+
+        # Mirem si alguna línia conté (AD)
+        ad_text_parts: List[str] = []
+        for tl in text_lines:
+            if "(AD)" in tl:
+                # Eliminem el tag, mantenint la resta
+                after = tl.split("(AD)", 1)[1].strip()
+                if after:
+                    ad_text_parts.append(after)
+
+        if not ad_text_parts:
+            continue
+
+        ad_text = " ".join(ad_text_parts).strip()
+        block_lines = [idx_line, time_line] + text_lines
+        cues.append(AdCue(start=start, end=end, text=ad_text, block_lines=block_lines))
+
+    return cues
+
+
+def _intervals_overlap(a_start: float, a_end: float, b_start: float, b_end: float) -> bool:
+    return max(a_start, b_start) < min(a_end, b_end)
+
+
+def _build_training_rows() -> List[Tuple[float, int, int, str]]:
+    """Construeix files d'entrenament (dur, chars, words, label) a partir de
+    les parelles (une_ad_auto, une_ad_hitl).
+    """
+
+    rows: List[Tuple[float, int, int, str]] = []
+
+    for sha1sum, une_auto, une_hitl in _iter_une_vs_hitl_pairs():
+        auto_cues = _parse_srt_ad_cues(une_auto)
+        hitl_cues = _parse_srt_ad_cues(une_hitl)
+
+        # Mapatges per superposició d'intervals
+        for ac in auto_cues:
+            # Buscar HITL amb solapament
+            matching: Optional[AdCue] = None
+            for hc in hitl_cues:
+                if _intervals_overlap(ac.start, ac.end, hc.start, hc.end):
+                    matching = hc
+                    break
+
+            if matching is None:
+                # No hi ha pista HITL corresponent -> X (eliminada)
+                if ac.text.strip():
+                    rows.append((ac.duration, ac.char_len, ac.word_len, "X"))
+                continue
+
+            # Tenim parella auto+HITL
+            auto_text = ac.text.strip()
+            hitl_text = matching.text.strip()
+
+            if not auto_text and hitl_text:
+                # Creació: la versió automàtica no tenia text
+                rows.append((matching.duration, 0, 0, "C"))
+                continue
+
+            if not auto_text and not hitl_text:
+                continue
+
+            # Casos S/E/R segons canvi de longitud
+            auto_chars = len(auto_text)
+            hitl_chars = len(hitl_text)
+
+            # Umbral de "canvi negligible" en caràcters
+            diff = hitl_chars - auto_chars
+            if abs(diff) <= max(5, 0.1 * auto_chars):
+                label = "S"
+            elif diff > 0:
+                label = "E"
+            else:
+                label = "R"
+
+            rows.append((ac.duration, ac.char_len, ac.word_len, label))
+
+        # Pistes HITL sense automàtica -> C
+        for hc in hitl_cues:
+            has_auto = any(
+                _intervals_overlap(hc.start, hc.end, ac.start, ac.end) for ac in auto_cues
+            )
+            if not has_auto and hc.text.strip():
+                rows.append((hc.duration, 0, 0, "C"))
+
+    return rows
+
+
+def train_reflexion_model(max_examples: Optional[int] = None) -> None:
+    """Entrena el model KNN de reflexion i desa CSV + model.
+
+    - Construeix ``reflexion.csv`` amb files ``duracion,char_len,word_len,label``.
+    - Entrena un KNN (K=5) i el desa a ``reflexion_knn.joblib``.
+    """
+
+    if KNeighborsClassifier is None or joblib is None:
+        logger.warning(
+            "sklearn/joblib no disponibles; el mòdul de reflexion no es pot entrenar."
+        )
+        return
+
+    rows = _build_training_rows()
+    if not rows:
+        logger.warning("No s'han pogut generar files d'entrenament per a reflexion.")
+        return
+
+    if max_examples is not None:
+        rows = rows[:max_examples]
+
+    # Desa CSV per transparència
+    with REFLEXION_CSV_PATH.open("w", newline="", encoding="utf-8") as f:
+        writer = csv.writer(f)
+        writer.writerow(["duration", "char_len", "word_len", "label"])
+        for dur, cl, wl, lab in rows:
+            writer.writerow([f"{dur:.3f}", cl, wl, lab])
+
+    X = [[dur, cl, wl] for dur, cl, wl, _ in rows]
+    y = [lab for _, _, _, lab in rows]
+
+    knn = KNeighborsClassifier(n_neighbors=5, weights="distance")
+    knn.fit(X, y)
+
+    joblib.dump(knn, REFLEXION_MODEL_PATH)
+    logger.info(
+        "Model de reflexion entrenat amb %d mostres i desat a %s",
+        len(rows),
+        REFLEXION_MODEL_PATH,
+    )
+
+
+def _load_reflexion_model():
+    if KNeighborsClassifier is None or joblib is None:
+        return None
+    if not REFLEXION_MODEL_PATH.exists():
+        return None
+    try:
+        return joblib.load(REFLEXION_MODEL_PATH)
+    except Exception:  # pragma: no cover
+        logger.warning("No s'ha pogut carregar el model de reflexion de %s", REFLEXION_MODEL_PATH)
+        return None
+
+
+def _get_llm() -> Optional[ChatOpenAI]:
+    api_key = os.environ.get("OPENAI_API_KEY")
+    if not api_key:
+        logger.warning("OPENAI_API_KEY no está configurada; se omite la reflexion.")
+        return None
+    try:
+        return ChatOpenAI(model="gpt-4o-mini", temperature=0.0, api_key=api_key)
+    except Exception as exc:  # pragma: no cover
+        logger.error("No se pudo inicializar ChatOpenAI para reflexion: %s", exc)
+        return None
+
+
+def _apply_knn_to_cues(cues: List[AdCue]) -> List[str]:
+    """Retorna una etiqueta S/E/R/X/C per a cada cue.
+
+    Per simplicitat, les pistes amb durada o longitud zero es marquen com "S" si
+    no hi ha model.
+    """
+
+    model = _load_reflexion_model()
+    if model is None:
+        return ["S" for _ in cues]
+
+    X = [[c.duration, c.char_len, c.word_len] for c in cues]
+    try:
+        probs = model.predict_proba(X)
+        classes = list(model.classes_)
+        labels: List[str] = []
+        for p in probs:
+            idx = int(p.argmax())
+            labels.append(str(classes[idx]))
+        return labels
+    except Exception as exc:  # pragma: no cover
+        logger.error("Error aplicant el model de reflexion: %s", exc)
+        return ["S" for _ in cues]
+
+
+def _ask_llm_for_length_adjustments(cues: List[AdCue], labels: List[str]) -> Dict[int, str]:
+    """Demana al LLM que alargui/curti frases segons E/R.
+
+    Retorna un mapa {index_cue -> nou_text}."""
+
+    llm = _get_llm()
+    if llm is None:
+        return {}
+
+    items: List[Dict[str, str]] = []
+    for idx, (cue, lab) in enumerate(zip(cues, labels)):
+        if lab not in {"E", "R"}:
+            continue
+        items.append({"id": str(idx), "case": lab, "text": cue.text})
+
+    if not items:
+        return {}
+
+    system = SystemMessage(
+        content=(
+            "Ets un assistent que ajusta lleugerament la longitud de frases d'"
+            "audiodescripció en català. \n"
+            "Rebràs una llista d'objectes JSON amb camps 'id', 'case' (E o R) i "
+            "'text'. \n"
+            "Per a cada element has de tornar un nou text que: \n"
+            "- Si 'case' és 'E': sigui una mica més llarg (afegint detalls" \
+            " suaus, sense canviar el sentit).\n"
+            "- Si 'case' és 'R': sigui una mica més curt, més concís, mantenint el" \
+            " sentit principal.\n"
+            "Respon EXCLUSIVAMENT en JSON de la forma:\n"
+            "{\"segments\":[{\"id\":\"...\",\"new_text\":\"...\"}, ...]}"
+        )
+    )
+
+    user = HumanMessage(content=json.dumps({"segments": items}, ensure_ascii=False))
+
+    try:
+        resp = llm.invoke([system, user])
+    except Exception as exc:  # pragma: no cover
+        logger.error("Error llamando al LLM en reflexion (ajustes E/R): %s", exc)
+        return {}
+
+    text = resp.content if isinstance(resp.content, str) else str(resp.content)
+    try:
+        data = json.loads(text)
+    except json.JSONDecodeError:
+        logger.warning("Respuesta del LLM en reflexion no es JSON válido: %s", text[:2000])
+        return {}
+
+    result: Dict[int, str] = {}
+    for seg in data.get("segments", []):
+        try:
+            idx = int(seg.get("id"))
+        except Exception:
+            continue
+        new_text = str(seg.get("new_text", "")).strip()
+        if new_text:
+            result[idx] = new_text
+
+    return result
+
+
+def refine_srt_with_reflexion(srt_content: str) -> str:
+    """Aplica el pas de "reflexion" sobre un SRT.
+
+    - Usa un model KNN entrenat per decidir, per a cada pista d'(AD), si cal
+      mantenir-la, eliminar-la o ajustar-ne la longitud.
+    - Per a casos E/R, demana al LLM una versió lleugerament més llarga/curta.
+    - Si no hi ha model o LLM, retorna el SRT original.
+    """
+
+    cues = _parse_srt_ad_cues(srt_content)
+    if not cues:
+        return srt_content
+
+    labels = _apply_knn_to_cues(cues)
+
+    # Segons els labels decidim què fer amb cada bloc
+    adjustments = _ask_llm_for_length_adjustments(cues, labels)
+
+    # Reconstruïm l'SRT: cal tornar a barrejar les pistes modificades amb les
+    # línies originals (incloses les que no són (AD)). Per simplicitat, només
+    # intervenim sobre blocs que continguin (AD): si es marquen com X, els
+    # eliminem; si E/R, modifiquem el text dins de les línies (AD).
+
+    # Primer mapegem (start,end) dels cues per poder identificar blocs
+    cue_by_interval: Dict[Tuple[float, float], Tuple[int, AdCue]] = {}
+    for idx, cue in enumerate(cues):
+        cue_by_interval[(cue.start, cue.end)] = (idx, cue)
+
+    lines = srt_content.splitlines()
+    i = 0
+    out_lines: List[str] = []
+
+    while i < len(lines):
+        if not lines[i].strip():
+            out_lines.append(lines[i])
+            i += 1
+            continue
+
+        idx_line = lines[i]
+        i += 1
+        if i >= len(lines):
+            out_lines.append(idx_line)
+            break
+
+        time_line = lines[i]
+        i += 1
+        if "-->" not in time_line:
+            # Bloc sense format SRT; el copiem tal qual
+            out_lines.append(idx_line)
+            out_lines.append(time_line)
+            continue
+
+        # Parse interval per veure si hi ha un cue associat
+        try:
+            start_str, end_str = [part.strip() for part in time_line.strip().split("-->")]
+            start = _parse_timestamp(start_str)
+            end = _parse_timestamp(end_str)
+        except Exception:
+            start = end = math.nan
+
+        text_block: List[str] = []
+        while i < len(lines) and lines[i].strip():
+            text_block.append(lines[i])
+            i += 1
+
+        key = (start, end)
+        if key not in cue_by_interval:
+            # Bloc sense (AD) o no identificat -> es copia sense tocar
+            out_lines.append(idx_line)
+            out_lines.append(time_line)
+            out_lines.extend(text_block)
+            if i < len(lines) and not lines[i].strip():
+                out_lines.append(lines[i])
+                i += 1
+            continue
+
+        cue_idx, cue = cue_by_interval[key]
+        label = labels[cue_idx] if cue_idx < len(labels) else "S"
+
+        if label == "X":
+            # Eliminem completament aquest bloc
+            if i < len(lines) and not lines[i].strip():
+                i += 1  # saltar línia buida
+            continue
+
+        # S/C/E/R: mantenim bloc però potser modifiquem el text
+        new_text = adjustments.get(cue_idx)
+        if new_text:
+            # Reescrivim només les línies amb (AD)
+            new_block: List[str] = []
+            replaced = False
+            for tl in text_block:
+                if "(AD)" in tl and not replaced:
+                    prefix, _ = tl.split("(AD)", 1)
+                    new_block.append(prefix + "(AD) " + new_text)
+                    replaced = True
+                else:
+                    new_block.append(tl)
+            text_block = new_block
+
+        out_lines.append(idx_line)
+        out_lines.append(time_line)
+        out_lines.extend(text_block)
+        if i < len(lines) and not lines[i].strip():
+            out_lines.append(lines[i])
+            i += 1
+
+    return "\n".join(out_lines)

refinement/temp/few_shot_examples.txt

@@ -0,0 +1,592 @@
+# sha1sum=150f0d2abfe26602e38dc3cc1a0030d16c8ed0a2
+```json
+{
+  "few_shot_example": {
+    "correccions": [
+      {
+        "exemple": "S'ha afegit 'la visió majestuosa' per enriquir la descripció de la panoràmica.",
+        "original": "Es mostra una panoràmica de Barcelona amb les obres de la Sagrada Família.",
+        "corregit": "Es mostra una panoràmica de Barcelona amb la visió majestuosa de les obres de la Sagrada Família."
+      },
+      {
+        "exemple": "S'ha especificat l'estat d'ànim del personatge Viet per aportar més context.",
+        "original": "Obres",
+        "corregit": "Obres. Viet, amb un entusiasme evident, posa la mirada en el progrés de la construcció."
+      },
+      {
+        "exemple": "S'ha millorat la descripció de la vista d'ocell per fer-la més evocadora.",
+        "original": "Es mostra a vista d´ocell la sagrada família i les seves obres",
+        "corregit": "L'observació de la basílica continua amb una vista d'ocell de la Sagrada Família i les seves obres, posant de manifest la immensitat del projecte."
+      },
+      {
+        "exemple": "S'ha afegit una nova descripció per a la imatge d'obrers.",
+        "original": "No hi havia descripció.",
+        "corregit": "Apareixen dos obrers xerrant i prenent el sol al capdamunt."
+      }
+    ]
+  },
+  "rule": "En les audiodescripcions, és important enriquir el context emocional i visual dels personatges i escenes, així com proporcionar descripcions addicionals per a elements visuals que no estiguin explícitament mencionats en el diàleg."
+}
+```
+
+# sha1sum=150f0d2abfe26602e38dc3cc1a0030d16c8ed0a2
+```json
+{
+  "few_shot_example": {
+    "correccions": [
+      {
+        "exemple": "S'ha afegit 'la visió majestuosa' per enriquir la descripció de la panoràmica.",
+        "original": "Es mostra una panoràmica de Barcelona amb les obres de la Sagrada Família.",
+        "corregit": "Es mostra una panoràmica de Barcelona amb la visió majestuosa de les obres de la Sagrada Família."
+      },
+      {
+        "exemple": "S'ha especificat l'estat d'ànim del personatge Viet per aportar més context.",
+        "original": "Obres",
+        "corregit": "Obres. Viet, amb un entusiasme evident, posa la mirada en el progrés de la construcció."
+      },
+      {
+        "exemple": "S'ha millorat la descripció de la vista d'ocell per fer-la més evocadora.",
+        "original": "Es mostra a vista d´ocell la sagrada família i les seves obres",
+        "corregit": "L'observació de la basílica continua amb una vista d'ocell de la Sagrada Família i les seves obres, posant de manifest la immensitat del projecte."
+      },
+      {
+        "exemple": "S'ha afegit una nova descripció per a la imatge d'obrers.",
+        "original": "No hi havia descripció d'obrers.",
+        "corregit": "Apareixen dos obrers xerrant i prenent el sol al capdamunt."
+      }
+    ]
+  },
+  "rule": "En les audiodescripcions, és important enriquir les descripcions visuals amb detalls que aportin context emocional i visual, així com assegurar-se que cada element visual rellevant estigui descrit adequadament."
+}
+```
+
+# sha1sum=3df04d2b7df70210fcceb7b9d9a35731bb43a39c
+```json
+{
+  "few_shot_example": {
+    "correccions": [
+      {
+        "exemple": "La línia 4 de la versió automàtica incloïa una coma innecessària al final de la frase.",
+        "correccio": "El quadre de la finestra ara emmarca un carrer de tardor, amb arbres amb fulles grogues i taronges."
+      },
+      {
+        "exemple": "La línia 5 de la versió automàtica no separava correctament les frases de Salvador.",
+        "correccio": "La versió corregida divideix el text en diverses línies per a una millor comprensió."
+      }
+    ]
+  },
+  "rule": "Assegura't de revisar la puntuació i la separació de les línies per a una millor llegibilitat i comprensió del text."
+}
+```
+
+# sha1sum=3df04d2b7df70210fcceb7b9d9a35731bb43a39c
+```json
+{
+  "few_shot_example": {
+    "correccions": [
+      {
+        "exemple_auto": "(AD) Es veu una noia a la finestra.",
+        "exemple_hitl": "(AD) La càmera mira a través d'una finestra de fusta, àmplia i oberta, a una dona jove vestida amb un abric clar sobre uns pantalons curts de texà."
+      },
+      {
+        "exemple_auto": "(AD) L'interior de l'habitació es va enfosquint gradualment.",
+        "exemple_hitl": "(AD) La perspectiva canvia a una finestra més petita amb cortines blanques i velades."
+      },
+      {
+        "exemple_auto": "(AD) Una dona jove, amb un abric beix, camina sola sota la llum daurada del sol ponent.",
+        "exemple_hitl": "(AD) El quadre de la finestra ara emmarca un carrer de tardor, amb arbres amb fulles grogues i taronges."
+      }
+    ]
+  },
+  "rule": "Les audiodescripcions han de proporcionar detalls visuals més rics i contextualitzats, incloent descripcions de l'entorn i l'estat d'ànim, en comptes de simples observacions."
+}
+```
+
+# sha1sum=82a86f234c7d37ade1a1c823ba201e6cdf38011d
+```json
+{
+  "few_shot_example": {
+    "correccions": [
+      {
+        "exemple": "La descripció de l'AD es va dividir en dues línies.",
+        "abans": "(AD) Una ampolla de vidre amb un missatge a dins està a la sorra, mentre les ones trenquen sota la llum de la posta de sol.",
+        "després": "(AD) Una ampolla de vidre amb un missatge a dins està a la sorra,\n(AD) mentre les ones trenquen sota la llum de la posta de sol."
+      }
+    ]
+  },
+  "rule": "Les descripcions d'audiodescripció han de ser dividides en línies per millorar la llegibilitat, especialment quan la informació és llarga o complexa."
+}
+```
+
+# sha1sum=82a86f234c7d37ade1a1c823ba201e6cdf38011d
+{'correccions': [{'exemple_auto': '(AD) Una ampolla a la sorra de la platja.', 'exemple_hitl': '(AD) Una ampolla de vidre amb un missatge a dins està a la sorra,', 'descripcio': "S'ha especificat que l'ampolla és de vidre i conté un missatge, millorant la descripció."}, {'exemple_auto': '', 'exemple_hitl': '(AD) mentre les ones trenquen sota la llum de la posta de sol.', 'descripcio': "S'ha afegit una descripció de l'entorn, mencionant les ones i la llum de la posta de sol."}]}
+
+# sha1sum=8ff4b2aaccfeee31ecc59b96e1ae90273de78864
+```json
+{
+  "few_shot_example": {
+    "correccions": [
+      {
+        "exemple_auto": "(AD) Ara caminen per un parc arbrat i assolellat.",
+        "exemple_hitl": "(AD) Canvi d'escena a El Parc. Caminant."
+      },
+      {
+        "exemple_auto": "(AD) Les dues joves són a una cuina moderna. Una jove talla verdures mentre l'altra remena una amanida en un bol.",
+        "exemple_hitl": "(AD) A Una Cuina, tallen verdures per a una amanida."
+      }
+    ]
+  },
+  "rule": "Utilitzar descripcions més concises i clares per a les escenes, evitant detalls innecessaris i centrant-se en l'acció principal."
+}
+```
+
+# sha1sum=8ff4b2aaccfeee31ecc59b96e1ae90273de78864
+```json
+{
+  "few_shot_example": {
+    "correccions": [
+      {
+        "original": "(AD) De sobte, són al parc.",
+        "corregit": "(AD) Canvi d'escena a El Parc. Caminant."
+      },
+      {
+        "original": "(AD) Ara tallen menjar i fan una amanida a una cuina.",
+        "corregit": "(AD) A Una Cuina, tallen verdures per a una amanida."
+      },
+      {
+        "original": "00:00:00,000 --> 0:00:05,340",
+        "corregit": "00:00:00,000 --> 00:00:03,140"
+      }
+    ]
+  },
+  "rule": "Les descripcions d'audiodescripció han de ser més específiques i descriptives, incloent el context de l'escena i les accions que es realitzen, així com assegurar-se que els temps de les línies siguin precisos i coherents."
+}
+```
+
+# sha1sum=99712a83300194a84adf07c11b6db57c9661aca2
+{'correccions': [{'exemple': 'La línia 2 ha estat dividida en dues línies separades per millorar la claredat.', 'abans': '[Mireia Martí] Això no és cert. Les nostres xifres mostren un creixement constant, i vostè ho sap.', 'després': '[Mireia Martí] Això no és cert.\n[Mireia Martí] Les nostres xifres mostren un creixement constant, i vostè ho sap.'}]}
+
+# sha1sum=99712a83300194a84adf07c11b6db57c9661aca2
+{'correccions': [{'exemple': 'La línia 2 ha estat dividida en dues línies per millorar la claredat.', 'abans': '[Mireia Martí] Això no és cert. Les nostres xifres mostren un creixement constant, i vostè ho sap.', 'després': '[Mireia Martí] Això no és cert.\n[Mireia Martí] Les nostres xifres mostren un creixement constant, i vostè ho sap.'}, {'exemple': 'La línia 4 ha estat corregida per mantenir la coherència en la numeració.', 'abans': "(AD) Ara es posen a jugar a tennis l'un contra l'altre.", 'després': "(AD) Els polítics de sobte es posen a jugar a tennis l'un contra l'altre."}, {'exemple': 'La línia 6 ha estat corregida per ajustar el format de temps.', 'abans': '00:00:16,740 --> 0:00:24,030', 'després': '00:00:16,740 --> 00:00:24,030'}]}
+
+# sha1sum=9a1cfbe8c743d3148534b8f635d84d55342dfc4b
+```json
+{
+  "few_shot_example": {
+    "correccions": [
+      {
+        "original": "[Jordi] Sé quina cançó hem de triar. Una rumba.",
+        "corregit": "[Jordi] Sé quina cançó hem de triar.\n[Jordi] Una rumba."
+      },
+      {
+        "original": "9\n00:00:30,940 --> 00:00:33,000\n(AD) Continuen gaudint de la festa.",
+        "corregit": "11\n00:00:30,940 --> 00:00:33,000\n(AD) Continuen gaudint de la festa."
+      }
+    ]
+  },
+  "rule": "Separar les frases de diàlegs en línies diferents per a una millor comprensió i numerar les línies de manera consecutiva sense saltar números."
+}
+```
+
+# sha1sum=9a1cfbe8c743d3148534b8f635d84d55342dfc4b
+```json
+{
+  "few_shot_example": {
+    "correccions": [
+      {
+        "original": "[Jordi] Sé quina cançó hem de triar. Una rumba.",
+        "corregit": "[Jordi] Sé quina cançó hem de triar.\n[Jordi] Una rumba."
+      },
+      {
+        "original": "9\n00:00:30,940 --> 00:00:33,000\n(AD) Continuen gaudint de la festa.",
+        "corregit": "11\n00:00:30,940 --> 00:00:33,000\n(AD) Continuen gaudint de la festa."
+      }
+    ]
+  },
+  "rule": "Assegura't que cada línia de diàleg estigui separada en subtítols diferents i que la numeració dels subtítols sigui consecutiva i correcta."
+}
+```
+
+# sha1sum=150f0d2abfe26602e38dc3cc1a0030d16c8ed0a2
+{
+  "correccions": [
+    {
+      "exemple": "S'ha afegit 'la visió majestuosa' per enriquir la descripció de les obres de la Sagrada Família.",
+      "original": "Es mostra una panoràmica de Barcelona amb les obres de la Sagrada Família.",
+      "corregit": "Es mostra una panoràmica de Barcelona amb la visió majestuosa de les obres de la Sagrada Família."
+    },
+    {
+      "exemple": "S'ha especificat l'estat d'ànim del personatge Viet, afegint 'amb un entusiasme evident'.",
+      "original": "Obres",
+      "corregit": "Obres. Viet, amb un entusiasme evident, posa la mirada en el progrés de la construcció."
+    },
+    {
+      "exemple": "S'ha millorat la descripció de la vista d'ocell, afegint 'posant de manifest la immensitat del projecte'.",
+      "original": "Es mostra a vista d´ocell la sagrada família i les seves obres",
+      "corregit": "L'observació de la basílica continua amb una vista d'ocell de la Sagrada Família i les seves obres, posant de manifest la immensitat del projecte."
+    },
+    {
+      "exemple": "S'ha afegit una nova descripció per a la imatge d'obrers, que abans no estava present.",
+      "original": "No hi havia descripció.",
+      "corregit": "Apareixen dos obrers xerrant i prenent el sol al capdamunt."
+    }
+  ]
+}
+
+# sha1sum=150f0d2abfe26602e38dc3cc1a0030d16c8ed0a2
+{
+  "correccions": [
+    {
+      "exemple": "S'ha afegit 'la visió majestuosa' per enriquir la descripció de la panoràmica.",
+      "original": "Es mostra una panoràmica de Barcelona amb les obres de la Sagrada Família.",
+      "corregit": "Es mostra una panoràmica de Barcelona amb la visió majestuosa de les obres de la Sagrada Família."
+    },
+    {
+      "exemple": "S'ha especificat l'estat d'ànim del personatge Viet per aportar més context.",
+      "original": "Obres",
+      "corregit": "Obres. Viet, amb un entusiasme evident, posa la mirada en el progrés de la construcció."
+    },
+    {
+      "exemple": "S'ha millorat la descripció de la vista d'ocell per fer-la més evocadora.",
+      "original": "Es mostra a vista d´ocell la sagrada família i les seves obres",
+      "corregit": "L'observació de la basílica continua amb una vista d'ocell de la Sagrada Família i les seves obres, posant de manifest la immensitat del projecte."
+    },
+    {
+      "exemple": "S'ha afegit una nova descripció per a la imatge d'obrers.",
+      "original": "No hi havia descripció.",
+      "corregit": "Apareixen dos obrers xerrant i prenent el sol al capdamunt."
+    }
+  ]
+}
+
+# sha1sum=3df04d2b7df70210fcceb7b9d9a35731bb43a39c
+{
+  "correccions": [
+    {
+      "exemple": "La línia 4 de la versió automàtica incloïa una coma innecessària al final: 'amb arbres amb fulles grogues i taronges,'. La versió corregida elimina aquesta coma.",
+      "descripcio": "Correcció de puntuació."
+    },
+    {
+      "exemple": "La línia 5 de la versió automàtica no separava correctament les frases, resultant en una sola línia llarga. La versió corregida divideix el text en diverses línies per a una millor llegibilitat.",
+      "descripcio": "Millora en la separació de diàlegs."
+    }
+  ]
+}
+
+# sha1sum=3df04d2b7df70210fcceb7b9d9a35731bb43a39c
+{
+  "correccions": [
+    {
+      "exemple_auto": "(AD) Es veu una noia a la finestra.",
+      "exemple_hitl": "(AD) La càmera mira a través d'una finestra de fusta, àmplia i oberta, a una dona jove vestida amb un abric clar sobre uns pantalons curts de texà."
+    },
+    {
+      "exemple_auto": "(AD) L'interior de l'habitació es va enfosquint gradualment.",
+      "exemple_hitl": "(AD) La perspectiva canvia a una finestra més petita amb cortines blanques i velades."
+    },
+    {
+      "exemple_auto": "(AD) Una dona jove, amb un abric beix, camina sola sota la llum daurada del sol ponent.",
+      "exemple_hitl": "(AD) El quadre de la finestra ara emmarca un carrer de tardor, amb arbres amb fulles grogues i taronges."
+    }
+  ]
+}
+
+# sha1sum=82a86f234c7d37ade1a1c823ba201e6cdf38011d
+{
+  "correccions": [
+    {
+      "original": "(AD) Una ampolla de vidre amb un missatge a dins està a la sorra, mentre les ones trenquen sota la llum de la posta de sol.",
+      "corregit": "7\n00:00:12,340 --> 00:00:19,340\n(AD) Una ampolla de vidre amb un missatge a dins està a la sorra,\n\n8\n00:00:19,340 --> 00:00:23,940\n(AD) mentre les ones trenquen sota la llum de la posta de sol."
+    }
+  ]
+}
+
+# sha1sum=82a86f234c7d37ade1a1c823ba201e6cdf38011d
+{
+  "correccions": [
+    {
+      "exemple_auto": "(AD) Una ampolla a la sorra de la platja.",
+      "exemple_hitl": "(AD) Una ampolla de vidre amb un missatge a dins està a la sorra,"
+    },
+    {
+      "exemple_auto": "",
+      "exemple_hitl": "(AD) mentre les ones trenquen sota la llum de la posta de sol."
+    }
+  ]
+}
+
+# sha1sum=8ff4b2aaccfeee31ecc59b96e1ae90273de78864
+{
+  "correccions": [
+    {
+      "exemple_auto": "(AD) Ara caminen per un parc arbrat i assolellat.",
+      "exemple_hitl": "(AD) Canvi d'escena a El Parc. Caminant."
+    },
+    {
+      "exemple_auto": "(AD) Les dues joves són a una cuina moderna. Una jove talla verdures mentre l'altra remena una amanida en un bol.",
+      "exemple_hitl": "(AD) A Una Cuina, tallen verdures per a una amanida."
+    }
+  ]
+}
+
+# sha1sum=8ff4b2aaccfeee31ecc59b96e1ae90273de78864
+{
+  "correccions": [
+    {
+      "original": "(AD) De sobte, són al parc.",
+      "corregit": "(AD) Canvi d'escena a El Parc. Caminant."
+    },
+    {
+      "original": "(AD) Ara tallen menjar i fan una amanida a una cuina.",
+      "corregit": "(AD) A Una Cuina, tallen verdures per a una amanida."
+    }
+  ]
+}
+
+# sha1sum=99712a83300194a84adf07c11b6db57c9661aca2
+{
+  "correccions": [
+    {
+      "exemple": "La línia 2 ha estat dividida en dues línies separades per millorar la claredat.",
+      "abans": "[Mireia Martí] Això no és cert. Les nostres xifres mostren un creixement constant, i vostè ho sap.",
+      "després": "[Mireia Martí] Això no és cert.\n[Mireia Martí] Les nostres xifres mostren un creixement constant, i vostè ho sap."
+    }
+  ]
+}
+
+# sha1sum=99712a83300194a84adf07c11b6db57c9661aca2
+{
+  "correccions": [
+    {
+      "exemple": "La línia 2 de la versió automàtica conté un diàleg incomplet: \"Això no és cert. Les nostres xifres mostren un creixement constant, i vostè ho sap.\" s'ha dividit en dues línies a la versió corregida.",
+      "canvi": "S'ha afegit una nova línia per separar el diàleg de Mireia Martí."
+    },
+    {
+      "exemple": "La línia 4 de la versió automàtica conté un error de numeració i s'ha corregit a la línia 5 de la versió corregida.",
+      "canvi": "S'ha ajustat la numeració de les línies per mantenir la coherència."
+    }
+  ]
+}
+
+# sha1sum=9a1cfbe8c743d3148534b8f635d84d55342dfc4b
+{
+  "correccions": [
+    {
+      "original": "[Jordi] Sé quina cançó hem de triar. Una rumba.",
+      "corregit": "[Jordi] Sé quina cançó hem de triar.\n[Jordi] Una rumba."
+    },
+    {
+      "original": "9\n00:00:30,940 --> 00:00:33,000\n(AD) Continuen gaudint de la festa.",
+      "corregit": "11\n00:00:30,940 --> 00:00:33,000\n(AD) Continuen gaudint de la festa."
+    }
+  ]
+}
+
+# sha1sum=9a1cfbe8c743d3148534b8f635d84d55342dfc4b
+{
+  "correccions": [
+    {
+      "original": "[Jordi] Sé quina cançó hem de triar. Una rumba.",
+      "corregit": "[Jordi] Sé quina cançó hem de triar.\n[Jordi] Una rumba."
+    },
+    {
+      "original": "9\n00:00:30,940 --> 00:00:33,000\n(AD) Continuen gaudint de la festa.",
+      "corregit": "11\n00:00:30,940 --> 00:00:33,000\n(AD) Continuen gaudint de la festa."
+    }
+  ]
+}
+
+# sha1sum=150f0d2abfe26602e38dc3cc1a0030d16c8ed0a2
+{
+  "correccions": [
+    {
+      "exemple": "S'ha afegit 'la visió majestuosa' per enriquir la descripció de la panoràmica.",
+      "original": "Es mostra una panoràmica de Barcelona amb les obres de la Sagrada Família.",
+      "corregit": "Es mostra una panoràmica de Barcelona amb la visió majestuosa de les obres de la Sagrada Família."
+    },
+    {
+      "exemple": "S'ha especificat l'estat d'ànim del personatge Viet, afegint 'amb un entusiasme evident'.",
+      "original": "Obres",
+      "corregit": "Obres. Viet, amb un entusiasme evident, posa la mirada en el progrés de la construcció."
+    },
+    {
+      "exemple": "S'ha millorat la descripció de la vista d'ocell, afegint 'posant de manifest la immensitat del projecte'.",
+      "original": "Es mostra a vista d´ocell la sagrada família i les seves obres",
+      "corregit": "L'observació de la basílica continua amb una vista d'ocell de la Sagrada Família i les seves obres, posant de manifest la immensitat del projecte."
+    },
+    {
+      "exemple": "S'ha afegit una nova descripció per a la imatge d'obrers, que abans no estava present.",
+      "original": "",
+      "corregit": "Apareixen dos obrers xerrant i prenent el sol al capdamunt."
+    }
+  ]
+}
+
+# sha1sum=150f0d2abfe26602e38dc3cc1a0030d16c8ed0a2
+{
+  "correccions": [
+    {
+      "exemple": "S'ha afegit 'la visió majestuosa' per enriquir la descripció de la panoràmica.",
+      "original": "Es mostra una panoràmica de Barcelona amb les obres de la Sagrada Família.",
+      "corregit": "Es mostra una panoràmica de Barcelona amb la visió majestuosa de les obres de la Sagrada Família."
+    },
+    {
+      "exemple": "S'ha especificat l'estat d'ànim del personatge Viet per aportar més context.",
+      "original": "Obres",
+      "corregit": "Obres. Viet, amb un entusiasme evident, posa la mirada en el progrés de la construcció."
+    },
+    {
+      "exemple": "S'ha millorat la descripció de la vista d'ocell per fer-la més evocadora.",
+      "original": "Es mostra a vista d´ocell la sagrada família i les seves obres",
+      "corregit": "L'observació de la basílica continua amb una vista d'ocell de la Sagrada Família i les seves obres, posant de manifest la immensitat del projecte."
+    },
+    {
+      "exemple": "S'ha afegit una nova descripció per a la imatge d'obrers.",
+      "original": "No hi havia descripció.",
+      "corregit": "Apareixen dos obrers xerrant i prenent el sol al capdamunt."
+    }
+  ]
+}
+
+# sha1sum=3df04d2b7df70210fcceb7b9d9a35731bb43a39c
+{
+  "correccions": [
+    {
+      "exemple": "La línia 4 de la versió automàtica incloïa una coma innecessària al final de la frase.",
+      "correcció": "El quadre de la finestra ara emmarca un carrer de tardor, amb arbres amb fulles grogues i taronges."
+    },
+    {
+      "exemple": "La línia 5 de la versió automàtica no separava correctament les frases de Salvador.",
+      "correcció": "La versió corregida divideix el text en diverses línies per a una millor comprensió."
+    }
+  ]
+}
+
+# sha1sum=3df04d2b7df70210fcceb7b9d9a35731bb43a39c
+{
+  "correccions": [
+    {
+      "exemple_auto": "(AD) Es veu una noia a la finestra.",
+      "exemple_hitl": "(AD) La càmera mira a través d'una finestra de fusta, àmplia i oberta, a una dona jove vestida amb un abric clar sobre uns pantalons curts de texà."
+    },
+    {
+      "exemple_auto": "(AD) L'interior de l'habitació es va enfosquint gradualment.",
+      "exemple_hitl": "(AD) La perspectiva canvia a una finestra més petita amb cortines blanques i velades."
+    },
+    {
+      "exemple_auto": "(AD) Una dona jove, amb un abric beix, camina sola sota la llum daurada del sol ponent.",
+      "exemple_hitl": "(AD) El quadre de la finestra ara emmarca un carrer de tardor, amb arbres amb fulles grogues i taronges."
+    }
+  ]
+}
+
+# sha1sum=82a86f234c7d37ade1a1c823ba201e6cdf38011d
+{
+  "correccions": [
+    {
+      "exemple": "La descripció de l'AD es va dividir en dues línies.",
+      "abans": "(AD) Una ampolla de vidre amb un missatge a dins està a la sorra, mentre les ones trenquen sota la llum de la posta de sol.",
+      "després": "(AD) Una ampolla de vidre amb un missatge a dins està a la sorra,\n(AD) mentre les ones trenquen sota la llum de la posta de sol."
+    }
+  ]
+}
+
+# sha1sum=82a86f234c7d37ade1a1c823ba201e6cdf38011d
+{
+  "correccions": [
+    {
+      "exemple": "SRT 7: (AD) Una ampolla a la sorra de la platja.",
+      "correcció": "(AD) Una ampolla de vidre amb un missatge a dins està a la sorra,"
+    },
+    {
+      "exemple": "SRT 8: (AD) [no existia en la versió automàtica]",
+      "correcció": "(AD) mentre les ones trenquen sota la llum de la posta de sol."
+    }
+  ]
+}
+
+# sha1sum=8ff4b2aaccfeee31ecc59b96e1ae90273de78864
+{
+  "correccions": [
+    {
+      "exemple_auto": "(AD) Ara caminen per un parc arbrat i assolellat.",
+      "exemple_hitl": "(AD) Canvi d'escena a El Parc. Caminant."
+    },
+    {
+      "exemple_auto": "(AD) Les dues joves són a una cuina moderna. Una jove talla verdures mentre l'altra remena una amanida en un bol.",
+      "exemple_hitl": "(AD) A Una Cuina, tallen verdures per a una amanida."
+    }
+  ]
+}
+
+# sha1sum=8ff4b2aaccfeee31ecc59b96e1ae90273de78864
+{
+  "correccions": [
+    {
+      "original": "(AD) De sobte, són al parc.",
+      "corregit": "(AD) Canvi d'escena a El Parc. Caminant."
+    },
+    {
+      "original": "(AD) Ara tallen menjar i fan una amanida a una cuina.",
+      "corregit": "(AD) A Una Cuina, tallen verdures per a una amanida."
+    }
+  ]
+}
+
+# sha1sum=99712a83300194a84adf07c11b6db57c9661aca2
+{
+  "correccions": [
+    {
+      "exemple": "La línia 2 ha estat dividida en dues línies separades per millorar la claredat.",
+      "abans": "[Mireia Martí] Això no és cert. Les nostres xifres mostren un creixement constant, i vostè ho sap.",
+      "després": "[Mireia Martí] Això no és cert.\n[Mireia Martí] Les nostres xifres mostren un creixement constant, i vostè ho sap."
+    }
+  ]
+}
+
+# sha1sum=99712a83300194a84adf07c11b6db57c9661aca2
+{
+  "correccions": [
+    {
+      "original": "[Mireia Martí] Això no és cert. Les nostres xifres mostren un creixement constant, i vostè ho sap.",
+      "corregit": "[Mireia Martí] Això no és cert.\n[Mireia Martí] Les nostres xifres mostren un creixement constant, i vostè ho sap."
+    },
+    {
+      "original": "4\n0:00:12,840 --> 0:00:16,740\n(AD) Ara es posen a jugar a escacs.",
+      "corregit": "5\n0:00:12,840 --> 0:00:16,740\n(AD) Ara es posen a jugar a escacs."
+    },
+    {
+      "original": "5\n0:00:16,740 --> 0:00:24,030\n(AD) Ara comencen un duel de sabres làser.",
+      "corregit": "6\n0:00:16,740 --> 00:00:24,030\n(AD) Ara comencen un duel de sabres làser."
+    }
+  ]
+}
+
+# sha1sum=9a1cfbe8c743d3148534b8f635d84d55342dfc4b
+{
+  "correccions": [
+    {
+      "original": "Sé quina cançó hem de triar. Una rumba.",
+      "corregit": "Sé quina cançó hem de triar.\nUna rumba."
+    },
+    {
+      "original": "9\n00:00:30,940 --> 00:00:33,000\n(AD) Continuen gaudint de la festa.",
+      "corregit": "11\n00:00:30,940 --> 00:00:33,000\n(AD) Continuen gaudint de la festa."
+    }
+  ]
+}
+
+# sha1sum=9a1cfbe8c743d3148534b8f635d84d55342dfc4b
+{
+  "correccions": [
+    {
+      "original": "Sé quina cançó hem de triar. Una rumba.",
+      "corregit": "Sé quina cançó hem de triar.\nUna rumba."
+    },
+    {
+      "original": "9\n00:00:30,940 --> 00:00:33,000\n(AD) Continuen gaudint de la festa.",
+      "corregit": "11\n00:00:30,940 --> 00:00:33,000\n(AD) Continuen gaudint de la festa."
+    }
+  ]
+}
+

refinement/temp/reflection.log

@@ -0,0 +1,167 @@
+INFO: Ficheros iniciales 'une_ad_0.srt' y 'json_ad.json' creados.
+INFO: --- Comenzando el Bucle de Reflexión ---
+INFO: Narrador: Generada la versión 0 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_0.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 40.0%.
+INFO: CONTINUAR: Iteración 1 / 3. Fiabilidad actual: 40.0%.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Narrador: Generada la versión 1 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_1.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 40.0%.
+INFO: CONTINUAR: Iteración 2 / 3. Fiabilidad actual: 40.0%.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Narrador: Generada la versión 2 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_2.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 50.0%.
+INFO: FIN: Se alcanzó el máximo de iteraciones (3 / 3).
+INFO: 
+--- Bucle Finalizado ---
+INFO: Ficheros iniciales 'une_ad_0.srt' y 'json_ad.json' creados.
+INFO: --- Comenzando el Bucle de Reflexión ---
+INFO: Narrador: Generada la versión 0 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_0.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 60.0%.
+INFO: CONTINUAR: Iteración 1 / 3. Fiabilidad actual: 60.0%.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Narrador: Generada la versión 1 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_1.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 40.0%.
+INFO: CONTINUAR: Iteración 2 / 3. Fiabilidad actual: 40.0%.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Narrador: Generada la versión 2 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_2.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 40.0%.
+INFO: FIN: Se alcanzó el máximo de iteraciones (3 / 3).
+INFO: 
+--- Bucle Finalizado ---
+INFO: Ficheros iniciales 'une_ad_0.srt' y 'json_ad.json' creados.
+INFO: --- Comenzando el Bucle de Reflexión ---
+INFO: Narrador: Generada la versión 0 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_0.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 60.0%.
+INFO: CONTINUAR: Iteración 1 / 3. Fiabilidad actual: 60.0%.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Narrador: Generada la versión 1 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_1.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 50.0%.
+INFO: CONTINUAR: Iteración 2 / 3. Fiabilidad actual: 50.0%.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Narrador: Generada la versión 2 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_2.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 50.0%.
+INFO: FIN: Se alcanzó el máximo de iteraciones (3 / 3).
+INFO: 
+--- Bucle Finalizado ---
+INFO: Ficheros iniciales 'une_ad_0.srt' y 'json_ad.json' creados.
+INFO: --- Comenzando el Bucle de Reflexión ---
+INFO: Narrador: Generada la versión 0 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_0.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 60.0%.
+INFO: CONTINUAR: Iteración 1 / 3. Fiabilidad actual: 60.0%.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Narrador: Generada la versión 1 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_1.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 50.0%.
+INFO: CONTINUAR: Iteración 2 / 3. Fiabilidad actual: 50.0%.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Narrador: Generada la versión 2 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_2.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 40.0%.
+INFO: FIN: Se alcanzó el máximo de iteraciones (3 / 3).
+INFO: 
+--- Bucle Finalizado ---
+INFO: Ficheros iniciales 'une_ad_0.srt' y 'json_ad.json' creados.
+INFO: --- Comenzando el Bucle de Reflexión ---
+INFO: Narrador: Generada la versión 0 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_0.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 60.0%.
+INFO: CONTINUAR: Iteración 1 / 3. Fiabilidad actual: 60.0%.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Narrador: Generada la versión 1 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_1.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 50.0%.
+INFO: CONTINUAR: Iteración 2 / 3. Fiabilidad actual: 50.0%.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Narrador: Generada la versión 2 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_2.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 60.0%.
+INFO: FIN: Se alcanzó el máximo de iteraciones (3 / 3).
+INFO: 
+--- Bucle Finalizado ---
+INFO: Ficheros iniciales 'une_ad_0.srt' y 'json_ad.json' creados.
+INFO: --- Comenzando el Bucle de Reflexión ---
+INFO: Narrador: Generada la versión 0 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_0.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 50.0%.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: CONTINUAR: Iteració 1 / 5. Mitjana actual: 5.33 / 7.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Narrador: Generada la versión 1 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_1.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 50.0%.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: CONTINUAR: Iteració 2 / 5. Mitjana actual: 5.17 / 7.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Narrador: Generada la versión 2 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_2.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 60.0%.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: CONTINUAR: Iteració 3 / 5. Mitjana actual: 5.83 / 7.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Narrador: Generada la versión 3 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_3.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 40.0%.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: CONTINUAR: Iteració 4 / 5. Mitjana actual: 5.33 / 7.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Narrador: Generada la versión 4 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_4.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 60.0%.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: FIN: Mitjana d'avaluació assolida (6.00 >= 6.0).
+INFO: 
+--- Bucle Finalizado ---
+INFO: Ficheros iniciales 'une_ad_0.srt' y 'json_ad.json' creados.
+INFO: --- Comenzando el Bucle de Reflexión ---
+INFO: Narrador: Generada la versión 0 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_0.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 60.0%.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: CONTINUAR: Iteració 1 / 5. Mitjana ponderada actual: 4.78 / 7.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Narrador: Generada la versión 1 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_1.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 40.0%.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: CONTINUAR: Iteració 2 / 5. Mitjana ponderada actual: 5.00 / 7.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Narrador: Generada la versión 2 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_2.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 60.0%.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: CONTINUAR: Iteració 3 / 5. Mitjana ponderada actual: 5.56 / 7.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Narrador: Generada la versión 3 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_3.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 60.0%.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: CONTINUAR: Iteració 4 / 5. Mitjana ponderada actual: 5.67 / 7.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Narrador: Generada la versión 4 del SRT en 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad_4.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 40.0%.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: FIN: S'ha assolit el màxim d'iteracions (5 / 5).
+INFO: 
+--- Bucle Finalizado ---
+INFO: SRT final copiado a 'C:\dev\veureu\hf_spaces\engine\reflection\temp\une_ad.srt'.
+INFO: Evaluación final copiada a 'C:\dev\veureu\hf_spaces\engine\reflection\temp\eval.csv'.
+INFO: Ficheros iniciales 'une_ad_0.srt' y 'json_ad.json' creados.
+INFO: --- Començant el bucle de reflexió (run_reflection_pipeline) ---
+INFO: Narrador: Generada la versión 0 del SRT en 'C:\dev\veureu\hf_spaces\engine\refinement\temp\une_ad_0.srt'.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: Crítico: Evaluación completada. Fiabilidad: 60.0%.
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: FIN: Mitjana ponderada d'avaluació assolida (6.44 >= 6.0).
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
+INFO: HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"

refinement/temp/reflexion.csv

@@ -0,0 +1,40 @@
+duration,char_len,word_len,label
+4.310,74,13,E
+3.000,5,1,E
+10.500,62,12,E
+4.310,74,13,E
+3.000,5,1,E
+10.500,62,12,E
+5.000,142,27,S
+3.700,80,13,S
+2.700,29,6,S
+2.920,100,18,S
+4.000,30,7,E
+4.700,55,7,E
+2.700,29,6,S
+2.920,82,16,E
+11.600,118,25,R
+11.600,36,8,E
+2.750,44,8,R
+4.100,108,20,R
+4.200,56,10,X
+4.050,67,11,X
+3.900,38,6,X
+3.150,64,13,X
+3.000,6,1,X
+2.000,22,5,E
+4.000,48,10,S
+4.000,30,5,X
+5.000,36,7,X
+7.000,55,9,X
+3.940,20,3,X
+5.500,68,13,S
+3.900,30,7,S
+7.290,37,7,S
+3.900,30,7,S
+7.290,37,7,S
+5.500,0,0,C
+6.900,67,10,S
+2.060,30,5,S
+6.900,67,10,S
+2.060,30,5,S

refinement/temp/rules.txt

@@ -0,0 +1,23 @@
+Les audiodescripcions han de ser detallades i proporcionar informació contextual rellevant per millorar la comprensió de l'escena.
+Dividir les oracions llargues en línies més curtes per millorar la comprensibilitat i la fluïdesa de l'audiodescripció.
+Assegurar-se que les línies de diàleg es divideixin adequadament per a una millor comprensió i mantenir la coherència en la numeració i el format de temps.
+En les audiodescripcions, és important enriquir les descripcions visuals amb detalls que reflecteixin l'estat d'ànim dels personatges i la magnitud dels escenaris, així com assegurar-se que cada imatge o escena tingui una descripció clara i completa.
+En les audiodescripcions, és important enriquir les descripcions visuals amb detalls que aportin context emocional i visual, així com assegurar-se que cada escena o imatge rellevant estigui descrita adequadament.
+Assegura't de revisar la puntuació i la separació de diàlegs per millorar la llegibilitat i la coherència de l'audiodescripció.
+Les audiodescripcions han de proporcionar detalls visuals més rics i contextualitzats, incloent elements com l'entorn, la vestimenta i l'estat d'ànim dels personatges, per millorar la comprensió de l'escena.
+Separar les descripcions d'audiodescripció en línies diferents per a una millor llegibilitat i sincronització amb el vídeo.
+Les audiodescripcions han de ser més detallades i descriptives, incloent informació rellevant sobre els objectes i l'entorn per millorar la comprensió de l'escena.
+Utilitzar descripcions més concises i clares per a les escenes, evitant detalls innecessaris i centrant-se en l'acció principal.
+Millorar la descripció de les escenes per fer-les més clares i informatives, especificant el context i les accions de manera precisa.
+En les audiodescripcions, assegureu-vos de dividir els diàlegs llargs en línies separades per facilitar la comprensió i mantenir la numeració correcta de les línies.
+Separar les línies de diàleg en frases completes i assegurar-se que els números de seqüència són consecutius i correctes.
+Separar les línies de diàleg quan un personatge parla més d'una vegada consecutivament, i assegurar-se que els números de seqüència són consecutius i correctes.
+En les audiodescripcions, és important enriquir les descripcions visuals amb detalls que reflecteixin l'estat d'ànim dels personatges i la grandiositat dels escenaris, així com assegurar-se que cada imatge o escena tingui una descripció clara i completa.
+Assegura't de revisar la puntuació i la separació de les línies per a una millor claredat i comprensió en les audiodescripcions.
+Les audiodescripcions han de proporcionar detalls visuals més rics i contextualitzats, incloent descripcions de l'entorn i l'estat d'ànim, en comptes de simples observacions.
+Les descripcions d'audiodescripció (AD) han de ser dividides en línies separades per millorar la llegibilitat i la comprensió.
+Les audiodescripcions han de ser més descriptives i proporcionar informació addicional sobre els objectes i l'entorn, incloent detalls visuals i context que no es poden deduir només del diàleg.
+Utilitzar un llenguatge més concís i directe en les audiodescripcions, evitant detalls innecessaris i centrant-se en l'acció principal.
+Millorar la descripció de les escenes per ser més específica i clara, incloent detalls sobre l'escenari i l'acció que es realitza.
+Separar les intervencions de diferents personatges en línies separades per millorar la claredat i la comprensibilitat de l'audiodescripció.
+Separar les frases en línies diferents per a una millor llegibilitat i assegurar-se que els números de seqüència són consecutius i correctes.