# Sprint: Expansive Sample Variety

> **Versión:** 3.1 Expansive Architecture  
> **Fecha:** 2026-04-12  
> **Estado:** Diseño Completo / Pendiente Implementación  
> **Dependencias:** Senior Architecture v3.0

---

## 1. Overview

### Objetivo Principal

El sistema **Expansive Sample Variety** permite crear producciones musicales que utilizan **12 samples por categoría** (96 samples totales) manteniendo una **coherencia profesional ≥ 0.90**.

Este sprint resuelve el problema crítico de la monotonía en producciones generadas por IA, donde tracks suenan repetitivos por reutilizar los mismos samples. En lugar de 1 sample por rol durante toda la canción, el sistema Expansive distribuye 12 samples estratégicamente según el contexto musical, creando variación orgánica sin sacrificar cohesión.

### Métricas de Éxito

| Métrica | Valor Objetivo | Descripción |
|---------|----------------|-------------|
| Samples por Rol | 12 | Distintos samples por categoría (kick, snare, hihat, etc.) |
| Coherencia Global | ≥ 0.90 | Score de similitud espectral entre samples |
| Variación Temporal | Cada 4-8 barras | Cambio de sample según sección |
| QA Score | ≥ 95 | Validación post-producción |
| Total Samples | 96 | 8 roles × 12 samples cada uno |

---

## 2. Architecture

### 2.1 Diagrama de Arquitectura

```
┌─────────────────────────────────────────────────────────────────────────┐
│                   EXPANSIVE SAMPLE VARIETY ENGINE                        │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  ┌──────────────────┐  ┌──────────────────┐  ┌──────────────────┐         │
│  │ Sample Library   │  │ SectionSample    │  │ ExpansiveCoherence│        │
│  │ (511 samples)    │──│ Mapper            │──│ Validator         │        │
│  │                  │  │                   │  │                   │         │
│  └──────────────────┘  └──────────────────┘  └──────────────────┘         │
│          │                      │                      │                   │
│          ▼                      ▼                      ▼                   │
│  ┌──────────────────┐  ┌──────────────────┐  ┌──────────────────┐         │
│  │ RoleStrategy     │  │ MultiSampleInjector│  │ VariationController│        │
│  │ (8 roles)        │──│                   │──│                   │        │
│  │                  │  └──────────────────┘  └──────────────────┘         │
│  └──────────────────┘            │                      │                   │
│          │                        │                      │                   │
│          ▼                        ▼                      ▼                   │
│  ┌──────────────────────────────────────────────────────────────────┐      │
│  │                    Ableton Live Arrangement                      │      │
│  │                  (96 clips distribuidos)                        │      │
│  └──────────────────────────────────────────────────────────────────┘      │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘
```

### 2.2 Componentes Principales

#### 2.2.1 SectionSampleMapper

**Responsabilidad:** Asigna samples a secciones musicales según progresión coherente.

```python
class SectionSampleMapper:
    """
    Mapea 12 samples a 4 secciones principales:
    - Intro: samples[0-2] (3 samples)
    - Verse: samples[3-6] (4 samples)
    - Chorus: samples[7-10] (4 samples)
    - Bridge: samples[10-11] (2 samples)
    """
    
    def map_samples_to_sections(
        self,
        samples: List[Sample],
        section_config: SectionConfiguration
    ) -> SectionMapping:
        """
        Retorna mapeo optimizado con transiciones suaves.
        """
```

**Características:**
- Validación de compatibilidad entre samples adyacentes
- Transiciones cross-fade entre cambios
- Soporte para sub-secciones (A/B verse)
- Fallback a sample anterior si coherencia baja

#### 2.2.2 ExpansiveCoherenceValidator

**Responsabilidad:** Valida que 12 samples mantengan coherencia ≥ 0.90 entre sí.

```python
class ExpansiveCoherenceValidator:
    """
    Valida coherencia de un grupo de 12 samples.
    
    Métricas validadas:
    - Coherencia por pares (mínima entre samples adyacentes)
    - Coherencia global (promedio de todas las combinaciones)
    - Coherencia espectral (MFCCs promedio)
    - Coherencia temporal (ataque, sustain, release)
    """
    
    THRESHOLD_PAIR = 0.85      # Mínimo entre samples consecutivos
    THRESHOLD_GLOBAL = 0.90    # Promedio del grupo completo
    THRESHOLD_SPECTRAL = 0.88  # Similaridad espectral
    
    def validate_group(
        self,
        samples: List[Sample],
        role: str  # "kick", "snare", etc.
    ) -> CoherenceReport:
        """
        Retorna reporte con score y recomendaciones.
        """
```

