siesa-agents 2.1.72-qa.2 → 2.1.72-qa.21

package/siesa-agents/scripts/bmad_to_agiletest.py

@@ -1,22 +1,31 @@
 """
-bmad_to_agiletest.py — Parser + Cargador de artefactos BMAD V6.0 → AgileTest/Jira
+bmad_to_agiletest.py — Parser + Cargador de artefactos BMAD V7.8 → AgileTest/Jira
 
-Lee un archivo bmad-v6-*-test-design.md (documento unificado BMAD V6.0) y extrae:
-  - Stories desde Seccion I (Gatekeeper)
-  - FACs Gherkin desde Seccion II (Features & FAC)
-  - Test Cases desde Seccion IV (Matriz 360°)
-  - Traceability desde Apendice
-Luego puede crear todo en Jira/AgileTest via API REST.
+Lee el `test-design.yml` (fuente única de verdad, BMAD V7.8) con yaml.safe_load y extrae:
+  - Stories      desde `gatekeeper[]`
+  - FACs Gherkin desde `features[].fac[]`
+  - Test Cases   desde `test_matrix[]`  (con `steps[]` atómicos: paso/accion/resultado/datos)
+  - Traceability desde `traceability[]`
+Luego puede crear todo en Jira/AgileTest via API REST. Cada `step` lleva su `data` (datos por
+paso del YAML), de modo que los Test Steps en AgileTest quedan con su testData real.
 
 Uso:
     python bmad_to_agiletest.py --dry-run                              # Parsea y muestra resumen
     python bmad_to_agiletest.py --dry-run --detail                     # Muestra cada TC con steps
     python bmad_to_agiletest.py --dry-run --export                     # Exporta a JSON
-    python bmad_to_agiletest.py --input mi-archivo.md --dry-run        # Archivo custom
+    python bmad_to_agiletest.py --input test-design.yml --dry-run      # Archivo custom (.yml)
     python bmad_to_agiletest.py --create                               # Crea en Jira/AgileTest
 
+Requiere: PyYAML (`pip install pyyaml`).
+
+Codificación: toda la E/S de archivos (YAML in, JSON/state out) es UTF-8.
+Salida: el progreso y los resúmenes van a stdout; para consumo por máquina usa
+        `--export` (escribe bmad_parsed_data.json) en vez de parsear stdout.
+Exit codes: 0 = OK · 1 = error genérico/credenciales faltantes · 2 = entrada inválida
+            (archivo no encontrado / YAML mal formado) · 3 = error de state-dir.
+
 Autor: Juan Manuel Reina Montoya — Lider QA, SIESA
-Fecha: 29 marzo 2026 | Actualizado: 09 abril 2026 (soporte BMAD V6.0)
+Fecha: 29 marzo 2026 | Actualizado: 11 junio 2026 (V7.8 — lectura YAML vía yaml.safe_load)
 """
 
 import re
@@ -53,8 +62,8 @@ def _http_with_retry(fn, max_retries=4, base_delay=1.5):
 # ============================================================
 
 CONFIG = {
-    # Archivo BMAD V6.0 (ruta relativa al script)
-    'input_file': 'bmad-v6-segment-test-design.md',
+    # Archivo BMAD V7.8 — test-design.yml (ruta relativa al script)
+    'input_file': 'test-design.yml',
 
     # Jira
     'jira_base_url': 'https://siesa-team.atlassian.net',
@@ -82,8 +91,15 @@ CONFIG = {
         'P2': 'Media',
         'P3': 'Baja',
     },
+
+    # Campos Jira obligatorios adicionales por proyecto (vacío = ninguno).
+    # Se llena desde config.yaml -> agiletest.extra_fields (ej. CON: timetracking).
+    'extra_fields': {},
 }
 
