siesa-agents 2.1.72-qa.13 → 2.1.72-qa.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "siesa-agents",
-  "version": "2.1.72-qa.13",
+  "version": "2.1.72-qa.15",
   "description": "Paquete para instalar y configurar agentes SIESA en tu proyecto",
   "main": "index.js",
   "bin": {

package/siesa-agents/bmm/workflows/3-solutioning/quality-process/workflow.md

@@ -935,9 +935,20 @@ Después de guardar `shards/test-design-phase4-test-matrix.md` (Sección V — M
 **Exportar el diseño completo a YAML estructurado:**
 
 Además del `test-design.md` (narrativo) y el `test-cases.csv` (casos tabulares), generar un
-`test-design.yml` que represente **todo el diseño en formato datos** (machine-readable). El
-agente ya tiene en memoria las Secciones I→VI del megaprompt — serializarlas a YAML con esta
-estructura:
+`test-design.yml` que represente **todo el diseño en formato datos** (machine-readable).
+
+> **🚨 OBLIGATORIO — también (y especialmente) en Modo Completo / batch.** El `test-design.yml`
+> NO es opcional: es el insumo directo de AgileTest (Fase 5), del Motor de Datos (Fase 4) y del
+> Agente Ejecutor E2E (Fase 6). Debe generarse para el batch diseñado en esta corrida, sin importar
+> cuántos casos tenga la matriz.
+>
+> **Fuente de verdad = los shards ya guardados, NO la memoria.** En corridas largas (Modo Completo
+> con varios features) la matriz puede haber salido del contexto. Para construir el YAML de forma
+> robusta, **re-lee los archivos recién escritos** en `shards/` — sobre todo
+> `shards/test-design-phase4-test-matrix.md` (Sección V — Matriz) y los demás shards (I, II/III, VI)
+> — y serialízalos. Así el `.yml` no depende de que el diseño siga "en memoria".
+
+Serializar a YAML con esta estructura:
 
 ```yaml
 metadata:
@@ -1024,6 +1035,16 @@ traceability:                     # Apéndice — Matriz de Trazabilidad
 
 Guardar como: `{implementation_artifacts}/quality-process/diseno/test-design-YYYY-MM-DD-HHmmss/test-design.yml` (en la raíz, junto a `test-cases.csv`, NO en shards/)
 
+**Verificación obligatoria (guard) — no completar la Fase 3 sin el YAML:**
+
+Tras el Write, **verificar que `test-design.yml` exista y no esté vacío** (y que su `test_matrix`
+tenga el mismo número de entradas que filas tiene la matriz del CSV/Markdown):
+
+- Si el archivo **no existe, quedó vacío o truncado** (caso típico en batch grande): **regenerarlo
+  re-leyendo los shards** (`shards/test-design-phase4-test-matrix.md` + I, II/III, VI) y volver a
+  escribirlo. Repetir hasta que el `.yml` esté completo.
+- **No avanzar a F3.5** ni reportar la fase como completada mientras falte el `test-design.yml`.
+
 ---
 
 ### F3.5: Completion

package/siesa-agents/scripts/bmad_to_agiletest.py

@@ -1,22 +1,25 @@
 """
-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`).
+
 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 +56,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',
@@ -134,101 +137,85 @@ 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()
-
-    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()
-
-    return meta
+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 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
+
+
+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 del ID de historia
-        is_classic = bool(re.search(r'E\d+-S\d+', story_id))          # FEATURE-E001-S001
-        # quality-process: "Story 2.3" o, en V7.8, el numero pelado "2.3"
-        is_qp      = bool(re.match(r'(?:Story\s+)?\d+\.\d+\s*$', story_id))
-
-        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()
-        # Layout del gatekeeper:
-        #   - 4 cols (clasico/qp): ID | Titulo | Clasificacion | Justificacion
-        #   - 5 cols (V7.8):       ID | Nombre/Epica | Feature | Clasificacion | Justificacion
-        if len(cols) >= 5:
-            classification = cols[3].strip()
-            justification  = cols[4].strip()
-        else:
-            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
         )
 