**Algoritmo de Validación:**

1. **Extracción de Features:** MFCCs, spectral centroid, attack time, RMS
2. **Matriz de Similitud:** Calcula similitud entre cada par de samples
3. **Coherencia por Pares:** Evalúa transiciones entre samples consecutivos
4. **Coherencia Global:** Promedio de todas las combinaciones posibles
5. **Reporte:** Score numérico + diagnóstico de problemas

#### 2.2.3 MultiSampleInjector

**Responsabilidad:** Inyecta múltiples samples en Arrangement View según estrategia de rol.

```python
class MultiSampleInjector:
    """
    Inyecta samples en Ableton Live con timing preciso.
    
    Soporta 7 estrategias de inyección:
    - round_robin: Cambia sample cada N barras
    - pattern_based: Samples según patrón rítmico
    - layered: 2-3 samples simultáneos
    - section_based: Un sample por sección
    - random_coherent: Aleatorio con constraints
    - velocity_based: Sample según velocity
    - fill_based: Samples especiales en fills
    """
    
    def inject_with_strategy(
        self,
        track_index: int,
        samples: List[Sample],
        strategy: InjectionStrategy,
        arrangement_length_bars: int
    ) -> InjectionReport:
        """
        Crea clips en Arrangement según estrategia.
        """
```

**Métodos de Inyección (Live 12+):**

1. `track.insert_arrangement_clip()` - Clip directo en timeline
2. `track.create_audio_clip()` - Clip con warp markers
3. `arrangement_clips.add_new_clip()` - API oficial Live 12
4. Múltiple clips con diferentes fuentes en mismo track

#### 2.2.4 VariationController

**Responsabilidad:** Gestiona la lógica de variación y evita repetitividad.

```python
class VariationController:
    """
    Controla cuándo y cómo cambiar samples.
    
    Features:
    - Fatiga detection: Evita usar el mismo sample demasiado
    - Energy mapping: Samples más intensos en choruses
    - Smooth transitions: Cross-fade entre cambios
    - Context awareness: Considera elementos simultáneos
    """
    
    FATIGUE_THRESHOLD = 8  # Cambiar después de 8 repeticiones
    
    def should_change_sample(
        self,
        current_sample: Sample,
        playhead_bar: int,
        section_type: str,
        energy_level: float
    ) -> Optional[Sample]:
        """
        Determina si debe cambiar al siguiente sample.
        Retorna nuevo sample o None si mantiene actual.
        """
```

---

## 3. Strategies by Role

### 3.1 Estrategia Combinada

Cada rol utiliza una estrategia optimizada para sus características:

| Rol | Estrategia | Sample Count | Variación | Descripción |
|-----|------------|--------------|-----------|-------------|
| **Kick** | Round-robin | 12 | Cada 4 barras | Cambio cíclico manteniendo groove |
| **Snare** | Pattern-based | 12 | Dembow + fills | 1 sample base + fills aleatorios |
| **HiHat** | Layered | 12 | 2-3 simultáneos | Capas de closed, open, ghost |
| **Bass** | Section-based | 12 | Por sección | 1 sample por sección musical |
| **Perc** | Random coherent | 12 | Aleatorio con constraints | Variación controlada por coherencia |
| **FX** | Section-based | 12 | Por sección | Risers, impacts según contexto |
| **Chords** | Section-based | 12 | Por sección | Progresiones cambian por sección |
| **Melody** | Section-based | 12 | Por sección | Motivos evolucionan por sección |

### 3.2 Detalle por Estrategia

#### 3.2.1 Kick - Round-Robin

```python
class KickRoundRobinStrategy:
    """
    Cambia kick cada 4 barras (1 compás del dembow).
    
    Pattern:
    - Bar 0-3: Sample 0
    - Bar 4-7: Sample 1
    - Bar 8-11: Sample 2
    - ...continúa cíclicamente...
    
    Coherencia: Samples seleccionados para tener
    attack time y sub-bass frequency similares.
    """
    
    BARS_PER_SAMPLE = 4
    TOTAL_SAMPLES = 12
    
    def get_sample_for_bar(self, bar: int) -> Sample:
        index = (bar // self.BARS_PER_SAMPLE) % self.TOTAL_SAMPLES
        return self.samples[index]
```