+# Diagnóstico detallado (--verbose)
+VERBOSE = False
+
 # Normalizacion de niveles de test
 LEVEL_NORMALIZE = {
     'BE-Integration': 'Integration (TI)',
@@ -134,93 +150,104 @@ class TestCase:
     steps: list = field(default_factory=list)
 
 # ============================================================
-# Parser: Metadata del documento
+# Loader: test-design.yml (BMAD V7.8) via yaml.safe_load
 # ============================================================
 
-def parse_metadata(content: str) -> dict:
-    """Extrae metadata del header del documento BMAD V6.0."""
-    meta = {'feature': '', 'feature_code': '', 'date': '', 'author': ''}
-
-    m = re.search(r'\*\*M[oó]dulo/Feature:\*\*\s*(.+)', content)
-    if m:
-        meta['feature'] = m.group(1).strip()
+def load_design(yaml_path: str) -> dict:
+    """Carga el test-design.yml (V7.8) como dict. Requiere PyYAML."""
+    try:
+        import yaml
+    except ImportError:
+        print('  ERROR: falta PyYAML. Instala con: pip install -r requirements.txt  (o: pip install pyyaml)')
+        sys.exit(1)
+    with open(yaml_path, 'r', encoding='utf-8') as f:
+        data = yaml.safe_load(f)
+    if not isinstance(data, dict):
+        raise ValueError('test-design.yml no tiene un mapeo (dict) en la raiz — revisa el YAML')
+    return data
 
-    m = re.search(r'\*\*Feature Code:\*\*\s*(.+)', content)
-    if m:
-        meta['feature_code'] = m.group(1).strip()
 
-    m = re.search(r'\*\*Fecha del Dise[nñ]o:\*\*\s*(.+)', content)
-    if not m:
-        m = re.search(r'\*\*Fecha.*?:\*\*\s*(.+)', content)
-    if m:
-        meta['date'] = m.group(1).strip()
+def validate_design(design: dict):
+    """Validación blanda del test-design.yml (V7.8). Solo advierte, no aborta:
+    el procesamiento real decide qué hacer con secciones vacías.
 
-    return meta
+    - H-F5-11: avisa si la versión declarada no parece V7.8.
+    - H-F5-15: avisa si faltan las secciones de las que dependen los builders.
+    """
+    md = design.get('metadata', {}) or {}
+    version = str(md.get('version') or md.get('schema_version') or design.get('version') or '').strip()
+    if version and '7.8' not in version:
+        safe_print(f'  [WARN] El test-design.yml declara versión "{version}"; este script está calibrado para V7.8.')
+
+    required = ('gatekeeper', 'test_matrix')
+    faltantes = [k for k in required if not design.get(k)]
+    if faltantes:
+        safe_print(f'  [WARN] Secciones ausentes o vacías en el YAML: {", ".join(faltantes)} '
+                   f'(se esperan gatekeeper[] para Stories y test_matrix[] para Test Cases).')
+
+
+def build_metadata(design: dict) -> dict:
+    """Deriva meta {feature, feature_code, date, author, mode} desde metadata + features."""
+    md = design.get('metadata', {}) or {}
+    features = design.get('features', []) or []
+    project = md.get('project_name') or md.get('project') or ''
+    # feature_code: un solo feature -> su code; varios (Modo Completo) -> el proyecto
+    if len(features) == 1 and features[0].get('code'):
+        feature_code = features[0]['code']
+        feature = features[0].get('name') or project
+    else:
+        feature_code = project or 'BMAD'
+        feature = project or 'BMAD'
+    return {
+        'feature': feature,
+        'feature_code': feature_code,
+        'date': str(md.get('generated_date', '')),
+        'author': '',
+        'mode': md.get('mode', ''),
+    }
 
 # ============================================================
-# Parser: Seccion I — Gatekeeper (Stories)
+# Builder: gatekeeper[] -> Stories
 # ============================================================
 
-def parse_stories(content: str, feature_code: str) -> list:
-    """Extrae stories de la tabla del Gatekeeper (Seccion I).
+def build_stories(design: dict) -> list:
+    """Construye Stories desde `gatekeeper[]` del YAML V7.8.
 
-    Soporta dos formatos de story_id:
-      - Clasico BMAD:       FEATURE-E001-S001  (ej: SEGM-SEGMT-E001-S001)
-      - Quality-process:    Story X.Y          (ej: Story 2.3)
+    Cada entrada: {story_id, name, feature, classification, justification}.
+    Clasificacion BL ('BL' / 'Logica de Negocio' / '✅') -> risk_level High.
     """
     stories = []
-
-    # Buscar seccion I — tolerar distintos terminadores de sección
-    gk_match = re.search(
-        r'## I\.\s*REPORTE DEL GATEKEEPER.*?\n(.*?)(?=\n---\s*\n\n## II|\n## Resumen|\n# FASE 2|\Z)',
-        content, re.DOTALL
-    )
-    if not gk_match:
-        return stories
-
-    section = gk_match.group(1)
-
-    for line in section.split('\n'):
-        line = line.strip()
-        if not line.startswith('|'):
+    for e in design.get('gatekeeper', []) or []:
+        if not isinstance(e, dict):
             continue
-        cols = [c.strip() for c in line.split('|')[1:-1]]
-        if len(cols) < 3:
-            continue
-        story_id = cols[0].strip()
-
-        # Detectar formato
-        is_classic = bool(re.search(r'E\d+-S\d+', story_id))          # FEATURE-E001-S001
-        is_qp      = bool(re.match(r'Story\s+\d+\.\d+', story_id))    # Story 2.3
-
-        if not is_classic and not is_qp:
+        story_id = str(e.get('story_id') or e.get('id') or '').strip()
+        if not story_id:
             continue
-
-        title          = cols[1].strip()
-        classification = cols[2].strip()
-        justification  = cols[3].strip() if len(cols) > 3 else ''
+        title = str(e.get('name', '')).strip()
+        justification = str(e.get('justification', '')).strip()
+        classification = str(e.get('classification', '')).strip()
+        feature = str(e.get('feature', '')).strip()
 
         # Epic ID
-        if is_classic:
-            epic_match = re.search(r'(.*-E\d+)', story_id)
-            epic_id = epic_match.group(1) if epic_match else ''
+        if re.search(r'E\d+-S\d+', story_id):
+            em = re.search(r'(.*-E\d+)', story_id)
+            epic_id = em.group(1) if em else ''
         else:
-            epic_num_match = re.match(r'Story\s+(\d+)\.\d+', story_id)
-            epic_id = f'Epic {epic_num_match.group(1)}' if epic_num_match else ''
+            em = re.match(r'(?:Story\s+)?(\d+)\.\d+', story_id)
+            epic_id = f'Epic {em.group(1)}' if em else (feature or '')
 
-        # Layer
+        # Layer (heuristica por contenido)
+        lower_all = (title + ' ' + justification + ' ' + feature).lower()
         layer = 'Backend'
-        lower_all = (title + justification).lower()
         if any(kw in lower_all for kw in [
             'frontend', 'react', 'ui ', 'typescript', 'hook', 'page',
             'drawer', 'form', 'navigation', 'fe+be', 'fe ',
         ]):
             layer = 'Frontend'
 
-        # Clasificación BL: soporta "BL", "Lógica de Negocio", "Logica de Negocio", "✅"
         is_bl = (
             'BL' in classification or
-            'gica de Negocio' in classification or   # Lógica / Logica
+            'gica de Negocio' in classification or   # Logica / Lógica de Negocio
             '✅' in classification
         )
 
@@ -233,258 +260,178 @@ def parse_stories(content: str, feature_code: str) -> list:
             layer=layer,
             risk_level='High' if is_bl else 'Low',
         ))
-
     return stories
 
 # ============================================================
-# Parser: Seccion II — FACs Gherkin
+# Builder: features[].fac[] -> FACs Gherkin
 # ============================================================
 
-def parse_facs(content: str) -> dict:
-    """Extrae FAC Gherkin de Seccion II. Retorna dict: fac_id -> gherkin_text."""
+def build_facs(design: dict) -> dict:
+    """Construye dict fac_id -> texto Gherkin desde `features[].fac[]`."""
     facs = {}
-
-    # Buscar todos los Scenario dentro de bloques ```gherkin
-    gherkin_blocks = re.findall(r'```gherkin\s*\n(.*?)```', content, re.DOTALL)
-
-    for block in gherkin_blocks:
-        # Separar scenarios
-        scenarios = re.split(r'\n\s*(?=Scenario(?:\s+Outline)?:)', block)
-        for scenario in scenarios:
-            scenario = scenario.strip()
-            if not scenario.startswith('Scenario'):
+    for feat in design.get('features', []) or []:
+        if not isinstance(feat, dict):
+            continue
+        for fac in feat.get('fac', []) or []:
+            if not isinstance(fac, dict):
                 continue
-            # Extraer FAC ID del titulo
-            title_match = re.match(r'Scenario(?:\s+Outline)?:\s*(F\d+-(?:FAC|NF)-\d+)\s*', scenario)
-            if title_match:
-                fac_id = title_match.group(1)
-                facs[fac_id] = scenario
-
+            fid = str(fac.get('id', '')).strip()
+            gherkin = str(fac.get('gherkin', '')).strip()
+            if fid:
+                facs[fid] = gherkin
     return facs
 
 # ============================================================
-# Parser: Seccion IV — Matriz 360° (Test Cases)
+# Builder: test_matrix[] -> Test Cases (con steps atomicos)
 # ============================================================
 
-def parse_matrix_row(cols: list) -> TestCase:
-    """Parsea una fila de la matriz 360° (12 columnas) en un TestCase."""
-    # Columnas: ID | Funcionalidad | Epicas | Nivel | Tecnica | Escenario |
-    #           Precondiciones | Pasos | Resultado Esperado | Riesgo (IxP) | Prioridad | Estrategia
-    tc_id = cols[0].strip()
-    feature = cols[1].strip() if len(cols) > 1 else ''
-    epics = cols[2].strip() if len(cols) > 2 else ''
-    level_raw = cols[3].strip() if len(cols) > 3 else ''
-    technique = cols[4].strip() if len(cols) > 4 else ''
-    scenario = cols[5].strip() if len(cols) > 5 else ''
-    preconditions = cols[6].strip() if len(cols) > 6 else ''
-    pasos = cols[7].strip() if len(cols) > 7 else ''
-    expected = cols[8].strip() if len(cols) > 8 else ''
-    risk_score = cols[9].strip() if len(cols) > 9 else ''
-    priority = cols[10].strip() if len(cols) > 10 else ''
-    strategy = cols[11].strip() if len(cols) > 11 else ''
-
-    # Normalizar nivel
-    level = LEVEL_NORMALIZE.get(level_raw, level_raw)
-
-    # Construir steps: Precondiciones -> Setup, Pasos -> Action, Expected -> Result
-    steps = []
-    if preconditions and preconditions != '—' and preconditions != '-':
-        steps.append(TestStep(
-            action=f'SETUP: {preconditions}',
-            expected_result='Precondiciones verificadas',
-        ))
-    if pasos:
-        # Separar pasos numerados (1. xxx 2. yyy)
-        numbered = re.split(r'\d+\.\s+', pasos)
-        numbered = [p.strip() for p in numbered if p.strip()]
-        if len(numbered) > 1:
-            # Multiples pasos: uno por cada numerado, el ultimo lleva el expected
-            for i, paso in enumerate(numbered):
-                if i < len(numbered) - 1:
-                    steps.append(TestStep(
-                        action=paso,
-                        expected_result='Paso ejecutado correctamente',
-                    ))
-                else:
-                    steps.append(TestStep(
-                        action=paso,
-                        expected_result=expected,
-                    ))
-        else:
-            steps.append(TestStep(
-                action=pasos,
-                expected_result=expected,
-            ))
-    elif expected:
-        steps.append(TestStep(
-            action=scenario or 'Ejecutar escenario',
-            expected_result=expected,
-        ))
-
-    # Extraer story refs del campo Epicas
-    source_stories = []
-    story_refs = re.findall(r'E\d+-S\d+', epics)
-    # Se enriquecen despues con feature_code prefix
-
-    # Construir titulo: escenario como titulo descriptivo
-    title = scenario if scenario else tc_id
-
-    # Raw body para descripcion en Jira
-    raw_body = (
-        f'Escenario: {scenario}\n'
-        f'Precondiciones: {preconditions}\n'
-        f'Pasos: {pasos}\n'
-        f'Resultado Esperado: {expected}\n'
-        f'Tecnica: {technique}\n'
-        f'Riesgo: {risk_score}'
-    )
-
-    return TestCase(
-        tc_id=tc_id,
-        title=title,
-        priority=priority,
-        level=level,
-        feature=feature,
-        epics=epics,
-        technique=technique,
-        scenario=scenario,
-        preconditions=preconditions,
-        risk_score=risk_score,
-        strategy=strategy,
-        source_stories=source_stories,
-        raw_body=raw_body,
-        steps=steps,
-    )
+def build_test_cases(design: dict) -> list:
+    """Construye Test Cases desde `test_matrix[]` (V7.8).
 
-
-def parse_test_cases(content: str) -> list:
-    """Extrae Test Cases de Seccion IV (Matriz 360°)."""
+    Cada caso trae `steps[]` como array de {paso, accion, resultado, datos}. Cada step
+    se mapea a un TestStep con su `data` (datos por paso) — insumo del testData de AgileTest.
+    """
     test_cases = []
-
-    # Buscar seccion IV
-    matrix_match = re.search(
-        r'## IV\.\s*MATRIZ INTEGRAL.*?\n(.*?)(?=\n---\s*\n\n## V|\Z)',
-        content, re.DOTALL
-    )
-    if not matrix_match:
-        return test_cases
-
-    section = matrix_match.group(1)
-
-    # Parsear todas las filas de tabla que empiecen con | TC-
-    for line in section.split('\n'):
-        line = line.strip()
-        if not line.startswith('|'):
+    for c in design.get('test_matrix', []) or []:
+        if not isinstance(c, dict):
             continue
-        # Saltar headers y separadores
-        if '---' in line or 'ID' in line.split('|')[1]:
+        tc_id = str(c.get('id', '')).strip()
+        if not tc_id:
             continue
 
-        cols = [c.strip() for c in line.split('|')[1:-1]]
-        if len(cols) < 8:
-            continue
-        # Verificar que la primera columna es un TC ID
-        if not cols[0].startswith('TC-'):
-            continue
+        feature = str(c.get('feature', '')).strip()
+        epics_raw = c.get('epics', [])
+        if isinstance(epics_raw, list):
+            epics = ', '.join(str(x) for x in epics_raw)
+        else:
+            epics = str(epics_raw or '')
+        modo          = str(c.get('mode', '') or '').strip()
+        level_raw     = str(c.get('level', '') or '').strip()
+        tipo_interfaz = str(c.get('interface_type', '') or '').strip()
+        technique     = str(c.get('technique', '') or '').strip()
+        scenario      = str(c.get('scenario', '') or '').strip()
+        preconditions = str(c.get('preconditions', '') or '').strip()
+        expected      = str(c.get('expected_result', '') or '').strip()
+        risk_score    = str(c.get('risk', '') or '').strip()
+        priority      = str(c.get('priority', '') or '').strip()
+        level = LEVEL_NORMALIZE.get(level_raw, level_raw)
+
+        # Steps: precondiciones como SETUP + un step por cada paso atomico del YAML
+        steps = []
+        if preconditions and preconditions not in ('—', '-'):
+            steps.append(TestStep(
+                action=f'SETUP: {preconditions}',
+                expected_result='Precondiciones verificadas',
+            ))
+        for s in c.get('steps', []) or []:
+            if isinstance(s, dict):
+                accion    = str(s.get('accion', '') or '').strip()
+                resultado = str(s.get('resultado', '') or '').strip()
+                datos     = str(s.get('datos', '') or '').strip()
+            else:
+                # tolerancia: step como string suelto
+                accion, resultado, datos = str(s).strip(), '', ''
+            if accion:
+                steps.append(TestStep(
+                    action=accion,
+                    expected_result=resultado or expected,
+                    data=datos,
+                ))
+        # Fallback: si el YAML no trajo pasos atomicos pero hay resultado esperado
+        if not any(not st.action.startswith('SETUP:') for st in steps) and expected:
+            steps.append(TestStep(
+                action=scenario or 'Ejecutar escenario',
+                expected_result=expected,
+            ))
 
-        tc = parse_matrix_row(cols)
-        test_cases.append(tc)
+        title = scenario if scenario else tc_id
+        raw_body = (
+            f'Escenario: {scenario}\n'
+            f'Precondiciones: {preconditions}\n'
+            f'Resultado Esperado: {expected}\n'
+            f'Tecnica: {technique}\n'
+            + (f'Modo: {modo}\n' if modo else '')
+            + (f'Tipo Interfaz: {tipo_interfaz}\n' if tipo_interfaz else '')
+            + f'Riesgo: {risk_score}'
+        )
 
+        test_cases.append(TestCase(
+            tc_id=tc_id,
+            title=title,
+            priority=priority,
+            level=level,
+            feature=feature,
+            epics=epics,
+            technique=technique,
+            scenario=scenario,
+            preconditions=preconditions,
+            risk_score=risk_score,
+            strategy=tipo_interfaz,
+            source_stories=[],
+            raw_body=raw_body,
+            steps=steps,
+        ))
     return test_cases
 
 # ============================================================
-# Parser: Apendice — Traceability
+# Builder: traceability[] -> mapping requirement -> [tc_ids]
 # ============================================================
 
-def _parse_traceability_classic(section: str, feature_code: str) -> dict:
-    """Formato clásico BMAD: '- E001-S001 (name) → TC-P0-CRUD-001, ...'"""
+def build_traceability(design: dict) -> dict:
+    """Construye mapping requisito/criterio -> [tc_ids] desde `traceability[]`."""
     mapping = {}
-    line_pattern = re.compile(
-        r'-\s*(E\d+-S\d+)\s*\(.*?\)\s*(?:→|->)\s*(.+?)$', re.MULTILINE
-    )
-    for m in line_pattern.finditer(section):
-        story_id = f'{feature_code}-{m.group(1)}'
-        tc_ids = re.findall(r'TC-[A-Z0-9]+-[\w]+-\d+', m.group(2))
-        tc_ids += [t for t in re.findall(r'TC-[A-Z0-9]+-\d+', m.group(2))
-                   if t not in tc_ids]
-        if tc_ids:
-            mapping.setdefault(story_id, [])
-            mapping[story_id] = list(set(mapping[story_id] + tc_ids))
+    for t in design.get('traceability', []) or []:
+        if not isinstance(t, dict):
+            continue
+        req = str(t.get('requirement', '') or '').strip()
+        if not req:
+            continue
+        cases = t.get('cases', []) or []
+        mapping.setdefault(req, [])
+        for cid in cases:
+            cid = str(cid).strip()
+            if cid and cid not in mapping[req]:
+                mapping[req].append(cid)
     return mapping
 
 
-def _parse_traceability_tree(section: str) -> dict:
-    """Formato árbol quality-process:
-        F2 — Client Management
-          ├── Story 2.1 (List & Search) → TC-F2-01, TC-F2-02
-          ├── Story 1.2 (Navigation)
-          │   ├── TC-F1-01 (desc)
-          └── ...
+def augment_trace_with_stories(trace_map: dict, stories: list, test_cases: list):
+    """Agrega al trace_map los vinculos story_id -> [tc_ids] inferidos de la columna
+    `epics` de cada caso, para que el link TC -> Requisito (gatekeeper) funcione aunque
+    el bloque `traceability` apunte a FACs en vez de a historias.
     """
-    mapping = {}
-    current_story = None
-    current_tcs = []
-
-    for line in section.split('\n'):
-        # Detectar línea que menciona una Story
-        story_match = re.search(r'\bStory\s+(\d+\.\d+)\b', line)
-        if story_match:
-            # Cerrar story anterior
-            if current_story and current_tcs:
-                mapping.setdefault(current_story, [])
-                mapping[current_story] = list(set(mapping[current_story] + current_tcs))
-
-            current_story = f'Story {story_match.group(1)}'
-            current_tcs = []
-
-            # TCs en la misma línea: Story 2.1 → TC-F2-01, TC-F2-02
-            arrow_match = re.search(r'(?:→|->)\s*(.+)$', line)
-            if arrow_match:
-                current_tcs.extend(re.findall(r'TC-[A-Z0-9]+-\d+', arrow_match.group(1)))
-
-        elif current_story:
-            # TCs en líneas hijo: │   ├── TC-F1-01 (desc)
-            tcs = re.findall(r'TC-[A-Z0-9]+-\d+', line)
-            current_tcs.extend(tcs)
-
-    # Guardar el último story
-    if current_story and current_tcs:
-        mapping.setdefault(current_story, [])
-        mapping[current_story] = list(set(mapping[current_story] + current_tcs))
-
-    return mapping
+    story_ids = {s.story_id for s in stories}
 
+    def norm(sid):
+        m = re.search(r'(\d+\.\d+)', sid)
+        return m.group(1) if m else sid
 
-def parse_traceability(content: str, feature_code: str) -> dict:
-    """Extrae mapping Story → TCs desde el Apéndice de Trazabilidad.
+    norm_index = {norm(sid): sid for sid in story_ids}
 
-    Soporta dos formatos:
-      - Clásico BMAD:       '- E001-S001 (name) → TC-P0-CRUD-001'
-      - Quality-process:    árbol con ├── y Story X.Y
-    """
-    # Buscar sección del apéndice (varios posibles encabezados)
-    trace_match = re.search(
-        r'### Funcionalidad.*?(?:Casos de Prueba|Historias|Features).*?\n(.*?)(?=\n### Trazabilidad|\n### Requerimientos|\Z)',
-        content, re.DOTALL
-    )
-    if not trace_match:
-        trace_match = re.search(
-            r'(?:APÉNDICE|APENDICE).*?TRAZABILIDAD.*?\n(.*?)(?=\n### Trazabilidad|\n### Requerimientos|\Z)',
-            content, re.DOTALL
-        )
-    if not trace_match:
-        return {}
-
-    section = trace_match.group(1)
+    for tc in test_cases:
+        if not tc.epics:
+            continue
+        refs = re.findall(r'E\d+-S\d+', tc.epics) + re.findall(r'\b\d+\.\d+\b', tc.epics)
+        for ref in refs:
+            sid = ref if ref in story_ids else norm_index.get(norm(ref))
+            if not sid:
+                continue
+            trace_map.setdefault(sid, [])
+            if tc.tc_id not in trace_map[sid]:
+                trace_map[sid].append(tc.tc_id)
+    return trace_map
 
-    # Intentar formato clásico primero
-    mapping = _parse_traceability_classic(section, feature_code)
+# ============================================================
+# (legacy) Parser: Seccion II — FACs Gherkin
+# ============================================================
 
-    # Si no encontró nada, intentar formato árbol quality-process
-    if not mapping:
-        mapping = _parse_traceability_tree(section)
+# ============================================================
+# (legacy) Parser: Seccion IV — Matriz 360° (Test Cases)
+# ============================================================
 
-    return mapping
+# ============================================================
+# (legacy) Parser: Apendice — Traceability
+# ============================================================
 
 # ============================================================
 # Enriquecimiento: propagar traceability y FACs a TCs
@@ -503,12 +450,17 @@ def enrich_test_cases(test_cases: list, trace_map: dict, facs: dict, feature_cod
 
     # 2. Inferir story refs del campo epics de cada TC
     for tc in test_cases:
-        if tc.epics:
-            refs = re.findall(r'E\d+-S\d+', tc.epics)
-            for ref in refs:
-                full_id = f'{feature_code}-{ref}'
-                if full_id not in tc.source_stories:
-                    tc.source_stories.append(full_id)
+        if not tc.epics:
+            continue
+        # Formato clasico: E001-S001
+        for ref in re.findall(r'E\d+-S\d+', tc.epics):
+            full_id = f'{feature_code}-{ref}'
+            if full_id not in tc.source_stories:
+                tc.source_stories.append(full_id)
+        # Formato V7.8: "Epic 2 / 2.1, 2.5" -> historias 2.1, 2.5 (numero pelado)
+        for ref in re.findall(r'\b\d+\.\d+\b', tc.epics):
+            if ref not in tc.source_stories:
+                tc.source_stories.append(ref)
 
     # 3. Normalizar niveles
     for tc in test_cases:
@@ -518,27 +470,24 @@ def enrich_test_cases(test_cases: list, trace_map: dict, facs: dict, feature_cod
 # Enriquecimiento: epic names en stories
 # ============================================================
 
-def enrich_stories_from_traceability(content: str, stories: list):
-    """Extrae nombres de Feature/Epic del texto de traceability y los asigna a stories."""
-    # Buscar lineas como: **F1 — Gestion del Ciclo de Vida de Segmentos**
-    feature_blocks = re.findall(
-        r'\*\*(F\d+)\s*(?:—|--)\s*(.+?)\*\*', content
-    )
-    feature_names = {fid: fname.strip() for fid, fname in feature_blocks}
-
-    # Buscar en traceability lineas como:
-    # - E001-S001 (Entities & EF Core) -> ...
-    epic_names = {}
-    for m in re.finditer(r'-\s*(E\d+-S\d+)\s*\((.+?)\)', content):
-        epic_names[m.group(1)] = m.group(2).strip()
+def enrich_stories_from_features(design: dict, stories: list):
+    """Asigna epic_name a las stories usando los nombres de `features[]` del YAML."""
+    feature_names = {}
+    for feat in design.get('features', []) or []:
+        if not isinstance(feat, dict):
+            continue
+        code = str(feat.get('code', '') or '').strip()
+        name = str(feat.get('name', '') or '').strip()
+        if code and name:
+            feature_names[code] = name
 
     for s in stories:
-        # Buscar nombre de epic
-        suffix = re.search(r'E\d+-S\d+', s.story_id)
-        if suffix:
-            key = suffix.group(0)
-            if key in epic_names and not s.epic_name:
-                s.epic_name = epic_names[key]
+        if s.epic_name:
+            continue
+        # epic_id tipo "VNT-E001" -> prefijo de feature antes del primer '-'
+        code = s.epic_id.split('-')[0] if s.epic_id else ''
+        if code in feature_names:
+            s.epic_name = feature_names[code]
 
 # ============================================================
 # API: Jira REST
@@ -550,6 +499,9 @@ class JiraAPI:
         self.email = config['jira_user_email']
         self.token = config['jira_api_token']
         self.project = config['jira_project_key']
+        # Campos Jira obligatorios por proyecto (ej. CON exige timetracking.originalEstimate).
+        # Se mergean en cada create_issue; vacío por defecto (HCM no los requiere).
+        self.extra_fields = config.get('extra_fields') or {}
 
     def _headers(self):
         import base64
@@ -578,8 +530,12 @@ class JiraAPI:
         except Exception:
             return []
 
-    def create_issue(self, summary, description, issue_type_id, priority='Media', labels=None):
-        """Crea un issue en Jira y retorna el ID y key."""
+    def create_issue(self, summary, description, issue_type_id, priority='Media', labels=None, extra_fields=None):
+        """Crea un issue en Jira y retorna el ID y key.
+
+        extra_fields: dict opcional de campos Jira adicionales (ej. timetracking).
+        Si es None, usa self.extra_fields (de config.yaml agiletest.extra_fields).
+        """
         import urllib.request
         fields = {
             'project': {'key': self.project},
@@ -592,6 +548,10 @@ class JiraAPI:
         }
         if priority:
             fields['priority'] = {'name': priority}
+        # Mergear campos obligatorios por proyecto (ej. CON: timetracking.originalEstimate)
+        merged_extra = extra_fields if extra_fields is not None else self.extra_fields
+        if merged_extra:
+            fields.update(merged_extra)
         payload = {'fields': fields}
         if labels:
             payload['fields']['labels'] = labels
@@ -857,7 +817,7 @@ def build_plan_tc_map(test_cases):
 def print_summary(stories, test_cases, trace_map, facs, meta):
     """Muestra resumen del parseo."""
     safe_print('\n' + '=' * 70)
-    safe_print(' BMAD V6.0 -> AgileTest -- Resumen del parseo')
+    safe_print(' BMAD V7.8 (YAML) -> AgileTest -- Resumen del parseo')
     safe_print('=' * 70)
 
     safe_print(f'\n  Feature: {meta.get("feature", "?")}')
@@ -1025,6 +985,14 @@ def create_in_agiletest(stories, test_cases, trace_map, meta, config, state_dir=
     feature_label = (meta.get('feature_code', '') or 'BMAD').replace('-', '_').replace(' ', '_').replace('&', 'and')
     if state_dir is None:
         state_dir = os.path.dirname(os.path.abspath(__file__))
+    # H-F5-13: garantizar que el state-dir existe y es escribible; fallar con mensaje claro
+    try:
+        os.makedirs(state_dir, exist_ok=True)
+        if not os.access(state_dir, os.W_OK):
+            raise OSError('sin permiso de escritura')
+    except OSError as e:
+        safe_print(f'  ERROR: no se puede usar el state-dir "{state_dir}": {e}')
+        sys.exit(3)
     state_path = os.path.join(state_dir, f'bmad_state_{feature_label}.json')
     state = load_state(state_path)
 
@@ -1425,15 +1393,32 @@ def load_bmm_config(config_path: str):
     # Capa 1: config.yaml público (sin secretos)
     try:
         with open(config_path, 'r', encoding='utf-8') as f:
-            _extract_agiletest_section(f.read(), 'config.yaml', include_secrets=False)
+            content = f.read()
+        _extract_agiletest_section(content, 'config.yaml', include_secrets=False)
+        # extra_fields es una estructura anidada: se parsea con YAML, no con regex.
+        try:
+            import yaml
+            cfg = yaml.safe_load(content)
+            at = (cfg.get('agiletest') or {}) if isinstance(cfg, dict) else {}
+            if isinstance(at, dict) and isinstance(at.get('extra_fields'), dict):
+                CONFIG['extra_fields'] = at['extra_fields']
+        except Exception:
+            pass  # extra_fields es opcional; si el YAML falla, se ignora
     except Exception as e:
         safe_print(f'  [WARN] No se pudo leer {config_path}: {e}')
 
     # Capa 2: config.secrets.yaml (gitignoreado, tiene los tokens)
-    # Buscar en _siesa-agents/bmm/ (relativo al directorio del script)
+    # Buscar primero junto al --config provisto, luego relativo al script (_siesa-agents/bmm/).
     script_dir = os.path.dirname(os.path.abspath(__file__))
-    secrets_path = os.path.normpath(os.path.join(script_dir, '..', 'bmm', 'config.secrets.yaml'))
-    if os.path.exists(secrets_path):
+    secrets_candidates = [
+        os.path.join(config_dir, 'config.secrets.yaml'),
+        os.path.normpath(os.path.join(script_dir, '..', 'bmm', 'config.secrets.yaml')),
+    ]
+    secrets_path = next((p for p in secrets_candidates if os.path.exists(p)), None)
+    if VERBOSE:
+        safe_print(f'  [VERBOSE] config.yaml: {config_path}')
+        safe_print(f'  [VERBOSE] config.secrets.yaml: {secrets_path or "(no encontrado)"}')
+    if secrets_path:
         try:
             with open(secrets_path, 'r', encoding='utf-8') as f:
                 _extract_agiletest_section(f.read(), 'config.secrets.yaml', include_secrets=True)
@@ -1457,14 +1442,14 @@ def load_bmm_config(config_path: str):
 
 def main():
     parser = argparse.ArgumentParser(
-        description='BMAD V6.0 -> AgileTest: Parser + Cargador',
+        description='BMAD V7.8 (YAML) -> AgileTest: Parser + Cargador',
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="""
 Ejemplos:
   python bmad_to_agiletest.py --dry-run                    Parsea y muestra resumen
   python bmad_to_agiletest.py --dry-run --detail            Muestra cada TC con steps
   python bmad_to_agiletest.py --dry-run --export            Exporta a JSON
-  python bmad_to_agiletest.py --input mi-archivo.md --dry-run
+  python bmad_to_agiletest.py --input test-design.yml --dry-run
   python bmad_to_agiletest.py --create                      Crea todo en Jira/AgileTest
         """,
     )
@@ -1477,45 +1462,69 @@ Ejemplos:
     parser.add_argument('--feature-filter', default=None,
                         help='Filtrar por feature key (ej: F4, F1). Solo procesa TCs de esa feature')
     parser.add_argument('--input', default=CONFIG['input_file'],
-                        help='Ruta al archivo test-design.md generado por quality-process')
+                        help='Ruta al archivo test-design.yml generado por quality-process')
     parser.add_argument('--config', default=None,
                         help='Ruta a _bmad/bmm/config.yaml (para leer sección agiletest)')
+    parser.add_argument('--jira-url', default=None,
+                        help='URL base de Jira (sobreescribe config.yaml). Ej: https://tu-org.atlassian.net')
+    parser.add_argument('--project-key', default=None,
+                        help='Project key de Jira (sobreescribe config.yaml). Ej: CON, COM, MAN')
     parser.add_argument('--state-dir', default=None,
                         help='Directorio donde guardar el state file (default: directorio del input)')
+    parser.add_argument('--verbose', action='store_true',
+                        help='Imprime detalle de diagnóstico (rutas de config/secrets resueltas, instancia destino)')
 
     args = parser.parse_args()
+    global VERBOSE
+    VERBOSE = args.verbose
 
     # Cargar config YAML si se proveyó (sobreescribe CONFIG con valores no-secretos)
     if args.config:
         load_bmm_config(args.config)
 
+    # Flags CLI: tienen prioridad sobre config.yaml para identificar la instancia Jira destino
+    if args.jira_url:
+        CONFIG['jira_base_url'] = args.jira_url
+    if args.project_key:
+        CONFIG['jira_project_key'] = args.project_key
+
     # Resolver ruta
     script_dir = os.path.dirname(os.path.abspath(__file__))
     input_path = os.path.join(script_dir, args.input) if not os.path.isabs(args.input) else args.input
 
     if not os.path.exists(input_path):
         print(f'  ERROR: Archivo no encontrado: {input_path}')
-        sys.exit(1)
+        sys.exit(2)
 
-    # Leer archivo completo
-    print(f'Parseando: {os.path.basename(input_path)}')
-    with open(input_path, 'r', encoding='utf-8') as f:
-        content = f.read()
+    if VERBOSE:
+        safe_print(f'  [VERBOSE] Instancia destino: {CONFIG["jira_base_url"]} | proyecto {CONFIG["jira_project_key"]}')
+        safe_print(f'  [VERBOSE] Input: {input_path}')
 
-    # Parsear metadata
-    meta = parse_metadata(content)
+    # Cargar el test-design.yml (V7.8) via yaml.safe_load
+    print(f'Cargando YAML: {os.path.basename(input_path)}')
+    try:
+        design = load_design(input_path)
+    except Exception as e:
+        print(f'  ERROR: YAML inválido en {os.path.basename(input_path)}: {e}')
+        sys.exit(2)
+    validate_design(design)
+
+    # Metadata
+    meta = build_metadata(design)
     feature_code = meta.get('feature_code', 'UNKNOWN')
-    print(f'  Feature: {meta.get("feature", "?")} ({feature_code})')
+    print(f'  Feature: {meta.get("feature", "?")} ({feature_code}) | Modo: {meta.get("mode", "?")}')
 
-    # Parsear todas las secciones
-    stories = parse_stories(content, feature_code)
-    facs = parse_facs(content)
-    test_cases = parse_test_cases(content)
-    trace_map = parse_traceability(content, feature_code)
+    # Construir entidades desde el YAML
+    stories = build_stories(design)
+    facs = build_facs(design)
+    test_cases = build_test_cases(design)
+    trace_map = build_traceability(design)
 
     # Enriquecer datos cruzados
     enrich_test_cases(test_cases, trace_map, facs, feature_code)
-    enrich_stories_from_traceability(content, stories)
+    enrich_stories_from_features(design, stories)
+    # Link story -> TC inferido de la columna epics (para TC -> Requisito en el create)
+    augment_trace_with_stories(trace_map, stories, test_cases)
 
     # Filtrado por feature (--pilot usa F4, --feature-filter usa lo indicado)
     feat_filter = None
@@ -1554,6 +1563,12 @@ Ejemplos:
         export_json(stories, test_cases, trace_map, facs, meta, json_path)
 
     if args.create:
+        # H-F5-04: avisar si se creará en la instancia por defecto sin override explícito
+        if not (args.config or args.jira_url or args.project_key):
+            safe_print('\n  [WARN] No se especificó --config, --jira-url ni --project-key.')
+            safe_print(f'         Se usará la instancia por defecto: {CONFIG["jira_base_url"]} (proyecto {CONFIG["jira_project_key"]}).')
+            safe_print('         Si NO es tu instancia, cancela y re-ejecuta con --jira-url/--project-key o --config.')
+
         missing = []
         if not CONFIG.get('jira_api_token'):
             missing.append('jira_api_token  (env: JIRA_API_TOKEN)')