@@ -241,332 +228,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 los bloques ```gherkin. Retorna dict: fac_id -> texto.
-
-    Soporta dos convenciones de ID observadas en archivos reales:
-      - ID en el titulo del Scenario:  'Scenario: F1-FAC-001 ...'
-      - ID en un comentario previo:    '# FAC-F1-F01: ...'  seguido de
-                                       'Scenario: <descripcion>'
-    """
+def build_facs(design: dict) -> dict:
+    """Construye dict fac_id -> texto Gherkin desde `features[].fac[]`."""
     facs = {}
-
-    gherkin_blocks = re.findall(r'```gherkin\s*\n(.*?)```', content, re.DOTALL)
-
-    # ID embebido en el titulo del Scenario. Dos convenciones:
-    #   - clasico: 'Scenario: F1-FAC-001 ...'
-    #   - V7.8:    'Scenario: FAC-FND-01 — ...'  (FAC/NF + codigo de feature)
-    id_in_title = re.compile(
-        r'Scenario(?:\s+Outline)?:\s*(F\d+-(?:FAC|NF)-\d+|(?:FAC|NF)-[A-Z]+-\d+)\b'
-    )
-    # ID en un comentario Gherkin (formato por fases): '# FAC-F1-F01' o '# F1-FAC-001'
-    id_in_comment = re.compile(r'#\s*((?:FAC|NF)-F\d+-\w+|F\d+-(?:FAC|NF)-\d+)\b')
-    is_scenario = re.compile(r'Scenario(?:\s+Outline)?:')
-
-    for block in gherkin_blocks:
-        pending_id = None      # id de comentario aun sin asociar a un Scenario
-        current_id = None
-        current_lines = []
-
-        def flush():
-            nonlocal current_id, current_lines
-            if current_id and current_lines:
-                facs[current_id] = '\n'.join(current_lines).strip()
-            current_id = None
-            current_lines = []
-
-        for raw in block.split('\n'):
-            line = raw.strip()
-            if is_scenario.match(line):
-                flush()
-                title_m = id_in_title.match(line)
-                if title_m:
-                    current_id = title_m.group(1)
-                else:
-                    current_id = pending_id  # usar el id del comentario previo
-                pending_id = None
-                current_lines = [line]
-                continue
-            # Comentario con ID de FAC (solo fuera de un Scenario en curso)
-            cmt = id_in_comment.match(line)
-            if cmt and current_id is None:
-                pending_id = cmt.group(1)
+    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
-            if current_id:
-                current_lines.append(line)
-        flush()
-
+            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° en un TestCase.
+def build_test_cases(design: dict) -> list:
+    """Construye Test Cases desde `test_matrix[]` (V7.8).
 
-    Soporta los dos layouts de columnas observados en archivos reales,
-    detectados por el numero de columnas:
-      - Clasico (12 cols):  ID | Funcionalidad | Features | Nivel | Tecnica |
-        Escenario | Precondiciones | Pasos | Resultado | Riesgo | Prioridad | Estrategia
-      - V7.8    (13 cols):  ID | Feature | Epicas | Modo | Nivel | Tipo Interfaz |
-        Tecnica | Escenario | Precondiciones | Pasos | Resultado | Riesgo | Prioridad
+    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.
     """
-    def col(i):
-        return cols[i].strip() if len(cols) > i else ''
-
-    tc_id = col(0)
-    modo = ''
-    tipo_interfaz = ''
-    if len(cols) >= 13:
-        # Layout V7.8 (13 columnas): Modo y Tipo Interfaz insertadas
-        feature       = col(1)
-        epics         = col(2)
-        modo          = col(3)
-        level_raw     = col(4)
-        tipo_interfaz = col(5)
-        technique     = col(6)
-        scenario      = col(7)
-        preconditions = col(8)
-        pasos         = col(9)
-        expected      = col(10)
-        risk_score    = col(11)
-        priority      = col(12)
-        strategy      = tipo_interfaz  # V7.8 no tiene columna Estrategia
-    else:
-        # Layout clasico (12 columnas)
-        feature       = col(1)
-        epics         = col(2)
-        level_raw     = col(3)
-        technique     = col(4)
-        scenario      = col(5)
-        preconditions = col(6)
-        pasos         = col(7)
-        expected      = col(8)
-        risk_score    = col(9)
-        priority      = col(10)
-        strategy      = col(11)
-
-    # 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'Modo: {modo}\n' if modo else '')
-        + (f'Tipo Interfaz: {tipo_interfaz}\n' if tipo_interfaz else '')
-        + 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 parse_test_cases(content: str) -> list:
-    """Extrae Test Cases de Seccion IV (Matriz 360°)."""
     test_cases = []
-
-    # Anclar la matriz por el TEXTO del encabezado, no por su numeral. Esto
-    # tolera los tres formatos observados en archivos reales:
-    #   - clasico:  "## IV. MATRIZ INTEGRAL ..."
-    #   - V7.8:     "## V. MATRIZ INTEGRAL ..."
-    #   - por fases:"# FASE 4 — MATRIZ INTEGRAL DE PRUEBAS (DISEÑO 360°)"
-    # Captura hasta el siguiente encabezado de fase (h1 "# FASE N") o la
-    # siguiente seccion romana (h2 "## V."/"## VI.") o el fin del documento.
-    matrix_match = re.search(
-        r'#+[^\n]*MATRIZ INTEGRAL[^\n]*\n(.*?)(?=\n#\s+FASE\s|\n##\s+[IVX]+[.\s]|\Z)',
-        content, re.DOTALL
-    )
-    if not matrix_match:
-        return test_cases
-
-    section = matrix_match.group(1)
-
-    # Patron de ID de caso. Acepta tanto el clasico "TC-F1-001" como el V7.8
-    # "[FEATURE]-[NIVEL]-NNN" (ej. CLI-INT-001, ASO-INTX-001, VNT-E2EX-001).
-    case_id_re = re.compile(r'^[A-Z][A-Z0-9]+-[A-Z0-9]+-\d+$')
-
-    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 ID de caso valido
-        if not case_id_re.match(cols[0]):
-            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))
+    story_ids = {s.story_id for s in stories}
 
-    return mapping
+    def norm(sid):
+        m = re.search(r'(\d+\.\d+)', sid)
+        return m.group(1) if m else sid
 
+    norm_index = {norm(sid): sid for sid in story_ids}
 
-def parse_traceability(content: str, feature_code: str) -> dict:
-    """Extrae mapping Story → TCs desde el Apéndice de Trazabilidad.
-
-    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
@@ -605,27 +438,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
@@ -944,7 +774,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", "?")}')
@@ -1544,14 +1374,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
         """,
     )
@@ -1564,7 +1394,7 @@ 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('--state-dir', default=None,
@@ -1584,25 +1414,26 @@ Ejemplos:
         print(f'  ERROR: Archivo no encontrado: {input_path}')
         sys.exit(1)
 
-    # Leer archivo completo
-    print(f'Parseando: {os.path.basename(input_path)}')
-    with open(input_path, 'r', encoding='utf-8') as f:
-        content = f.read()
+    # Cargar el test-design.yml (V7.8) via yaml.safe_load
+    print(f'Cargando YAML: {os.path.basename(input_path)}')
+    design = load_design(input_path)
 
-    # Parsear metadata
-    meta = parse_metadata(content)
+    # 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

package/siesa-agents/scripts/playwright/yaml-to-playwright-spec.ts

@@ -1,195 +1,203 @@
-/**
- * yaml-to-playwright-spec.ts
- * Convierte test-design YAML (fuente única de verdad) al formato Markdown
- * que espera el Playwright Test Generator Agent.
- *
- * Uso:
- *   npx ts-node tools/yaml-to-playwright-spec.ts <yaml-file> [--parte P3] [--output specs/plan.md]
- *
- * Si no se indica --parte, convierte todas las partes.
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import * as yaml from 'js-yaml';
-
-interface Paso {
-  paso: number;
-  parte: string;
-  nombre: string;
-  accion: string;
-  resultado: string;
-  datos?: string;
-  automatizado?: boolean;
-}
-
-interface TestDesignYaml {
-  metadata: {
-    modulo: string;
-    version: string;
-    autor: string;
-    fecha: string;
-    stack: string;
-  };
-  requisito: {
-    id: string;
-    nombre: string;
-    descripcion: string;
-  };
-  plan_pruebas: {
-    id: string;
-    nombre: string;
-    objetivo: string;
-    ambientes: Array<{ nombre: string; url: string; usuario: string }>;
-    precondiciones: string[];
-    framework: string;
-  };
-  caso_prueba: {
-    id: string;
-    nombre: string;
-    prioridad: string;
-    tipo: string;
-    pasos: Paso[];
-  };
-}
-
-function parseArgs(args: string[]): { yamlFile: string; parte: string | null; output: string | null } {
-  const yamlFile = args[0];
-  if (!yamlFile) {
-    console.error('Uso: npx ts-node tools/yaml-to-playwright-spec.ts <yaml-file> [--parte P3] [--output specs/plan.md]');
-    process.exit(1);
-  }
-
-  let parte: string | null = null;
-  let output: string | null = null;
-
-  for (let i = 1; i < args.length; i++) {
-    if (args[i] === '--parte' && args[i + 1]) {
-      parte = args[++i].toUpperCase();
-    } else if (args[i] === '--output' && args[i + 1]) {
-      output = args[++i];
-    }
-  }
-
-  return { yamlFile, parte, output };
-}
-
-function groupByParte(pasos: Paso[]): Map<string, Paso[]> {
-  const groups = new Map<string, Paso[]>();
-  for (const paso of pasos) {
-    const key = paso.parte;
-    if (!groups.has(key)) groups.set(key, []);
-    groups.get(key)!.push(paso);
-  }
-  return groups;
-}
-
-function parteLabel(parte: string, pasos: Paso[]): string {
-  const labels: Record<string, string> = {
-    P3: 'Datos Personales',
-    P4: 'Contacto e Información Personal',
-    P5: 'Formación',
-    P6: 'Experiencia Laboral',
-    P7: 'Activos y Pasivos',
-    P8: 'Datos Adicionales',
-  };
-  return labels[parte] || `Parte ${parte}`;
-}
-
-function generateMarkdown(data: TestDesignYaml, filterParte: string | null): string {
-  const lines: string[] = [];
-  const allPasos = data.caso_prueba.pasos;
-  const groups = groupByParte(allPasos);
-
-  // Header
-  lines.push(`# ${data.plan_pruebas.nombre}`);
-  lines.push('');
-  lines.push(`> ${data.plan_pruebas.objetivo.trim()}`);
-  lines.push('');
-  lines.push(`**Módulo:** ${data.metadata.modulo}  `);
-  lines.push(`**Stack:** ${data.metadata.stack}  `);
-  lines.push(`**Requisito:** ${data.requisito.id} — ${data.requisito.nombre}`);
-  lines.push('');
-
-  // Precondiciones
-  lines.push('## Precondiciones');
-  for (const pre of data.plan_pruebas.precondiciones) {
-    lines.push(`- ${pre}`);
-  }
-  lines.push('');
-
-  // Ambiente
-  const env = data.plan_pruebas.ambientes[0];
-  lines.push('## Ambiente');
-  lines.push(`- **URL:** ${env.url}`);
-  lines.push(`- **Usuario:** ${env.usuario}`);
-  lines.push('');
-
-  // Seed
-  lines.push(`**Seed:** \`tests/seed.spec.ts\``);
-  lines.push('');
-
-  // Partes
-  let sectionNum = 0;
-  for (const [parte, pasos] of groups) {
-    if (filterParte && parte !== filterParte) continue;
-
-    sectionNum++;
-    const label = parteLabel(parte, pasos);
-    lines.push(`## ${sectionNum}. ${label} (${parte})`);
-    lines.push('');
-
-    let stepInSection = 0;
-    for (const paso of pasos) {
-      stepInSection++;
-      lines.push(`### ${sectionNum}.${stepInSection} ${paso.nombre}`);
-      lines.push('');
-      lines.push('**Steps:**');
-
-      // Descomponer la acción en sub-pasos si contiene "+"
-      const subActions = paso.accion.split(/\s*\+\s*/);
-      let stepCounter = 1;
-      for (const sub of subActions) {
-        lines.push(`${stepCounter}. ${sub.trim()}`);
-        stepCounter++;
-      }
-
-      if (paso.datos) {
-        lines.push(`${stepCounter}. **Datos:** ${paso.datos}`);
-      }
-
-      lines.push('');
-      lines.push(`**Expected:** ${paso.resultado}`);
-      lines.push('');
-    }
-  }
-
-  return lines.join('\n');
-}
-
-// --- Main ---
-const args = process.argv.slice(2);
-const { yamlFile, parte, output } = parseArgs(args);
-
-const yamlContent = fs.readFileSync(yamlFile, 'utf-8');
-const data = yaml.load(yamlContent) as TestDesignYaml;
-
-const markdown = generateMarkdown(data, parte);
-
-// Determinar archivo de salida
-const defaultName = parte
-  ? `portal-empleo-${parte.toLowerCase()}.plan.md`
-  : 'portal-empleo-completo.plan.md';
-const outFile = output || path.join('specs', defaultName);
-
-// Crear directorio si no existe
-const outDir = path.dirname(outFile);
-if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
-
-fs.writeFileSync(outFile, markdown, 'utf-8');
-console.log(`✅ Plan generado: ${outFile}`);
-console.log(`   Partes: ${parte || 'todas'}`);
-
-const allPasos = data.caso_prueba.pasos;
-const filtered = parte ? allPasos.filter(p => p.parte === parte) : allPasos;
-console.log(`   Pasos: ${filtered.length}`);
+/**
+ * yaml-to-playwright-spec.ts
+ * Convierte el test-design.yml (BMAD V7.8, fuente única de verdad) al formato Markdown
+ * que espera el Playwright Test Generator Agent.
+ *
+ * V7.8: la fuente es `test_matrix[]` (varios casos), cada uno con `steps[]` atómicos
+ * { paso, accion, resultado, datos }. (Antes V6.0 usaba `caso_prueba.pasos[].parte`.)
+ *
+ * Uso:
+ *   npx ts-node yaml-to-playwright-spec.ts <yaml-file> [--feature CLI] [--id CLI-INT-001] [--output specs/plan.md]
+ *
+ * Si no se indica --feature ni --id, convierte todos los casos del test_matrix.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'js-yaml';
+
+// ── Estructura V7.8 ────────────────────────────────────────────────
+interface Step {
+  paso: number;
+  accion: string;
+  resultado: string;
+  datos?: string;
+}
+
+interface TestCase {
+  id: string;
+  feature?: string;
+  epics?: string[] | string;
+  mode?: string;
+  level?: string;
+  interface_type?: string | null;
+  technique?: string;
+  scenario?: string;
+  preconditions?: string;
+  steps?: Step[];
+  expected_result?: string;
+  risk?: string;
+  priority?: string;
+}
+
+interface TestDesignYaml {
+  metadata?: {
+    project_name?: string;
+    methodology?: string;
+    mode?: string;
+    interface_type?: string | null;
+    generated_date?: string;
+  };
+  test_matrix?: TestCase[];
+}
+
+function parseArgs(args: string[]): { yamlFile: string; feature: string | null; id: string | null; output: string | null } {
+  const yamlFile = args[0];
+  if (!yamlFile) {
+    console.error('Uso: npx ts-node yaml-to-playwright-spec.ts <yaml-file> [--feature CLI] [--id CLI-INT-001] [--output specs/plan.md]');
+    process.exit(1);
+  }
+
+  let feature: string | null = null;
+  let id: string | null = null;
+  let output: string | null = null;
+
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] === '--feature' && args[i + 1]) {
+      feature = args[++i].toUpperCase();
+    } else if (args[i] === '--id' && args[i + 1]) {
+      id = args[++i].toUpperCase();
+    } else if (args[i] === '--output' && args[i + 1]) {
+      output = args[++i];
+    }
+  }
+
+  return { yamlFile, feature, id, output };
+}
+
+function epicsToText(epics: TestCase['epics']): string {
+  if (Array.isArray(epics)) return epics.join(', ');
+  return epics || '';
+}
+
+function filterCases(cases: TestCase[], feature: string | null, id: string | null): TestCase[] {
+  return cases.filter(tc => {
+    if (id && (tc.id || '').toUpperCase() !== id) return false;
+    if (feature && (tc.feature || '').toUpperCase() !== feature) return false;
+    return true;
+  });
+}
+
+function generateMarkdown(data: TestDesignYaml, cases: TestCase[]): string {
+  const lines: string[] = [];
+  const md = data.metadata || {};
+  const title = md.project_name ? `Plan de Pruebas — ${md.project_name}` : 'Plan de Pruebas';
+
+  // Header
+  lines.push(`# ${title}`);
+  lines.push('');
+  if (md.methodology) lines.push(`**Metodología:** ${md.methodology}  `);
+  if (md.mode) lines.push(`**Modo:** ${md.mode}  `);
+  if (md.generated_date) {
+    // js-yaml parsea fechas ISO sin comillas como Date; normalizar a YYYY-MM-DD.
+    const d: any = md.generated_date;
+    const dateStr = d instanceof Date ? d.toISOString().slice(0, 10) : String(d);
+    lines.push(`**Fecha:** ${dateStr}`);
+  }
+  lines.push('');
+  lines.push(`**Seed:** \`tests/seed-example.spec.ts\``);
+  lines.push('');
+  lines.push(`> ${cases.length} caso(s) de prueba a automatizar.`);
+  lines.push('');
+
+  // Una sección por caso de prueba
+  let sectionNum = 0;
+  for (const tc of cases) {
+    sectionNum++;
+    const prio = tc.priority ? ` [${tc.priority}]` : '';
+    lines.push(`## ${sectionNum}. ${tc.id}${prio} — ${tc.scenario || ''}`.trimEnd());
+    lines.push('');
+
+    const metaBits: string[] = [];
+    if (tc.feature) metaBits.push(`**Feature:** ${tc.feature}`);
+    if (tc.level) metaBits.push(`**Nivel:** ${tc.level}`);
+    if (tc.technique) metaBits.push(`**Técnica:** ${tc.technique}`);
+    if (tc.interface_type) metaBits.push(`**Interfaz:** ${tc.interface_type}`);
+    const epicsTxt = epicsToText(tc.epics);
+    if (epicsTxt) metaBits.push(`**Épicas:** ${epicsTxt}`);
+    if (metaBits.length) {
+      lines.push(metaBits.join(' · '));
+      lines.push('');
+    }
+
+    if (tc.preconditions) {
+      lines.push(`**Precondiciones:** ${tc.preconditions}`);
+      lines.push('');
+    }
+
+    // Steps atómicos V7.8
+    lines.push('**Steps:**');
+    const steps = tc.steps || [];
+    if (steps.length === 0) {
+      lines.push('1. _(sin pasos atómicos en el YAML)_');
+    } else {
+      for (const step of steps) {
+        const n = step.paso != null ? step.paso : '-';
+        let line = `${n}. ${(step.accion || '').trim()}`;
+        if (step.datos && String(step.datos).trim()) {
+          line += `  — _Datos:_ ${String(step.datos).trim()}`;
+        }
+        lines.push(line);
+        if (step.resultado && step.resultado.trim()) {
+          lines.push(`   - _Esperado del paso:_ ${step.resultado.trim()}`);
+        }
+      }
+    }
+    lines.push('');
+
+    if (tc.expected_result) {
+      lines.push(`**Expected (caso):** ${tc.expected_result}`);
+      lines.push('');
+    }
+  }
+
+  return lines.join('\n');
+}
+
+// --- Main ---
+const args = process.argv.slice(2);
+const { yamlFile, feature, id, output } = parseArgs(args);
+
+const yamlContent = fs.readFileSync(yamlFile, 'utf-8');
+const data = yaml.load(yamlContent) as TestDesignYaml;
+
+const allCases = data.test_matrix || [];
+if (allCases.length === 0) {
+  console.error('⚠️  El YAML no tiene `test_matrix[]` o está vacío. ¿Es un test-design.yml V7.8?');
+  process.exit(1);
+}
+
+const cases = filterCases(allCases, feature, id);
+if (cases.length === 0) {
+  console.error(`⚠️  Ningún caso coincide con el filtro (feature=${feature ?? 'todas'}, id=${id ?? 'todos'}).`);
+  process.exit(1);
+}
+
+const markdown = generateMarkdown(data, cases);
+
+// Determinar archivo de salida
+const projectSlug = (data.metadata?.project_name || 'test-design').toLowerCase().replace(/[^a-z0-9]+/g, '-');
+const filterSlug = id ? id.toLowerCase() : feature ? feature.toLowerCase() : 'completo';
+const defaultName = `${projectSlug}-${filterSlug}.plan.md`;
+const outFile = output || path.join('specs', defaultName);
+
+// Crear directorio si no existe
+const outDir = path.dirname(outFile);
+if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
+
+fs.writeFileSync(outFile, markdown, 'utf-8');
+console.log(`✅ Plan generado: ${outFile}`);
+console.log(`   Filtro: feature=${feature ?? 'todas'} | id=${id ?? 'todos'}`);
+console.log(`   Casos: ${cases.length}`);
+const totalSteps = cases.reduce((acc, tc) => acc + (tc.steps?.length || 0), 0);
+console.log(`   Steps atómicos: ${totalSteps}`);