**Coherence Requirements:**
- Attack time variance < 5ms entre samples
- Sub-bass frequency (50-80Hz) ±2dB
- Transient consistency > 0.88

#### 3.2.2 Snare - Pattern-Based

```python
class SnarePatternStrategy:
    """
    Combina sample base con fills variados.
    
    Pattern:
    - Beats estándar (2, 4, 6, 8...): Sample base (índices 0-2)
    - Fills (último compás de cada 8): Samples 3-11
    
    Dembow Pattern:
    - Snare en 2.25, 4.25 (clásico)
    - Ghost notes con samples 6-8
    - Accents con samples 9-11
    """
    
    BASE_SAMPLES = 3      # samples[0-2]
    FILL_SAMPLES = 9      # samples[3-11]
    FILL_BARS = [7, 15, 23, 31]  # Cada 8 compases
```

**Distribución de 12 Samples:**

| Índice | Uso | Timing | Intensidad |
|--------|-----|--------|------------|
| 0-2 | Base | Beats 2 y 4 | Standard |
| 3-5 | Fill corto | Último 1/4 de compás | Medium |
| 6-8 | Ghost notes | Off-beats | Low |
| 9-11 | Accents | Beats fuertes | High |

#### 3.2.3 HiHat - Layered

```python
class HiHatLayeredStrategy:
    """
    Superposición de 2-3 hihats simultáneos.
    
    Capas:
    - Layer 1 (Closed): Samples 0-3 - Base 16th notes
    - Layer 2 (Open): Samples 4-7 - Accents en off-beats
    - Layer 3 (Ghost): Samples 8-11 - Fills y variaciones
    
    Timing: Cada capa tiene su propio pattern rítmico.
    """
    
    LAYERS = {
        'closed': {'samples': [0, 1, 2, 3], 'velocity': 100},
        'open': {'samples': [4, 5, 6, 7], 'velocity': 80},
        'ghost': {'samples': [8, 9, 10, 11], 'velocity': 60}
    }
```

**Arquitectura de Tracks:**

```
Track 3: HiHat Layered
├── Clip 0: Closed hihat (bars 0-4)
├── Clip 1: Open hihat overlay (bars 0-4)  
├── Clip 2: Ghost hihat overlay (bars 0-4)
├── Clip 3: Closed variation (bars 4-8)
└── ... (continúa)
```

#### 3.2.4 Bass - Section-Based

```python
class BassSectionStrategy:
    """
    Un sample de bass por sección musical.
    
    Mapeo:
    - Intro: Sample 0
    - Verse A: Sample 1
    - Verse B: Sample 2
    - Pre-chorus: Sample 3
    - Chorus: Samples 4-5 (alterna cada 4 barras)
    - Bridge: Sample 6
    - Outro: Sample 7
    
    Nota: Solo 8 de 12 samples usados en estructura estándar.
    Los samples 8-11 son reservas para extended versions.
    """
    
    SECTION_MAP = {
        'intro': 0,
        'verse_a': 1,
        'verse_b': 2,
        'pre_chorus': 3,
        'chorus_1': 4,
        'chorus_2': 5,
        'bridge': 6,
        'outro': 7
    }
```

**Criterio de Selección por Sección:**

| Sección | Característica Buscar | Sample Prioridad |
|---------|----------------------|------------------|
| Intro | Sub-bass profundo | 0 |
| Verse | Balance low-mid | 1-2 |
| Chorus | Más armónicos, presente | 4-5 |
| Bridge | Contraste, diferente | 6 |

#### 3.2.5 Perc - Random with Coherence

```python
class PercRandomStrategy:
    """
    Selección aleatoria con restricciones de coherencia.
    
    Rules:
    1. No repetir sample hasta que se usen 4 otros
    2. Coherencia con sample anterior ≥ 0.85
    3. Densidad controlada por sección (intro: baja, chorus: alta)
    4. Considerar samples simultáneos de otros roles
    """
    
    MIN_COHERENCE = 0.85
    REPETITION_COOLDOWN = 4  # Samples antes de repetir
    
    def select_next_sample(
        self,
        previous: Sample,
        used_recently: Set[int],
        section_type: str
    ) -> Sample:
        # Filtra por coherencia
        candidates = [s for s in self.samples 
                     if s.id not in used_recently
                     and self.coherence(s, previous) >= MIN_COHERENCE]
        # Selección aleatoria de candidatos válidos
        return random.choice(candidates)
```

#### 3.2.6 FX - Section-Based

```python
class FXSectionStrategy:
    """
    FX especializados por tipo de sección.
    
    Categorías de FX:
    - Risers (samples 0-3): Builds, transitions
    - Impacts (samples 4-6): Drops, acentos
    - Downlifters (samples 7-9): Post-chorus
    - Atmósfera (samples 10-11): Ambient
    """
    
    FX_TYPES = {
        'riser': {'indices': [0, 1, 2, 3], 'sections': ['pre_chorus', 'build']},
        'impact': {'indices': [4, 5, 6], 'sections': ['chorus', 'drop']},
        'downlifter': {'indices': [7, 8, 9], 'sections': ['post_chorus', 'outro']},
        'atmosphere': {'indices': [10, 11], 'sections': ['intro', 'breakdown']}
    }
```

---

## 4. Section Mapping

### 4.1 Distribución de 12 Samples por Sección

```
Índice:    0   1   2   3   4   5   6   7   8   9   10  11
           │   │   │   │   │   │   │   │   │   │   │   │
           ▼   ▼   ▼   ▼   ▼   ▼   ▼   ▼   ▼   ▼   ▼   ▼
Sección:  [  INTRO  ] [    VERSE    ] [   CHORUS    ][BRIDGE]
           │       │   │           │   │           │   │
Barras:    0-4    4-8  8-16       16-24 24-32      32-40 40-48
           │       │   │           │   │           │   │
Intensidad: Low    ▶   Medium      ▶   High        ▶   Medium
```

### 4.2 Tabla de Mapeo Detallado

| Sample Index | Sección | Sub-Sección | Uso Principal | Duración |
|--------------|---------|-------------|---------------|----------|
| 0 | Intro | A | Establecer atmósfera | 4 barras |
| 1 | Intro | B | Build inicial | 4 barras |
| 2 | Intro/Verse | Transición | Puente a verse | 2 barras |
| 3 | Verse | A1 | Tema principal | 4 barras |
| 4 | Verse | A2 | Variación leve | 4 barras |
| 5 | Verse | B1 | Contraste | 4 barras |
| 6 | Verse/Pre | Transición | Build a chorus | 2 barras |
| 7 | Chorus | A1 | Tema peak | 4 barras |
| 8 | Chorus | A2 | Variación energy | 4 barras |
| 9 | Chorus | B | Hook máximo | 2 barras |
| 10 | Chorus/Bridge | Transición | Salida chorus | 2 barras |
| 11 | Bridge | - | Resolución | 4 barras |

### 4.3 Coherencia entre Secciones Adyacentes

```
Coherencia Requerida entre Samples Consecutivos:

Intro[2] ──0.90──▶ Verse[3] ──0.88──▶ Verse[4] ──0.85──▶ ...
   │                  │                  │
   ▼                  ▼                  ▼
Transición        Variación           Contraste
(suave)           (moderada)          (notable)

Mínimo aceptable: 0.85 entre cualquier par consecutivo
Objetivo: 0.90+ promedio global
```

### 4.4 Cross-Fade Configuration

| Transición | Tipo de Cross-Fade | Duración | Curva |
|------------|-------------------|----------|-------|
| Intro → Verse | Fade in nuevo | 1 beat | S-curve |
| Verse → Chorus | Overlap | 2 beats | Linear |
| Chorus → Bridge | Cut + fade | 1 beat | Exponential |
| Bridge → Outro | Fade out viejo | 2 beats | S-curve |

---

## 5. Usage Example

### 5.1 Tool Principal: `generate_expansive_track()`

```python
ableton-live-mcp_generate_expansive_track(
    # Configuración básica
    genre="reggaeton",
    tempo=95,
    key="Am",
    style="perreo",
    
    # Estructura de canción
    structure="verse-chorus-extended",
    duration_bars=64,
    
    # Configuración Expansive
    samples_per_role=12,           # 12 samples por categoría
    coherence_threshold=0.90,     # Mínimo de coherencia
    variation_level="high",       # low | medium | high
    
    # Estrategias por rol (auto-detectadas si no se especifican)
    strategies={
        "kick": "round_robin",
        "snare": "pattern_based",
        "hihat": "layered",
        "bass": "section_based",
        "perc": "random_coherent",
        "fx": "section_based",
        "chords": "section_based",
        "melody": "section_based"
    },
    
    # Opciones adicionales
    auto_mix=True,                # Aplicar mezcla profesional
    include_vocal_placeholder=True,
    save_as_preset=True,
    preset_name="Expansive_001"
)
```

### 5.2 Respuesta Esperada

```json
{
  "status": "success",
  "expansive_track_id": "exp_20260412_001",
  
  "samples_used": {
    "kick": {
      "count": 12,
      "strategy": "round_robin",
      "coherence_score": 0.93,
      "files": [
        "libreria/reggaeton/kick/kick_deep_01.wav",
        "libreria/reggaeton/kick/kick_punchy_03.wav",
        ...
      ]
    },
    "snare": {
      "count": 12,
      "strategy": "pattern_based",
      "coherence_score": 0.91,
      "base_samples": 3,
      "fill_samples": 9
    },
    "hihat": {
      "count": 12,
      "strategy": "layered",
      "coherence_score": 0.92,
      "layers_active": 3,
      "simultaneous_clips": 36
    },
    "bass": {
      "count": 8,  # 4 de 12 no usados en estructura estándar
      "strategy": "section_based",
      "coherence_score": 0.94
    },
    "perc": {
      "count": 12,
      "strategy": "random_coherent",
      "coherence_score": 0.89,
      "variations_generated": 24
    },
    "fx": {
      "count": 12,
      "strategy": "section_based",
      "coherence_score": 0.90
    }
  },
  
  "arrangement": {
    "total_clips": 96,
    "total_bars": 64,
    "sections": [
      {"type": "intro", "bars": "0-8", "samples_per_role": 3},
      {"type": "verse", "bars": "8-24", "samples_per_role": 4},
      {"type": "chorus", "bars": "24-40", "samples_per_role": 4},
      {"type": "bridge", "bars": "40-48", "samples_per_role": 2},
      {"type": "outro", "bars": "48-56", "samples_per_role": 2}
    ]
  },
  
  "coherence_validation": {
    "global_score": 0.915,
    "pair_minimum": 0.86,
    "passed": true,
    "warnings": []
  },
  
  "mixing": {
    "bus_architecture": true,
    "parallel_compression": true,
    "master_chain": true,
    "sidechains_configured": 4
  },
  
  "qa_score": 97,
  "preset_saved": "Expansive_001",
  "render_path": null  # No render automático
}
```

### 5.3 Workflow Completo

```python
# Paso 1: Health check
ableton-live-mcp_health_check

# Paso 2: Generar track expansivo
ableton-live-mcp_generate_expansive_track \
    --genre "reggaeton" \
    --tempo 95 \
    --key "Am" \
    --style "perreo" \
    --samples_per_role 12 \
    --coherence_threshold 0.90 \
    --variation_level "high" \
    --auto_mix true

# Paso 3: Verificar coherencia
ableton-live-mcp_validate_project

# Paso 4: Quality check
ableton-live-mcp_full_quality_check

# Paso 5: Export
ableton-live-mcp_export_project \
    --path "C:\\Users\\Usuario\\Music\\ExpansiveTrack_001.wav"
```

---

## 6. Metrics

### 6.1 Métricas de Éxito del Sprint

| Categoría | Métrica | Mínimo | Objetivo | Máximo |
|-----------|---------|--------|----------|--------|
| **Cantidad** | Samples por rol | 10 | 12 | 16 |
| **Cantidad** | Total de samples | 80 | 96 | 128 |
| **Coherencia** | Score global | 0.88 | 0.90 | 0.95 |
| **Coherencia** | Mínimo por par | 0.85 | 0.88 | 0.90 |
| **Calidad** | QA Score | 90 | 95 | 98 |
| **Performance** | Tiempo de generación | 60s | 45s | 30s |
| **Variación** | Cambios por rol | 6 | 8 | 12 |

### 6.2 Reporte de QA

```python
class ExpansiveQAReport:
    """
    Reporte de calidad post-generación.
    """
    
    def generate_report(self) -> dict:
        return {
            "sample_count_validation": {
                "expected": 96,
                "actual": 96,
                "status": "PASS"
            },
            "coherence_validation": {
                "global_score": 0.915,
                "threshold": 0.90,
                "status": "PASS"
            },
            "arrangement_validation": {
                "total_clips": 96,
                "gaps_detected": 0,
                "overlaps": 0,
                "status": "PASS"
            },
            "mixing_validation": {
                "bus_routing": "complete",
                "sidechain_active": True,
                "master_chain": "applied",
                "status": "PASS"
            },
            "overall_qa_score": 97,
            "recommendations": []
        }
```

### 6.3 Validación de Coherencia

```
Proceso de Validación:

1. Pre-Selección:
   └── Filtra 12 samples del pool de 511
   └── Criterio: Coherencia mínima 0.85 entre todos

2. Section Mapping:
   └── Asigna samples a secciones
   └── Valida transiciones adyacentes ≥ 0.85

3. Injection Strategy:
   └── Aplica estrategia específica por rol
   └── Verifica timing y overlap

4. Post-Validation:
   └── Analiza clips creados en Arrangement
   └── Calcula coherencia real vs esperada
   └── Reporta discrepancias
```

### 6.4 Thresholds de Aceptación

| Validación | Condición | Acción si Falla |
|------------|-----------|-----------------|
| Global Coherence | ≥ 0.90 | Re-seleccionar samples |
| Pair Coherence | ≥ 0.85 | Ajustar mapeo de secciones |
| QA Score | ≥ 95 | Re-generar con diferentes seeds |
| Sample Count | 96 exactos | Reportar error crítico |
| Arrangement Gaps | 0 gaps permitidos | Auto-rellenar con sample coherente |

---

## 7. Implementación

### 7.1 Fases de Desarrollo

| Fase | Componentes | Tiempo Est. | Dependencias |
|------|-------------|-------------|--------------|
| 1 | SectionSampleMapper | 2 días | Senior Architecture v3.0 |
| 2 | ExpansiveCoherenceValidator | 3 días | metadata_store.py |
| 3 | MultiSampleInjector | 2 días | live_bridge.py |
| 4 | VariationController | 2 días | sample_selector.py |
| 5 | Role Strategies | 3 días | Fases 1-4 |
| 6 | Integration & Testing | 2 días | Fases 1-5 |

**Total Estimado:** 14 días de desarrollo

### 7.2 Files a Crear/Modificar

```
AbletonMCP_AI/mcp_server/engines/
├── expansive/
│   ├── __init__.py
│   ├── section_sample_mapper.py      # NEW
│   ├── expansive_coherence_validator.py  # NEW
│   ├── multi_sample_injector.py       # NEW
│   ├── variation_controller.py        # NEW
│   └── strategies/
│       ├── __init__.py
│       ├── kick_round_robin.py        # NEW
│       ├── snare_pattern.py          # NEW
│       ├── hihat_layered.py           # NEW
│       ├── bass_section.py           # NEW
│       ├── perc_random.py            # NEW
│       ├── fx_section.py             # NEW
│       └── base_strategy.py           # NEW

AbletonMCP_AI/mcp_server/
├── server.py                         # MODIFY - Add tool
└── integration.py                    # MODIFY - Wire engines
```

### 7.3 API Tool Nueva

```python
@mcp.tool()
async def generate_expansive_track(
    genre: str = "reggaeton",
    tempo: int = 95,
    key: str = "Am",
    style: str = "perreo",
    structure: str = "verse-chorus",
    duration_bars: int = 64,
    samples_per_role: int = 12,
    coherence_threshold: float = 0.90,
    variation_level: str = "medium",  # low | medium | high
    strategies: Optional[Dict[str, str]] = None,
    auto_mix: bool = True,
    include_vocal_placeholder: bool = True,
    save_as_preset: bool = True,
    preset_name: Optional[str] = None
) -> str:
    """
    Genera track con 12 samples por rol manteniendo coherencia ≥ 0.90.
    """
```

---

## 8. Relacionado

- `PROFESSIONAL_WORKFLOW.md` - Flujo profesional completo
- `skill_produccion_audio.md` - Skill de producción detallada
- `API_REFERENCE_PRO.md` - Referencia completa de tools

---

## Historial

- **v0.1** (2026-04-12): Documentación de diseño del sprint Expansive Sample Variety
