feat: upload PAMPAr-Coder code and documentation

.cursorrules

@@ -0,0 +1,226 @@
+# PAMPAr-Coder — AI Instructions
+
+> Consolidación de instrucciones para Cursor/Copilot en el proyecto PAMPAr-Coder.
+> "El Linux de la IA" - LLM de código con arquitectura cerebral.
+
+---
+
+## Proyecto
+
+**PAMPAr-Coder** es un LLM de código 1.5B-3B con arquitectura inspirada en las 52 zonas de Brodmann.
+
+### Quick Reference
+
+| Area | Convention |
+|------|------------|
+| Language | Python 3.13+ |
+| Framework | PyTorch 2.x |
+| Tokenizer | SentencePiece BPE — 16K vocab (modelo activo) |
+| Testing | pytest (134 tests) |
+| Type hints | Siempre requeridos |
+| Docstrings | Google style |
+| Training | local — GPU 4GB VRAM (NO cloud, NO RunPod) |
+
+---
+
+## Arquitectura Cerebral
+
+```
+Input → Embedding → [BloqueTerrritorial ×N] → LM Head → Output
+                          ↓
+              TálamoBrodmann (LLAVES 80% + Atención 20%)
+              + Conv1D causal (ventana 32 tokens)
+                          ↓
+    ┌─────────────────────┴─────────────────────┐
+    ▼                                           ▼
+┌───────────────┐                    ┌───────────────┐
+│   SINTAXIS    │◄── simbiosis ────►│   SEMÁNTICA   │
+│  Zonas 1-15   │                    │  Zonas 16-30  │
+└───────────────┘                    └───────────────┘
+    ▼                                           ▼
+┌───────────────┐                    ┌───────────────┐
+│    LÓGICO     │◄── simbiosis ────►│ ESTRUCTURAL   │
+│  Zonas 31-42  │                    │  Zonas 43-52  │
+└───────────────┘                    └───────────────┘
+```
+
+### Sistema LLAVES (80% del peso)
+
+Las LLAVES son **patrones regex que clasifican tokens en zonas de Brodmann**:
+
+```python
+# CRÍTICO: LLAVES son regex, NUNCA entrenables
+LLAVES = {
+    'B06_KEYWORDS_IMPORT': ['import', 'from', 'require'],
+    'B17_LITERAL_STRING': [r'".*"', r"'.*'", 'f"'],
+    'B35_IDENTIFICADOR_VAR': [r'[a-z_][a-z0-9_]*'],
+    # ... 52 zonas total
+}
+# INT8 cuantizado (256 niveles, <0.4% error)
+```
+
+### 4 Territorios
+
+| Territorio   | Zonas   | Responsabilidad           |
+| ------------ | ------- | ------------------------- |
+| SINTAXIS     | 1-15    | Estructura, indentación   |
+| SEMÁNTICA    | 16-30   | Significado, contexto     |
+| LÓGICO       | 31-42   | Flujo, condiciones        |
+| ESTRUCTURAL  | 43-52   | Arquitectura, módulos     |
+
+---
+
+## Estructura del Proyecto
+
+```
+PAMPAr-Coder/
+├── pampar/coder/v2/
+│   ├── modelo.py          # PampaRCoderV2 principal
+│   ├── config.py          # ConfigV2 + presets (PRESET_4GB, PRESET_8GB)
+│   ├── talamo.py          # TálamoBrodmann orquestador
+│   ├── llaves.py          # LLAVES INT8 lookup tables
+│   ├── zonas.py           # 52 zonas de Brodmann
+│   ├── bloques.py         # BloqueTerritorial + FFN simbiótico
+│   └── aprendizaje/       # Subsistemas de aprendizaje
+├── biblioteca/            # 39 temas de Python (~140 MB), lista para entrenar
+├── data/                  # Datos y tokenizer
+├── checkpoints/           # pampar_v2_best.pt (42M params, vocab 16K)
+├── scripts/               # Scripts utilidad (aprender_solo.py, etc.)
+└── tests/                 # 134 tests pytest
+```
+
+---
+
+## Reglas Críticas
+
+1. **LLAVES son regex** — NUNCA entrenarlas
+2. **Territorios en paralelo** — combinan via soporte simbiótico
+3. **INT8 para LLAVES** — lookup tables cuantizadas (256 niveles)
+4. **Pesos en FP16/BF16** — nunca INT8
+5. **Gradient checkpointing** — obligatorio para >500M params
+6. **vocab_size = 16000** — debe coincidir con el tokenizer activo (`code_tokenizer.model`)
+7. **Ventana contexto = 32** — convolución causal, pad izquierdo
+
+---
+
+## Convenciones de Código
+
+### Naming
+
+| Tipo | Convención | Ejemplo |
+|------|------------|---------|
+| Dominio | Español | `Talamo`, `MemoriaErrores` |
+| ML estándar | Inglés | `forward`, `hidden_states` |
+| Config | `Config` + nombre | `ConfigPampaRCoderV2` |
+| Presets | `PRESET_` + capacidad | `PRESET_4GB` |
+
+### Type Hints (OBLIGATORIO)
+
+```python
+def forward(
+    self,
+    input_ids: Tensor,
+    attention_mask: Optional[Tensor] = None,
+    labels: Optional[Tensor] = None,
+) -> Tuple[Tensor, Optional[Tensor]]:
+    """Forward pass del modelo."""
+    ...
+```
+
+### Docstrings (Google Style)
+
+```python
+class PampaRCoderV2(nn.Module):
+    """
+    Modelo principal PAMPAr-Coder V2.
+
+    Attributes:
+        config: Configuración del modelo.
+        embedding: Capa de embedding.
+
+    Example:
+        >>> model = crear_modelo(PRESET_4GB)
+    """
+```
+
+---
+
+## Patrones PyTorch
+
+### Training Loop
+
+```python
+from torch.cuda.amp import autocast, GradScaler
+
+scaler = GradScaler()
+for batch in dataloader:
+    with autocast(dtype=torch.bfloat16):
+        loss = model(**batch).loss / accumulation_steps
+    
+    scaler.scale(loss).backward()
+    
+    if (step + 1) % accumulation_steps == 0:
+        scaler.unscale_(optimizer)
+        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+        scaler.step(optimizer)
+        scaler.update()
+        optimizer.zero_grad()
+```
+
+### Checkpoint
+
+```python
+torch.save({
+    "model_state_dict": model.state_dict(),
+    "optimizer_state_dict": optimizer.state_dict(),
+    "epoch": epoch,
+    "loss": loss,
+}, "checkpoint.pt")
+```
+
+---
+
+## Testing (pytest)
+
+```python
+@pytest.fixture
+def small_config():
+    return ConfigPampaRCoderV2(
+        vocab_size=1000, hidden_size=64, num_layers=2
+    )
+
+class TestPampaRCoderV2:
+    def test_forward_shape(self, small_config):
+        model = PampaRCoderV2(small_config)
+        input_ids = torch.randint(0, 1000, (2, 16))
+        output = model(input_ids)
+        assert output.logits.shape == (2, 16, 1000)
+```
+
+---
+
+## Git Workflow
+
+```bash
+# Conventional commits
+feat(model): add early exit mechanism
+fix(llaves): correct zona classification for imports
+test(talamo): add gradient flow tests
+refactor(bloques): extract symbiotic support
+
+# Branch naming
+feat/early-exit
+fix/llaves-imports
+```
+
+---
+
+## Anti-patterns (NUNCA)
+
+- `any` en type hints → usar `Union`, `Optional`, etc.
+- LLAVES entrenables → son regex, siempre fijos
+- Cuantizar gradientes → solo LLAVES lookup
+- Archivos >300 líneas → dividir en módulos
+- Tests sin fixture → usar `small_config`
+- `print()` en producción → usar `logging`
+- Secrets en código → usar variables de entorno

.env.example

@@ -0,0 +1,4 @@
+# API keys for Classroom mentor system (optional)
+OPENROUTER_API_KEY=sk-or-v1-your-key-here
+GITHUB_TOKEN=ghp_your-token-here
+QWEN_API_KEY=sk-your-dashscope-key-here

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+logo-pampar-color.png filter=lfs diff=lfs merge=lfs -text
+logo-pampar-sf.png filter=lfs diff=lfs merge=lfs -text
+logo-pampar.png filter=lfs diff=lfs merge=lfs -text
+PAMPAR-coder.png filter=lfs diff=lfs merge=lfs -text
+PAMPArLLM.png filter=lfs diff=lfs merge=lfs -text

.github/CODEOWNERS

@@ -0,0 +1,2 @@
+# Repository owner — all PRs require review
+* @lucasmella-stack

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,33 @@
+---
+name: Bug Report
+about: Report a bug in PAMPAr-Coder
+title: "[BUG] "
+labels: bug
+assignees: lucasmella-stack
+---
+
+## Description
+
+<!-- Clear description of the bug -->
+
+## Steps to Reproduce
+
+1.
+2.
+3.
+
+## Expected Behavior
+
+<!-- What should happen -->
+
+## Actual Behavior
+
+<!-- What actually happens -->
+
+## Environment
+
+- OS:
+- Python version:
+- PyTorch version:
+- GPU:
+- Checkpoint used:

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,23 @@
+---
+name: Feature Request
+about: Suggest an idea for PAMPAr-Coder
+title: "[FEATURE] "
+labels: enhancement
+assignees: ""
+---
+
+## Problem
+
+<!-- What problem does this solve? -->
+
+## Proposed Solution
+
+<!-- How would you implement it? -->
+
+## Alternatives Considered
+
+<!-- Other approaches you thought of -->
+
+## Additional Context
+
+<!-- Any additional context, references, papers, etc. -->

.github/copilot-instructions.md

@@ -0,0 +1,82 @@
+# PAMPAr-Coder - Copilot Instructions
+
+> Instrucciones específicas para este proyecto. Se combinan con tu perfil global.
+
+## Proyecto
+
+**PAMPAr-Coder** es un LLM de código 1.5B con arquitectura cerebral inspirada en las 52 zonas de Brodmann.
+"El Linux de la IA" - Hacer más con menos hardware.
+
+## Arquitectura
+
+```
+Input → Embedding → [BloqueTerrritorial ×N] → LM Head → Output
+                          ↓
+              TálamoBrodmann (LLAVES 80% + Atención 20%)
+              + Conv1D causal (ventana 32 tokens)
+                          ↓
+    ┌─────────────────────┴─────────────────────┐
+    ▼                                           ▼
+┌───────────────┐                    ┌───────────────┐
+│   SINTAXIS    │◄── simbiosis ────►│   SEMÁNTICA   │
+│  Zonas 1-15   │                    │  Zonas 16-30  │
+└───────────────┘                    └───────────────┘
+    ▼                                           ▼
+┌───────────────┐                    ┌───────────────┐
+│    LÓGICO     │◄── simbiosis ────►│ ESTRUCTURAL   │
+│  Zonas 31-42  │                    │  Zonas 43-52  │
+└───────────────┘                    └───────────────┘
+```
+
+## Componentes Clave
+
+| Archivo | Propósito |
+|---------|-----------|
+| `pampar/coder/v2/modelo.py` | PampaRCoderV2 con 52 zonas |
+| `pampar/coder/v2/config.py` | ConfigPampaRCoderV2 + presets |
+| `pampar/coder/v2/talamo.py` | Tálamo orquestador con LLAVES + context conv |
+| `pampar/coder/v2/llaves.py` | LLAVES lookup tables (INT8, 256 niveles) |
+| `pampar/coder/v2/bloques.py` | BloqueTerrritorial + relaciones simbióticas |
+| `pampar/coder/v2/zonas.py` | Definición de las 52 zonas de Brodmann |
+| `pampar/coder/v2/aprendizaje/` | Metacognición, neuroplasticidad, memoria errores |
+| `cloud/runpod/train_cloud.py` | Script de entrenamiento en cloud |
+
+## Convenciones
+
+- **Idioma código**: Inglés
+- **Comentarios/docs**: Español o Inglés según contexto
+- **Nombres de clases**: Español para conceptos de dominio (`Talamo`, `Territorio`, `Zona`, `MemoriaErrores`)
+- **Variables**: Inglés (`input_ids`, `hidden_states`)
+
+## Stack
+
+- PyTorch 2.x
+- SentencePiece (tokenizer BPE, 48K vocab)
+- Hugging Face datasets
+- RunPod/Cloud para entrenamiento
+
+## Comandos frecuentes
+
+```bash
+# Entrenar localmente
+python scripts/train.py --config 1.5B --epochs 10
+
+# Entrenar en cloud (RunPod)
+ssh root@IP -p PORT
+cd /workspace/PAMPAr-Coder
+screen -S train
+python3 cloud/runpod/train_cloud.py --config 1_5B > training.log 2>&1
+
+# Ver progreso
+tail -f training.log
+```
+
+## Reglas específicas
+
+1. **LLAVES** son patrones regex que clasifican tokens - NUNCA usar ML para esto
+2. **Territorios** procesan en paralelo, luego combinan via soporte simbiótico
+3. **Cuantización INT8** (256 niveles) para LLAVES lookup tables
+4. **Early Exit** usa percentil 10 per-token (no promedio global)
+5. **Gradient checkpointing** siempre activo para modelos >500M params
+6. **Tests** en `tests/` con pytest
+7. **Ventana de contexto** (32 tokens) usa convolución causal - pad izquierdo

.github/instructions/cloud-training.instructions.md

@@ -0,0 +1,91 @@
+# Cloud Training Instructions
+
+> Entrenamiento de PAMPAr-Coder en RunPod y otros providers.
+
+## RunPod Setup
+
+### Conectar
+```bash
+ssh root@IP -p PORT
+# Password: en RunPod dashboard o usar SSH key
+```
+
+### Preparar entorno
+```bash
+cd /workspace/PAMPAr-Coder
+pip install sentencepiece tqdm datasets
+```
+
+### Lanzar entrenamiento
+```bash
+# Background con log
+nohup python3 cloud/runpod/train_cloud.py \
+    --config 3B \
+    --data-dir data/distillation \
+    --tokenizer data/tokenizer/code_bpe.model \
+    --epochs 10 \
+    --no-wandb \
+    > training.log 2>&1 &
+
+# Monitorear
+tail -f training.log
+nvidia-smi -l 5  # GPU cada 5 segundos
+```
+
+## Configuraciones
+
+| Config | Params | VRAM | GPU recomendada |
+|--------|--------|------|-----------------|
+| 1.5B | ~230M | 8GB | RTX 3090, A10 |
+| 3B | ~3B | 24GB | A40, A100 |
+
+### Ajustar config
+```python
+# cloud/runpod/config_3b.py
+@dataclass
+class Config3B:
+    vocab_size: int = 32000
+    dim: int = 2560
+    n_heads: int = 20
+    n_capas: int = 32
+    max_seq_len: int = 2048
+    batch_size: int = 4
+    gradient_accumulation: int = 16
+```
+
+## Troubleshooting
+
+### OOM en GPU
+1. Reducir `batch_size`
+2. Reducir `max_seq_len`
+3. Activar `use_gradient_checkpointing = True`
+
+### OOM en RAM (sistema)
+1. Usar streaming dataset
+2. Reducir workers de DataLoader
+3. Modelo se carga en CPU antes de GPU - reducir tamaño
+
+### Tokens fuera de rango
+- Asegurar `vocab_size` en config == tokenizer.GetPieceSize()
+- Típico: tokenizer tiene 32K, config dice 16K → error
+
+## Checkpoints
+
+```bash
+# Ubicación
+/workspace/PAMPAr-Coder/checkpoints/
+├── best_model.pt      # Mejor val_loss
+├── epoch_N.pt         # Por epoch
+└── step_XXXX.pt       # Por steps
+
+# Descargar a local
+scp -P PORT root@IP:/workspace/PAMPAr-Coder/checkpoints/best_model.pt ./
+```
+
+## Costos estimados
+
+| GPU | $/hora | 10 epochs (20K samples) |
+|-----|--------|------------------------|
+| A10 | $0.30 | ~$0.60 |
+| A40 | $0.40 | ~$0.80 |
+| A100 | $1.50 | ~$3.00 |

.github/instructions/pampar-architecture.instructions.md

@@ -0,0 +1,59 @@
+# PAMPAr Architecture Instructions
+
+> Arquitectura cerebral con 52 zonas de Brodmann para procesamiento de código.
+
+## LLAVES System
+
+LLAVES = Lookup de Activación Via Expresiones Sintácticas
+
+```python
+# Las LLAVES clasifican tokens usando patrones regex, NO ML
+LLAVES = {
+    'B06_KEYWORDS_IMPORT': ['import', 'from', 'require'],
+    'B17_LITERAL_STRING': [r'".*"', r"'.*'", 'f"', "f'"],
+    'B18_LITERAL_NUMERO': [r'\d+', r'\d+\.\d+'],
+    'B35_IDENTIFICADOR_VAR': [r'[a-z_][a-z0-9_]*'],
+    # ... 52 zonas total
+}
+```
+
+## Territorios (4 Macro-Áreas)
+
+| Territorio | Zonas | Función |
+|------------|-------|---------|
+| SINTAXIS | B01-B13 | Keywords, operadores, delimitadores |
+| SEMÁNTICA | B14-B39 | Identificadores, literales, tipos |
+| LÓGICO | B40-B44 | Condicionales, loops, excepciones |
+| ESTRUCTURAL | B45-B52 | Patrones, estructuras, documentación |
+
+## Flujo de Procesamiento
+
+```
+1. Token → LLAVES lookup (O(1), 80% peso)
+2. Token → Embedding attention (30% peso)  
+3. Combinar → Activación por zona
+4. Zonas activas → Procesamiento territorial
+5. Fusión → Output
+```
+
+## Cuantización
+
+Solo las lookup tables de LLAVES se cuantizan a INT4:
+- Reduce memoria de 6.5MB → 812KB
+- Sin pérdida de precisión (es lookup discreto)
+- El modelo (pesos) se mantiene en FP16/BF16
+
+## Early Exit
+
+El modelo puede salir temprano si la confianza es alta:
+```python
+if confianza > 0.90 and capa >= self.capas_minimas:
+    return x, True  # Exit early
+```
+
+## Reglas de Implementación
+
+1. **NUNCA** usar backprop para entrenar LLAVES
+2. **SIEMPRE** procesar territorios en paralelo cuando sea posible
+3. **Cuantizar** solo tablas de lookup, nunca pesos del modelo
+4. **Registrar** tokenizer con `model.registrar_tokenizer(tokenizer)`

.github/instructions/python-ml.instructions.md

@@ -0,0 +1,268 @@
+````instructions
+# Python ML/LLM Instructions
+
+> Para desarrollo de modelos de ML/LLM con PyTorch.
+
+## Type Hints (OBLIGATORIO)
+
+```python
+from typing import Optional, Tuple, Dict, List, Union, Literal
+from torch import Tensor
+import torch.nn as nn
+
+def forward(
+    self,
+    input_ids: Tensor,
+    attention_mask: Optional[Tensor] = None,
+    labels: Optional[Tensor] = None,
+) -> Tuple[Tensor, Optional[Tensor]]:
+    """
+    Forward pass del modelo.
+
+    Args:
+        input_ids: Token IDs, shape (batch, seq_len).
+        attention_mask: Máscara de atención, shape (batch, seq_len).
+        labels: Labels para calcular loss, shape (batch, seq_len).
+
+    Returns:
+        Tuple de (logits, loss). Loss es None si labels no se proporcionan.
+    """
+    ...
+````
+
+## Docstrings (Google Style)
+
+```python
+class PampaRCoderV2(nn.Module):
+    """
+    Modelo principal PAMPAr-Coder V2 con arquitectura cerebral.
+
+    Attributes:
+        config: Configuración del modelo.
+        embedding: Capa de embedding de tokens.
+        talamo: Orquestador central TálamoBrodmann.
+        territorios: Lista de 4 BloqueTerrritorial.
+
+    Example:
+        >>> config = ConfigPampaRCoderV2.from_preset("1.5B")
+        >>> model = PampaRCoderV2(config)
+        >>> output = model(input_ids)
+    """
+```
+
+## PyTorch Patterns
+
+### Model Definition
+
+```python
+class MiModulo(nn.Module):
+    def __init__(self, config: ConfigPampaRCoderV2):
+        super().__init__()
+        self.config = config
+        # Inicializar layers aquí
+
+    def forward(self, x: Tensor) -> Tensor:
+        # Forward pass
+        return x
+
+    def _init_weights(self, module: nn.Module) -> None:
+        """Inicialización de pesos."""
+        if isinstance(module, nn.Linear):
+            nn.init.normal_(module.weight, std=0.02)
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)
+```
+
+### Training Loop
+
+```python
+from torch.cuda.amp import autocast, GradScaler
+from tqdm import tqdm
+
+def train_epoch(
+    model: nn.Module,
+    dataloader: DataLoader,
+    optimizer: Optimizer,
+    scheduler: LRScheduler,
+    scaler: GradScaler,
+    device: torch.device,
+    accumulation_steps: int = 4,
+) -> float:
+    """Entrena una época completa."""
+    model.train()
+    total_loss = 0.0
+
+    for step, batch in enumerate(tqdm(dataloader)):
+        batch = {k: v.to(device) for k, v in batch.items()}
+
+        with autocast(dtype=torch.bfloat16):
+            outputs = model(**batch)
+            loss = outputs.loss / accumulation_steps
+
+        scaler.scale(loss).backward()
+
+        if (step + 1) % accumulation_steps == 0:
+            scaler.unscale_(optimizer)
+            torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+            scaler.step(optimizer)
+            scaler.update()
+            scheduler.step()
+            optimizer.zero_grad()
+
+        total_loss += loss.item() * accumulation_steps
+
+    return total_loss / len(dataloader)
+```
+
+### Checkpoint Saving/Loading
+
+```python
+def save_checkpoint(
+    model: nn.Module,
+    optimizer: Optimizer,
+    scheduler: LRScheduler,
+    epoch: int,
+    loss: float,
+    path: str,
+) -> None:
+    """Guarda checkpoint completo."""
+    torch.save({
+        "model_state_dict": model.state_dict(),
+        "optimizer_state_dict": optimizer.state_dict(),
+        "scheduler_state_dict": scheduler.state_dict(),
+        "epoch": epoch,
+        "loss": loss,
+    }, path)
+
+def load_checkpoint(
+    path: str,
+    model: nn.Module,
+    optimizer: Optional[Optimizer] = None,
+    scheduler: Optional[LRScheduler] = None,
+) -> Dict:
+    """Carga checkpoint."""
+    checkpoint = torch.load(path, map_location="cpu")
+    model.load_state_dict(checkpoint["model_state_dict"])
+    if optimizer:
+        optimizer.load_state_dict(checkpoint["optimizer_state_dict"])
+    if scheduler:
+        scheduler.load_state_dict(checkpoint["scheduler_state_dict"])
+    return checkpoint
+```
+
+## Memory Optimization
+
+### Gradient Checkpointing
+
+```python
+# Para modelos grandes (>500M params)
+model.gradient_checkpointing_enable()
+
+# Manual control:
+from torch.utils.checkpoint import checkpoint
+
+class Block(nn.Module):
+    def forward(self, x):
+        if self.training and self.gradient_checkpointing:
+            return checkpoint(self._forward_impl, x, use_reentrant=False)
+        return self._forward_impl(x)
+```
+
+### Efficient Attention
+
+```python
+# Usar Flash Attention cuando sea posible
+from torch.nn.functional import scaled_dot_product_attention
+
+# O xformers para backwards compatibility
+try:
+    from xformers.ops import memory_efficient_attention
+    HAS_XFORMERS = True
+except ImportError:
+    HAS_XFORMERS = False
+```
+
+### Tensor Operations
+
+```python
+# BIEN: operaciones in-place cuando sea seguro
+x.add_(bias)  # En lugar de x = x + bias
+
+# BIEN: evitar concatenaciones innecesarias
+# MAL:
+# outputs = []
+# for block in self.blocks:
+#     outputs.append(block(x))
+# return torch.cat(outputs, dim=-1)
+
+# BIEN: usar stack si las dimensiones son iguales
+outputs = torch.stack([block(x) for block in self.blocks], dim=0)
+```
+
+## Testing (pytest)
+
+```python
+import pytest
+import torch
+from pampar.coder.v2.modelo import PampaRCoderV2
+from pampar.coder.v2.config import ConfigPampaRCoderV2
+
+@pytest.fixture
+def config():
+    """Configuración pequeña para tests."""
+    return ConfigPampaRCoderV2(
+        vocab_size=1000,
+        hidden_size=64,
+        num_layers=2,
+        num_heads=4,
+    )
+
+@pytest.fixture
+def model(config):
+    """Modelo pequeño para tests."""
+    return PampaRCoderV2(config)
+
+class TestPampaRCoderV2:
+    def test_forward_shape(self, model, config):
+        """Verifica output shape."""
+        batch_size, seq_len = 2, 16
+        input_ids = torch.randint(0, config.vocab_size, (batch_size, seq_len))
+
+        output = model(input_ids)
+
+        assert output.logits.shape == (batch_size, seq_len, config.vocab_size)
+
+    def test_gradient_flow(self, model):
+        """Verifica que gradientes fluyen correctamente."""
+        input_ids = torch.randint(0, 1000, (1, 8))
+        labels = input_ids.clone()
+
+        output = model(input_ids, labels=labels)
+        output.loss.backward()
+
+        for name, param in model.named_parameters():
+            if param.requires_grad:
+                assert param.grad is not None, f"No gradient for {name}"
+```
+
+## Logging
+
+```python
+import logging
+
+# Configurar al inicio del script
+logging.basicConfig(
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    level=logging.INFO,
+)
+logger = logging.getLogger(__name__)
+
+# Usar en el código
+logger.info(f"Epoch {epoch}: loss={loss:.4f}")
+logger.warning(f"GPU memory high: {memory_used:.1f}GB")
+logger.error(f"Checkpoint save failed: {e}")
+```
+
+```
+
+```

.github/instructions/testing-pytest.instructions.md

@@ -0,0 +1,229 @@
+```instructions
+# Testing Instructions (pytest)
+
+> Para tests en PAMPAr-Coder usando pytest.
+
+## Regla de Oro
+
+**Cada módulo nuevo DEBE tener:**
+1. Un test de happy path
+2. Un test de error/edge case
+3. Un test de shapes (para tensores)
+
+## Estructura de Tests
+
+```
+
+tests/
+├── test_modelo.py # Tests del modelo principal
+├── test_talamo.py # Tests del tálamo
+├── test_llaves.py # Tests de LLAVES
+├── test_generation.py # Tests de generación
+└── conftest.py # Fixtures compartidos
+
+````
+
+## Fixtures (conftest.py)
+
+```python
+import pytest
+import torch
+from pampar.coder.v2.config import ConfigPampaRCoderV2
+
+@pytest.fixture
+def device():
+    """Device para tests: CUDA si disponible, else CPU."""
+    return torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+@pytest.fixture
+def small_config():
+    """Configuración mínima para tests rápidos."""
+    return ConfigPampaRCoderV2(
+        vocab_size=1000,
+        hidden_size=64,
+        num_layers=2,
+        num_heads=4,
+        intermediate_size=256,
+    )
+
+@pytest.fixture
+def batch():
+    """Batch de ejemplo para tests."""
+    return {
+        "input_ids": torch.randint(0, 1000, (2, 16)),
+        "attention_mask": torch.ones(2, 16, dtype=torch.long),
+        "labels": torch.randint(0, 1000, (2, 16)),
+    }
+````
+
+## Patrones de Test
+
+### Test de Shapes
+
+```python
+class TestModelShapes:
+    def test_embedding_output_shape(self, small_config):
+        from pampar.coder.v2.modelo import PampaRCoderV2
+
+        model = PampaRCoderV2(small_config)
+        input_ids = torch.randint(0, small_config.vocab_size, (2, 16))
+
+        output = model(input_ids)
+
+        assert output.logits.shape == (2, 16, small_config.vocab_size)
+        assert output.hidden_states.shape == (2, 16, small_config.hidden_size)
+
+    def test_attention_shape(self, small_config):
+        from pampar.coder.v2.talamo import TalamoBrodmann
+
+        talamo = TalamoBrodmann(small_config)
+        x = torch.randn(2, 16, small_config.hidden_size)
+
+        out = talamo(x)
+
+        assert out.shape == x.shape
+```
+
+### Test de Gradientes
+
+```python
+class TestGradientFlow:
+    def test_all_parameters_have_gradients(self, small_config):
+        model = PampaRCoderV2(small_config)
+        input_ids = torch.randint(0, small_config.vocab_size, (1, 8))
+
+        output = model(input_ids, labels=input_ids)
+        output.loss.backward()
+
+        for name, param in model.named_parameters():
+            if param.requires_grad:
+                assert param.grad is not None, f"No grad: {name}"
+                assert not torch.isnan(param.grad).any(), f"NaN grad: {name}"
+
+    def test_gradient_clipping(self, small_config):
+        model = PampaRCoderV2(small_config)
+        # ... setup con gradientes grandes
+
+        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+
+        total_norm = sum(p.grad.norm() ** 2 for p in model.parameters()).sqrt()
+        assert total_norm <= 1.0 + 1e-6
+```
+
+### Test con Mock
+
+```python
+from unittest.mock import MagicMock, patch
+
+class TestTraining:
+    @patch("torch.cuda.is_available", return_value=False)
+    def test_cpu_fallback(self, mock_cuda):
+        """Verifica que funciona sin GPU."""
+        from pampar.coder.v2.modelo import PampaRCoderV2
+
+        config = ConfigPampaRCoderV2.from_preset("mini")
+        model = PampaRCoderV2(config)
+
+        input_ids = torch.randint(0, config.vocab_size, (1, 8))
+        output = model(input_ids)
+
+        assert output.logits is not None
+```
+
+### Test Parametrizado
+
+```python
+@pytest.mark.parametrize("batch_size", [1, 2, 4])
+@pytest.mark.parametrize("seq_len", [8, 16, 32])
+def test_variable_batch_seq(small_config, batch_size, seq_len):
+    model = PampaRCoderV2(small_config)
+    input_ids = torch.randint(0, small_config.vocab_size, (batch_size, seq_len))
+
+    output = model(input_ids)
+
+    assert output.logits.shape == (batch_size, seq_len, small_config.vocab_size)
+
+@pytest.mark.parametrize("preset", ["mini", "1.5B", "3B"])
+def test_preset_configs(preset):
+    config = ConfigPampaRCoderV2.from_preset(preset)
+
+    assert config.vocab_size == 48000
+    assert config.hidden_size > 0
+```
+
+### Test de LLAVES
+
+```python
+class TestLlaves:
+    def test_llaves_are_not_trainable(self):
+        from pampar.coder.v2.llaves import LlavesModule
+
+        llaves = LlavesModule()
+
+        for param in llaves.parameters():
+            assert not param.requires_grad, "LLAVES no deben ser entrenables"
+
+    def test_llaves_int8_quantization(self):
+        from pampar.coder.v2.llaves import LlavesModule
+
+        llaves = LlavesModule()
+
+        assert llaves.lookup_table.dtype == torch.int8
+
+    def test_llaves_pattern_matching(self):
+        from pampar.coder.v2.llaves import classify_token
+
+        # Declaración Python
+        assert classify_token("def ") in range(1, 16)  # SINTAXIS
+
+        # Operador lógico
+        assert classify_token("if ") in range(31, 43)  # LÓGICO
+```
+
+## Markers
+
+```python
+# En pyproject.toml o pytest.ini:
+# [tool.pytest.ini_options]
+# markers = [
+#     "slow: marks tests as slow",
+#     "gpu: marks tests requiring GPU",
+# ]
+
+@pytest.mark.slow
+def test_full_training_loop():
+    """Test lento de training completo."""
+    ...
+
+@pytest.mark.gpu
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="GPU required")
+def test_cuda_forward():
+    """Test que requiere GPU."""
+    ...
+```
+
+## Ejecutar Tests
+
+```bash
+# Todos los tests
+pytest
+
+# Solo tests rápidos
+pytest -m "not slow"
+
+# Con coverage
+pytest --cov=pampar --cov-report=html
+
+# Verbose con print output
+pytest -v -s
+
+# Solo un archivo
+pytest tests/test_modelo.py
+
+# Solo un test específico
+pytest tests/test_modelo.py::TestModelShapes::test_embedding_output_shape
+```
+
+```
+
+```

.github/pull_request_template.md

@@ -0,0 +1,18 @@
+## What
+
+<!-- Brief description of the change -->
+
+## Why
+
+<!-- Context and motivation -->
+
+## How to Test
+
+<!-- Steps to verify it works -->
+
+## Checklist
+
+- [ ] Tests added/updated (`python -m pytest tests/ -v`)
+- [ ] Type hints on all new functions
+- [ ] No hardcoded paths or secrets
+- [ ] Conventional commit messages

.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install torch --index-url https://download.pytorch.org/whl/cpu
+          pip install -r requirements.txt
+
+      - name: Run tests
+        run: python -m pytest tests/ -v --tb=short

.gitignore

@@ -0,0 +1,103 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# Model checkpoints
+checkpoints/
+*.pt
+*.pth
+*.bin
+*.gguf
+
+# Data
+data/
+*.model
+
+# Logs
+logs/
+*.log
+scripts/_logs/
+tensorboard/
+
+# Sessions (generated HTML/JSONL replays)
+sessions/
+
+# Archive (dead scripts, old backups)
+_archive/
+scripts/_archive/
+
+# Large dataset files — use scripts to regenerate
+biblioteca/
+
+# OS
+.DS_Store
+Thumbs.db

.memoria/sesion_2026-03-16_linux-ia.md

@@ -0,0 +1,154 @@
+# Sesión 2026-03-16 — PAMPAr como "el Linux de la IA"
+
+> Archivo de memoria para el agente. Contexto de la sesión de trabajo.
+
+---
+
+## Corrección crítica del agente
+
+El agente redujo PAMPAr a "un generador de código en formato Problem/Solution".
+El usuario corrigió: **PAMPAr es un copiloto local autónomo basado en arquitectura cerebral**.
+
+### Lo que PAMPAr ES (nunca olvidar)
+
+1. **Arquitectura cerebral 2D**: grilla cortical 4 streams × 5 niveles, inspirada en el cerebro humano
+   - Tálamo (routing) + LLAVES INT8 (80% reglas + 20% aprendido)
+   - 4 streams: SINTAXIS (B01-B15), SEMÁNTICA (B16-B30), LÓGICO (B31-B42), ESTRUCTURAL (B43-B52)
+   - Lateral Gates = fibras blancas (comunicación entre streams)
+   - GQA 4:1 (8Q / 2KV heads), RoPE, Early Exit
+   - 108M params, vocab 48K, max_seq_len 4096
+
+2. **Copiloto local 100% offline**: corre en hardware consumer (GTX 1650, 4GB VRAM), sin cloud, sin APIs, sin telemetría
+
+3. **Agente autónomo con RAG del sistema**:
+   - Scanner inspecciona: workspace (ast.parse), paquetes (importlib), servicios (socket), hardware (torch.cuda)
+   - BootProtocol: CONCIENCIA.md → Scanner → AGENTS.md → RAG L2/L3
+   - La identidad (CONCIENCIA.md) es L3 inmutable, el entorno (AGENTS.md) es L2 mutable
+   - "Físico con doctorado" que se especializa según el "laboratorio" donde aterriza
+
+4. **Skills reales**: LectorArchivos (ojos), EjecutorCodigo (manos), con Skill ABC para extensibilidad
+
+5. **Memoria con Ley de Pareto**: RAGResidual + ClasificadorPareto (L0→L3) + ColaFinetune (auto-mejora)
+
+6. **Loop autónomo**: prompt → genera → ejecuta → observa → aprende del error → reintenta
+
+7. **Visión final**: el modelo genera su propio AGENTS.md al aterrizar en un sistema nuevo
+
+---
+
+## Analogía Linux ↔ PAMPAr
+
+| Linux                            | PAMPAr                                                | Estado                          |
+| -------------------------------- | ----------------------------------------------------- | ------------------------------- |
+| Kernel                           | PamparV3 (108M, grilla cortical 2D)                   | ✅ Construido                   |
+| Detección hardware (dmesg, udev) | Scanner (ast.parse, importlib, socket, torch.cuda)    | ✅ Construido                   |
+| Init system (systemd)            | BootProtocol (CONCIENCIA → Scanner → AGENTS.md → RAG) | ✅ Construido                   |
+| Filesystem                       | RAGResidual + ClasificadorPareto                      | ✅ Construido                   |
+| Device drivers                   | Skills (Skill ABC → LectorArchivos, EjecutorCodigo)   | ✅ Base, faltan más             |
+| Self-compilation                 | ColaFinetune (auto-SFT)                               | ✅ Wiring hecho, no probado e2e |
+| Terminal/Shell                   | ??? (cli.py es parche, Continue no integrado)         | ❌ Falta                        |
+| Corre en cualquier hardware      | 4GB VRAM, CPU fallback                                | ✅                              |
+
+---
+
+## Brechas detectadas
+
+### 1. Kernel no probado en producción
+
+- 16/16 eval controlado, pero no probado con prompts reales
+- SFT actual: Magicoder-OSS-75K (### Problem / ### Solution)
+- **El modelo NO fue entrenado para el formato del Agente** ([LEER:], [EJECUTAR:], historial, RAG context)
+- Brecha más crítica
+
+### 2. Pocos drivers (skills)
+
+- Solo 2 skills. Faltan: BuscarSkill, GitSkill, TerminalSkill, TestSkill, EditarSkill
+
+### 3. Sin interfaz real
+
+- cli.py llama a generate() directo, NO al Agente (sin RAG, sin skills, sin memoria)
+- Continue necesita HTTP server OpenAI-compatible
+
+### 4. Auto-mejora no probada end-to-end
+
+- ColaFinetune → mini-SFT → reload pesos nunca corrió completo
+
+---
+
+## Estrategia propuesta (3 fases)
+
+### Fase A — El kernel funciona de verdad (AHORA)
+
+1. Entrenar modelo con datos en formato del Agente (system prompt + RAG + acciones + historial)
+2. CLI usa el Agente real, no generate() directo
+
+### Fase B — Más drivers, shell funcional
+
+3. 3-4 skills más (buscar, editar, git, tests)
+4. HTTP server OpenAI-compatible (Continue)
+5. Loop auto-mejora probado end-to-end
+
+### Fase C — Distribución empaquetada
+
+6. pip install pampar-coder
+7. Integración Continue nativa
+8. Documentación tipo man pages
+
+---
+
+## Ventaja competitiva
+
+- Arquitectura cerebral (no transformer genérico)
+- 108M params en 4GB VRAM local
+- RAG del sistema como contexto (sabe qué hay en tu máquina)
+- Auto-aprendizaje (ColaFinetune)
+- Sin cloud, sin telemetría, 100% tuyo
+- = Propuesta de valor de Linux vs Windows/macOS en los 90s
+
+---
+
+## Estado del proyecto (Mar 2026)
+
+- **Modelo activo**: PamparV3 — 108.3M params, vocab 48K
+- **Mejor checkpoint**: v3_sft_v8.pt — 16/16 eval
+- **Tests**: 109+ passing
+- **Milestone 1** ✅ — 16/16 eval
+- **Milestone 2** ✅ — Runtime loop (chat.py + ColaFinetune + mini-SFT wiring)
+- **Milestone 3** ✅ — Protocolo (generador determinista AGENTS.md)
+- **Milestone 4** ⏳ — VS Code / Continue integration
+- **Milestone 5** ⏳ — Voz TTS
+
+## Archivos clave del proyecto
+
+```
+pampar/CONCIENCIA.md          — Identidad invariante (L3)
+AGENTS.md                     — Protocolo de despliegue (L2, mutable)
+ROADMAP.md                    — Plan de evolución
+pampar/coder/v3/modelo.py     — PamparV3 (108M)
+pampar/coder/v3/talamo.py     — TalamoInicial (routing cerebral)
+pampar/coder/v3/bloques.py    — NivelProfundo, StreamFFN, LateralGate
+pampar/coder/v3/llaves.py     — LLAVES INT8 (lookup tables)
+pampar/coder/v3/zonas.py      — 52 Zonas de Brodmann
+pampar/runtime/agente.py      — Agente (orquestador)
+pampar/runtime/scanner.py     — Scanner (inspección del entorno)
+pampar/runtime/boot.py        — BootProtocol (secuencia de arranque)
+pampar/runtime/generar_agents.py — Generador AGENTS.md
+pampar/memoria/rag.py         — RAGResidual (vector store)
+pampar/memoria/clasificador.py — ClasificadorPareto (L0-L3)
+pampar/memoria/cola_finetune.py — ColaFinetune (auto-SFT)
+pampar/skills/base.py         — Skill ABC
+pampar/skills/lector_archivos.py — LectorArchivos (ojos)
+pampar/skills/ejecutar_codigo.py — EjecutorCodigo (manos)
+pampar/cli.py                 — CLI (parche, no usa Agente)
+pampar/inference.py           — JSON-lines server (base para HTTP)
+checkpoints/v3_sft_v8.pt      — Mejor checkpoint (16/16)
+data/tokenizer/pampar_48k.model — Tokenizer activo
+```
+
+## Hardware del usuario
+
+- **GPU**: GTX 1650 (4GB VRAM)
+- **Python**: 3.13 (C:\Users\lucas\AppData\Local\Programs\Python\Python313\python.exe)
+- **torch**: 2.6.0+cu124
+- **OS**: Windows
+- **.venv en Lunux-AI/.venv**: NO tiene torch — no usar para inferencia

.zenodo.json

@@ -0,0 +1,70 @@
+{
+  "title": "PAMPAr-Coder V3: A Brain-Inspired 2D Stream Architecture with Mixed Selectivity for Efficient Code Generation",
+  "description": "<p>PAMPAr-Coder V3 is a compact code generation language model with 62.6M parameters, designed to train and run at full FP16 precision on consumer GPUs with as little as 4GB VRAM.</p><p>The architecture introduces two key innovations: (1) a <strong>2D Stream organization</strong> that arranges computation as four specialized cortical streams (Syntax, Semantics, Logic, Structural) across five depth levels, connected by bidirectional lateral gates analogous to white-matter fiber tracts; and (2) <strong>Mixed Selectivity via FiLM</strong>, where a single shared Feed-Forward Network per level is dynamically re-read by context-dependent gamma/beta modulators derived from a 63-dimensional context vector — reducing FFN parameters by ~73% per level compared to four independent networks.</p><p>Additional contributions include TalamoNivel adaptive per-level re-routing, Grouped Query Attention (8Q/2KV), and the MotorCuriosidad ZPD-based curriculum scheduler that adapts training difficulty across 161 topic categories and 3.2M lines of code data.</p><p>After 55,000 training steps, the model reaches a cross-entropy loss of ~1.38 and saturates 29 of 40 curriculum topics at level 1, demonstrating active learning progress with training still ongoing.</p><p>This release includes: full model source code (PyTorch), training scripts, PAMPAr-48k bilingual tokenizer (48K vocabulary), configuration, and the research paper preprint.</p>",
+  "upload_type": "software",
+  "access_right": "open",
+  "license": "other-open",
+  "creators": [
+    {
+      "name": "Mella Chillemi, Lucas Ricardo",
+      "affiliation": "Independent Researcher",
+      "orcid": ""
+    }
+  ],
+  "keywords": [
+    "language model",
+    "code generation",
+    "brain-inspired AI",
+    "mixed selectivity",
+    "FiLM modulation",
+    "grouped query attention",
+    "curriculum learning",
+    "ZPD",
+    "cortical streams",
+    "lateral gates",
+    "LLAVES routing",
+    "parameter efficiency",
+    "PyTorch",
+    "natural language processing",
+    "deep learning"
+  ],
+  "related_identifiers": [
+    {
+      "scheme": "doi",
+      "identifier": "10.5281/zenodo.18315642",
+      "relation": "isCitedBy",
+      "resource_type": "software"
+    }
+  ],
+  "references": [
+    "Perez E., Strub F., de Vries H., Dumoulin V., Courville A. (2018). FiLM: Visual Reasoning with a General Conditioning Layer. AAAI 2018.",
+    "Rigotti M., Barak O., Warden M. R., et al. (2013). The importance of mixed selectivity in complex cognitive tasks. Nature, 497, 585-590.",
+    "Ainslie J., Lee-Thorp J., de Jong M., et al. (2023). GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints. EMNLP 2023.",
+    "Roziere B., Gehring J., Gloeckle F., et al. (2023). Code Llama: Open Foundation Models for Code. arXiv:2308.12950.",
+    "Lozhkov A., Li R., Allal L. B., et al. (2024). StarCoder2 and the Stack v2: The Next Generation. arXiv:2402.19173.",
+    "Vygotsky L. S. (1978). Mind in Society: The Development of Higher Psychological Processes. Harvard University Press.",
+    "Mella Chillemi, L. R. (2026). PAMPAr-o1 v9: A Brain-Inspired Territorial Architecture for Language Modeling. DOI: 10.5281/zenodo.18315642.",
+    "Elhage N., Hume T., Gray C., et al. (2022). Toy Models of Superposition. Transformer Circuits Thread.",
+    "Felleman D. J. & Van Essen D. C. (1991). Distributed hierarchical processing in the primate cerebral cortex. Cerebral Cortex, 1(1), 1-47."
+  ],
+  "notes": "This software is released under the Business Source License 1.1 (BUSL-1.1). The paper preprint is available in the paper/ directory. The model is intended for research and non-commercial use. Commercial licensing inquiries: lucas.mella@outlook.com",
+  "version": "3.0.0",
+  "language": "eng",
+  "subjects": [
+    {
+      "term": "Computer Science - Computation and Language",
+      "identifier": "cs.CL",
+      "scheme": "arXiv"
+    },
+    {
+      "term": "Computer Science - Machine Learning",
+      "identifier": "cs.LG",
+      "scheme": "arXiv"
+    },
+    {
+      "term": "Computer Science - Programming Languages",
+      "identifier": "cs.PL",
+      "scheme": "arXiv"
+    }
+  ]
+}

AGENTS.md

@@ -0,0 +1,274 @@
+# PAMPAr — Repository Guidelines
+
+> **PAMPAr** = Procesador Autónomo Modular de Patrones y Razonamiento
+> Para AI agents: Claude Code, Codex, Gemini CLI, GitHub Copilot.
+
+---
+
+## Visión
+
+PAMPAr es un **motor de razonamiento puro** de 108M parámetros. No memoriza respuestas — aprende a **pensar con información de referencia**.
+
+La analogía: un físico que entiende termodinámica puede resolver problemas de química, ingeniería o biología. No memorizó cada campo — tiene los axiomas correctos.
+
+- Los **pesos** (108M params) contienen la capacidad de **razonar**: leer documentación, entender un problema, derivar una solución step-by-step.
+- El **dispositivo** (PC, móvil, servidor) provee el **conocimiento**: docs de Python, MDN, man pages, archivos del usuario — vía RAG local.
+- El modelo no necesita "saber Python". Necesita saber **usar la referencia que tiene disponible** para resolver cualquier problema.
+
+**Objetivo**: un modelo local que razona con la misma metodología que los mejores modelos, usando la información del dispositivo como RAG.
+
+---
+
+## Estado actual
+
+- **Modelo activo**: `PamparV3` — **108.3M params**, vocab 48K, 4 streams × 5 niveles
+- **Mejor checkpoint**: `v3_ghidra_v9.pt` — Routing Score 89, eval 6/16 (38%)
+- **Tokenizer**: `data/tokenizer/pampar_48k.model` (48K, bilingüe ES+código)
+- **Runtime**: Agente + RAGResidual + Scanner + BootProtocol — funcional
+- **Classroom**: Mentor conversacional con Qwen-plus — lecciones dinámicas, 21 conceptos adaptativos, absorción + práctica + corrección
+- **Bio-Mechanisms**: Neuromodulación, LTP, Sleep Consolidation, Neurogenesis, Synaptic Pruning — `bio_mechanisms.py`
+- **Teacher API**: Qwen-plus via DashScope (principal), GitHub Models gpt-4o-mini (alternativa)
+- **Training data**: `master_sft.jsonl` — 1,253 ejemplos (en expansión vía Classroom)
+
+---
+
+## Quick Reference
+
+| Area       | Convention                                             |
+| ---------- | ------------------------------------------------------ |
+| Language   | Python 3.13+                                           |
+| Framework  | PyTorch 2.6+                                           |
+| Tokenizer  | SentencePiece BPE — **48K** (`pampar_48k.model`)       |
+| Type hints | Always required                                        |
+| Docstrings | Google style                                           |
+| Training   | Local GTX 1650 (4 GB) + RunPod A100 para fases pesadas |
+| Budget     | $300-500 USD total                                     |
+
+---
+
+## Arquitectura — PamparV3
+
+### Grilla 2D: 4 streams × 5 niveles
+
+```
+tok_emb [48K × 640]
+  → TalamoInicial → terr_acts [B, L, 4]  /  zona_acts [B, L, 52]
+  → 4 streams paralelos (dim=640)
+
+Cada NivelProfundo (×5):
+  1. GQA Atención compartida (8 Q heads / 2 KV heads, head_dim=80)
+  2. Re-routing ligero del Tálamo (Linear dim→52, sin bias)
+  3. 4 × StreamFFN SwiGLU independientes (uno por stream)
+  4. Lateral gates por stream (bottleneck=128, fibras blancas)
+
+→ norm_f (RMSNorm) → lm_head (weight-tied, vocab=48K)
+```
+
+### Streams ↔ Capas lingüísticas
+
+| Stream | Territorio  | Zonas   | Especialización                           | Capa lingüística |
+| ------ | ----------- | ------- | ----------------------------------------- | ---------------- |
+| 0      | SINTAXIS    | B01-B15 | Keywords, delimitadores, puntuación       | Sintaxis         |
+| 1      | SEMANTICA   | B16-B30 | Variables, tipos, literales               | Semántica        |
+| 2      | LOGICO      | B31-B42 | Operadores, flujo de control, excepciones | Pragmática       |
+| 3      | ESTRUCTURAL | B43-B52 | Indentación, bloques, patrones            | Discurso         |
+
+### PRESET_V3
+
+| Parámetro        | Valor       |
+| ---------------- | ----------- |
+| `dim`            | 640         |
+| `n_streams`      | 4           |
+| `n_levels`       | 5           |
+| `n_heads`        | 8           |
+| `n_kv_heads`     | 2 (GQA 4:1) |
+| `vocab_size`     | 48 000      |
+| `max_seq_len`    | 4096        |
+| **Total params** | **108.3M**  |
+
+---
+
+## Subsistemas
+
+### 1. Modelo (`pampar/coder/v3/`)
+
+| Archivo             | Líneas | Propósito                                                                       |
+| ------------------- | ------ | ------------------------------------------------------------------------------- |
+| `modelo.py`         | 310    | PamparV3: forward, generate (nucleus sampling)                                  |
+| `config.py`         | 226    | ConfigV3, 3 presets (V3/SMALL/LARGE)                                            |
+| `bloques.py`        | 395    | RMSNorm, RoPE, BloqueAttn (GQA), StreamFFN (SwiGLU), LateralGate, NivelProfundo |
+| `talamo.py`         | 133    | TalamoInicial: LLAVES 80% + attn_proj 20% + context_conv                        |
+| `llaves.py`         | 266    | LlavesV2: clasificar_token(), tabla INT8, agregar_zonas_a_territorios           |
+| `zonas.py`          | 265    | Territorio(IntEnum), Zona(IntEnum), ZONAS dict, ZONA_TERRITORIO                 |
+| `ghidra_probe.py`   | 343    | GhidraProbe: 36 forward hooks, diagnosis/debugging                              |
+| `engrama_stream.py` | 359    | BancoEngrama: O(1) activation memory, cosine-gated injection                    |
+
+### 2. Memoria (`pampar/memoria/`)
+
+| Archivo            | Propósito                                                                     |
+| ------------------ | ----------------------------------------------------------------------------- |
+| `clasificador.py`  | ClasificadorPareto: scoring L0-L3 por densidad, novedad, loss, frecuencia     |
+| `rag.py`           | RAGResidual: FAISS + sentence-transformers (fallback TF-IDF), 5K entradas max |
+| `cola_finetune.py` | ColaFinetune: acumula L3, exporta JSONL, propone mini-SFT                     |
+
+### 3. Runtime (`pampar/runtime/`)
+
+| Archivo             | Propósito                                                          |
+| ------------------- | ------------------------------------------------------------------ |
+| `agente.py`         | Orquestador: prompt→RAG→generar→skills→retry→auto-SFT              |
+| `scanner.py`        | Inspección del dispositivo: OS, GPU, paquetes, servicios, archivos |
+| `boot.py`           | BootProtocol: CONCIENCIA.md (L3) → Scanner (L2) → Workspace (L1)   |
+| `generar_agents.py` | Genera AGENTS.md contextual desde ResultadoScan                    |
+
+### 4. Skills (`pampar/skills/`)
+
+| Archivo              | Propósito                                                 |
+| -------------------- | --------------------------------------------------------- |
+| `lector_archivos.py` | Lee archivos del dispositivo (30+ extensiones, sandboxed) |
+| `ejecutar_codigo.py` | Ejecuta código en subprocess con timeout y blocklist      |
+
+### 5. Inference (`pampar/inference.py`)
+
+Servidor JSON-lines stdin/stdout para extensión VS Code. Commands: `infer`, `boot`.
+
+### 6. Classroom — Mentor Conversacional + Bio-Mechanisms
+
+Sistema donde Qwen-plus actúa como mentor conversacional — genera explicaciones, ejemplos y ejercicios dinámicos. PamparV3 absorbe el conocimiento via gradient descent en 3 phases por lección.
+
+**Flujo**: StudentProfile → Mentor genera lección → Phase A (absorber explicación+ejemplo) → Phase B (alumno intenta ejercicio) → Phase C (mentor corrige, entrenar en solución+replay) → actualizar perfil.
+
+| Módulo                     | Líneas | Responsabilidad                                                                |
+| -------------------------- | ------ | ------------------------------------------------------------------------------ |
+| `classroom.py`             | ~608   | ClassroomEngine — motor conversacional (orquestador)                           |
+| `classroom_curriculum.py`  | ~433   | ClassroomConfig + CONCEPT_TREE (21 conceptos) + StudentProfile + concept_level |
+| `classroom_teacher.py`     | ~252   | Mentor API (Qwen/GitHub/OpenRouter) + parse de lecciones                       |
+| `classroom_training.py`    | ~211   | Tokenización + LR diferencial + train_step                                     |
+| `classroom_memory.py`      | ~187   | EWC + ReplayBuffer + LessonResult + compute_ewc_baseline                       |
+| `classroom_events.py`      | ~104   | Formateo dict-based de eventos para consola                                    |
+| `classroom_persistence.py` | ~123   | Guardado de checkpoints, sesiones JSONL, grabaciones HTML                      |
+| `classroom_server.py`      | ~255   | HTTP SSE server + CLI entry point                                              |
+| `bio_mechanisms.py`        | ~497   | 5 bio-mechanisms coordinados por BioOrchestrator                               |
+
+**CONCEPT_TREE**: 21 conceptos en 5 niveles con prerequisitos (arithmetic → algorithms).
+**StudentProfile**: mastery tracking adaptativo — prioriza refuerzo, luego nuevos, luego repaso.
+
+| Mecanismo          | Propósito                                                         |
+| ------------------ | ----------------------------------------------------------------- |
+| **EWC**            | Elastic Weight Consolidation — penaliza cambios en pesos críticos |
+| **Replay Buffer**  | Mezcla ejemplos nuevos con anteriores (consolidación tipo sueño)  |
+| **LR Diferencial** | LLAVES 0.01x, atención 0.1x, embed 0.1x, FFN 1.0x                 |
+| **Curriculum**     | 5 niveles progresivos: básico → avanzado                          |
+| **Grabación**      | Genera HTML con replay interactivo de cada sesión                 |
+
+**Bio-Mechanisms** (5 mecanismos de neurociencia en `bio_mechanisms.py`):
+
+| Mecanismo               | Implementación                                                       |
+| ----------------------- | -------------------------------------------------------------------- |
+| **Neuromodulación**     | Dopamina/Norepinefrina modulan LR dinámicamente (×0.3 a ×3.0)        |
+| **LTP**                 | Fortalece `LateralGate.scale` de streams activos (Hebb rule, cada 5) |
+| **Sleep Consolidation** | REM (aleatorio) + SWS (ordenado por dificultad), cada 15 lecciones   |
+| **Neurogenesis**        | LoRA adapters (rank=8) en StreamFFN cuando loss > 4.0, max 8         |
+| **Synaptic Pruning**    | Poda `LateralGate.scale < 0.03` cada 30 lecciones (decay ×0.5)       |
+
+Coordinados por `BioOrchestrator.after_lesson()`. Desactivables con `--no-bio`.
+
+**Resultados piloto mentor conversacional (5 lecciones)**: Loss absorción ~7-8, loss ejercicios 5.89→3.94 (mejora), brain score 88.24% estable.
+
+**APIs soportadas**: `qwen` (Qwen-plus via DashScope, principal), `github` (gpt-4o-mini), `openrouter` (requiere créditos).
+
+---
+
+## Estructura del proyecto
+
+```
+PAMPAr-Coder/
+├── AGENTS.md                    # Este archivo — guía para AI agents
+├── README.md                    # Documentación pública
+├── PLAN.md                      # Plan de training y evolución
+├── pampar/
+│   ├── CONCIENCIA.md            # Identidad invariante del modelo
+│   ├── coder/
+│   │   └── v3/                  # ARQUITECTURA ACTIVA (108M)
+│   │       ├── modelo.py        # PamparV3 — forward, generate
+│   │       ├── config.py        # ConfigV3, presets
+│   │       ├── talamo.py        # TalamoInicial — routing
+│   │       ├── bloques.py       # GQA, SwiGLU, LateralGate, NivelProfundo
+│   │       ├── llaves.py        # LlavesV2 — lookup INT8
+│   │       ├── zonas.py         # 52 Zonas de Brodmann
+│   │       ├── ghidra_probe.py  # Instrumentación read-only
+│   │       └── engrama_stream.py# Memoria de activaciones
+│   ├── memoria/
+│   │   ├── clasificador.py      # ClasificadorPareto — niveles L0-L3
+│   │   ├── rag.py               # RAGResidual — vector store local
+│   │   └── cola_finetune.py     # ColaFinetune — buffer auto-SFT
+│   ├── skills/
+│   │   ├── lector_archivos.py   # Lee archivos (sandboxed)
+│   │   └── ejecutar_codigo.py   # Ejecuta código (subprocess)
+│   ├── runtime/
+│   │   ├── agente.py            # Orquestador principal
+│   │   ├── scanner.py           # Inspección del dispositivo
+│   │   ├── boot.py              # Secuencia de arranque
+│   │   └── generar_agents.py    # Generador de AGENTS.md
+│   └── inference.py             # Servidor JSON-lines para VS Code
+├── scripts/
+│   ├── classroom.py             # ClassroomEngine — motor conversacional (~608 líneas)
+│   ├── classroom_curriculum.py  # ClassroomConfig + CONCEPT_TREE + StudentProfile + concept_level
+│   ├── classroom_teacher.py     # Mentor API — Qwen/GitHub/OpenRouter + parse de lecciones
+│   ├── classroom_training.py    # Tokenización + LR diferencial + train_step
+│   ├── classroom_events.py      # Formateo dict-based de eventos para consola
+│   ├── classroom_memory.py      # EWC + ReplayBuffer + LessonResult + compute_ewc_baseline
+│   ├── classroom_persistence.py # Guardado de checkpoints, sesiones, grabaciones HTML
+│   ├── classroom_server.py      # HTTP SSE server + CLI entry point
+│   ├── bio_mechanisms.py        # 5 bio-mechanisms (Neuromod, LTP, Sleep, Neurogenesis, Pruning)
+│   └── classroom_replay.html    # Player HTML para replays
+├── sessions/                    # Grabaciones de sesiones classroom
+├── data/
+│   ├── tokenizer/
+│   │   └── pampar_48k.model     # Vocab 48K bilingüe
+│   └── *.jsonl                  # Datasets de training
+├── checkpoints/
+│   └── v3_ghidra_v9.pt          # Mejor checkpoint actual
+├── _archive/                    # Backups de archivos antes de refactorizar
+└── tests/
+```
+
+---
+
+## Critical Rules
+
+- **vocab_size = 48K** → DEBE coincidir con `pampar_48k.model`
+- **Tokenizer path**: usar `PRESET_V3.tokenizer_path` o constante compartida — no hardcodear
+- LLAVES son INT8 pre-computadas — **nunca** en el grafo de gradientes
+- Los 4 streams procesan en **paralelo** — sin secuencialidad entre streams
+- `targets.reshape(-1)` siempre, nunca `.view(-1)` (tensores no-contiguos)
+- `generate()` usa `max_tokens`, NO `max_new_tokens`
+- Imports: `pampar.memoria.*`, `pampar.skills.*`, `pampar.runtime.*`
+- **Backups**: antes de borrar/refactorizar, mover el original a `_archive/`
+
+## Naming Conventions
+
+- **Español** para conceptos del dominio: `Talamo`, `Territorio`, `Zona`, `LLAVES`, `Agente`, `Scanner`
+- **Inglés** para ML estándar: `forward`, `embedding`, `hidden_states`, `loss`, `generate`
+
+## Paradigma de inferencia
+
+```
+1. Usuario hace una pregunta/pedido
+2. Scanner provee contexto del dispositivo (OS, paquetes, archivos)
+3. RAGResidual busca referencia relevante (docs, código, memoria)
+4. Prompt se arma: [SYSTEM] + [REFERENCIA RAG] + [CONTEXTO DISPOSITIVO] + [PREGUNTA]
+5. Modelo RAZONA sobre la referencia y genera solución step-by-step
+6. Skills ejecutan la solución si aplica (código, lectura, tests)
+7. Si falla → retry con error como contexto → ColaFinetune acumula patrones
+```
+
+---
+
+## Instructions Files
+
+Detailed instructions in `.github/instructions/`:
+
+- `global-profile.instructions.md` — perfil del desarrollador
+- `testing.instructions.md` — reglas de testing (pytest)
+- `git-workflow.instructions.md` — commits convencionales
+- `docker-devops.instructions.md` — Docker, CI/CD

CITATION.cff

@@ -0,0 +1,105 @@
+cff-version: 1.2.0
+message: >-
+  If you use PAMPAr-Coder V3 in your research or products,
+  please cite it using the metadata below.
+
+title: >-
+  PAMPAr-Coder V3: A Brain-Inspired 2D Stream Architecture
+  with Mixed Selectivity for Efficient Code Generation
+
+version: "3.0.0"
+
+doi: "10.5281/zenodo.XXXXXXX"
+
+date-released: "2026-04-07"
+
+license: "BUSL-1.1"
+
+repository-code: "https://github.com/lucasmella-stack/PAMPAr-Coder"
+
+abstract: >-
+  PAMPAr-Coder V3 is a 62.6M-parameter code language model with a
+  brain-inspired 2D Stream architecture. It organizes computation as four
+  specialized cortical streams (Syntax, Semantics, Logic, Structural) across
+  five depth levels connected by lateral gates. A single shared Feed-Forward
+  Network per level is dynamically modulated via FiLM (Feature-wise Linear
+  Modulation) using a 63-dimensional context vector, reducing FFN parameters
+  by 73% versus independent per-stream networks. A ZPD-based curriculum
+  scheduler (MotorCuriosidad) adapts training difficulty across 161 topic
+  categories. The model trains end-to-end at FP16 precision on a consumer
+  4GB GPU — a regime requiring quantization for competing models.
+
+keywords:
+  - code generation
+  - language model
+  - brain-inspired architecture
+  - mixed selectivity
+  - FiLM modulation
+  - grouped query attention
+  - curriculum learning
+  - ZPD
+  - parameter efficiency
+  - cortical streams
+  - lateral gates
+  - LLAVES routing
+
+authors:
+  - family-names: "Mella Chillemi"
+    given-names: "Lucas Ricardo"
+    affiliation: "Independent Researcher"
+    city: "Buenos Aires"
+    country: "AR"
+    email: "lucas.mella@outlook.com"
+
+references:
+  - type: article
+    title: >-
+      PAMPAr-o1 v9: A Brain-Inspired Territorial Architecture for Language
+      Modeling with Explicit Rule-Based Routing
+    authors:
+      - family-names: "Mella Chillemi"
+        given-names: "Lucas Ricardo"
+    year: 2026
+    doi: "10.5281/zenodo.18315642"
+
+  - type: article
+    title: >-
+      FiLM: Visual Reasoning with a General Conditioning Layer
+    authors:
+      - family-names: "Perez"
+        given-names: "Ethan"
+      - family-names: "Strub"
+        given-names: "Florian"
+      - family-names: "de Vries"
+        given-names: "Harm"
+      - family-names: "Dumoulin"
+        given-names: "Vincent"
+      - family-names: "Courville"
+        given-names: "Aaron"
+    year: 2018
+    conference:
+      name: "AAAI 2018"
+
+  - type: article
+    title: "The importance of mixed selectivity in complex cognitive tasks"
+    authors:
+      - family-names: "Rigotti"
+        given-names: "Mattia"
+      - family-names: "Barak"
+        given-names: "Omri"
+    year: 2013
+    journal: "Nature"
+    volume: 497
+    start: 585
+    end: 590
+
+  - type: article
+    title: >-
+      GQA: Training Generalized Multi-Query Transformer Models from
+      Multi-Head Checkpoints
+    authors:
+      - family-names: "Ainslie"
+        given-names: "Joshua"
+    year: 2023
+    conference:
+      name: "EMNLP 2023"

CONTRIBUTING.md

@@ -0,0 +1,53 @@
+# Contributing to PAMPAr-Coder
+
+Thank you for your interest in contributing! PAMPAr-Coder is licensed under
+[BUSL-1.1](LICENSE) — contributions are welcome for non-commercial research
+and academic purposes.
+
+## How to Contribute
+
+### Reporting Bugs
+
+1. Check [existing issues](https://github.com/lucasmella-stack/PAMPAr-Coder/issues) first.
+2. Open a new issue with:
+   - Steps to reproduce
+   - Expected vs actual behavior
+   - Python version, OS, GPU (if relevant)
+
+### Suggesting Features
+
+Open an issue with the `enhancement` label describing the feature and its use case.
+
+### Pull Requests
+
+1. Fork the repository.
+2. Create a feature branch: `git checkout -b feat/your-feature`
+3. Follow existing code style (type hints, Google-style docstrings).
+4. Add tests for new functionality (`pytest`).
+5. Run the test suite: `python -m pytest tests/ -v`
+6. Commit with [Conventional Commits](https://www.conventionalcommits.org/):
+   `feat:`, `fix:`, `test:`, `docs:`, `refactor:`
+7. Open a PR against `main`.
+
+## Development Setup
+
+```bash
+git clone https://github.com/lucasmella-stack/PAMPAr-Coder.git
+cd PAMPAr-Coder
+python -m venv .venv
+.venv/Scripts/activate   # Windows
+pip install -r requirements.txt
+python -m pytest tests/ -v
+```
+
+## Code Style
+
+- Python 3.11+ with type hints everywhere
+- Docstrings: Google style
+- No hardcoded paths or secrets
+- Functions ≤ 50 lines, files ≤ 400 lines
+
+## License
+
+By contributing, you agree that your contributions will be licensed under the
+same [BUSL-1.1](LICENSE) license.

LICENSE

@@ -0,0 +1,96 @@
+Business Source License 1.1
+
+Parameters
+
+Licensor: Lucas Ricardo Mella Chillemi
+Licensed Work: PAMPAr-Coder V3
+The Licensed Work is (c) 2025-2026 Lucas Ricardo Mella Chillemi.
+Additional Use Grant: You may use the Licensed Work for non-commercial research,
+academic citation, personal experimentation, and educational
+purposes. Production use for commercial purposes requires a
+separate commercial license from the Licensor.
+Change Date: April 7, 2030
+Change License: Apache License, Version 2.0
+
+For information about alternative licensing arrangements for the Licensed Work,
+please contact: lucas.mella@outlook.com
+
+---
+
+Notice
+
+The Business Source License (this document, or the "License") is not an Open
+Source license. However, the Licensed Work will eventually be made available
+under an Open Source License, as stated in this License.
+
+License text copyright (c) 2017 MariaDB Corporation Ab, All Rights Reserved.
+"Business Source License" is a trademark of MariaDB Corporation Ab.
+
+---
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, above, permitting limited
+production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under
+the terms of the Change License, and the rights granted in the paragraph
+above terminate.
+
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or authorized
+resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works
+of the Licensed Work, are subject to this License. This License applies
+separately for each version of the Licensed Work and the Change Date may vary
+for each version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy
+of the Licensed Work. If you receive the Licensed Work in original or
+modified form from a third party, the terms and conditions set forth in this
+License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other
+versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or logo of
+Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
+TITLE.
+
+MariaDB hereby grants you permission to use this License's text to license
+your works, and to refer to it using the trademark "Business Source License",
+as long as you comply with the Covenants of Licensor below.
+
+---
+
+Covenants of Licensor
+
+In consideration of the right to use this License's text and the "Business
+Source License" name and trademark, Licensor covenants to MariaDB, and to all
+other recipients of the licensed work to be provided by Licensor:
+
+1. To specify as the Change License the GPL Version 2.0 or any later version,
+   or a license that is compatible with GPL Version 2.0 or a later version,
+   where "compatible" means that software provided under the Change License
+   can be included in a program with software provided under GPL Version 2.0
+   or a later version. Licensor may specify additional Change Licenses
+   without limitation.
+
+2. To either: (a) specify an additional grant of rights to use that does not
+   impose any additional restriction on the right granted in this License, as
+   the Additional Use Grant; or (b) insert the text "None".
+
+3. Not to modify this License in any other way.

PLAN.md

@@ -0,0 +1,202 @@
+# PAMPAr — Plan de Evolución
+
+> Plan aprobado: **Option B — "Staged Physics"**
+> Budget total: **$300-500 USD**
+> Modelo: PamparV3, 108.3M params, vocab 48K
+
+---
+
+## Objetivo
+
+Transformar PamparV3 de un modelo que solo conoce patrones Python (38% eval)
+a un **motor de razonamiento multi-lenguaje** que usa documentación de referencia
+para resolver problemas en cualquier dominio.
+
+### Métricas target
+
+| Métrica | Actual | Target |
+|---------|--------|--------|
+| Python eval | 6/16 (38%) | 70%+ |
+| Multi-language | 0% | 50%+ |
+| Doc consultation (RAG) | 0% | 60%+ |
+| Debugging | 0% | 50%+ |
+
+---
+
+## Fase 1 — Continual Pretrain: "Textbook Physics"
+
+**Objetivo**: inyectar los axiomas fundamentales de razonamiento con referencia.
+
+### Datos (~540K-640K tokens)
+
+6 pilares de axiomas, cada uno con ~90K-100K tokens de texto tipo textbook:
+
+| Pilar | Contenido | Fuente |
+|-------|-----------|--------|
+| **Lógica y razonamiento** | Proposiciones, inferencia, truth tables, deducción | Generado + Wikipedia |
+| **Estructuras de datos** | Arrays, trees, graphs, hashmaps — cross-language | Generado + docs oficiales |
+| **Patrones de código** | Design patterns, idioms en Python/JS/Rust/C | Generado + libros open |
+| **Comprensión de docs** | Cómo leer una API reference, man page, docstring | MDN, Python docs, Rust Book |
+| **Debugging** | Stack traces, error messages, bisección, logging | Generado + StackOverflow curado |
+| **Multi-language syntax** | Equivalencias Python↔JS↔Rust↔C↔Bash↔SQL | Generado + Rosetta Code |
+
+### Formato
+
+```
+<textbook>
+## Capítulo: [tema]
+
+[Explicación clara del concepto]
+
+### Ejemplo
+[Código con comentarios]
+
+### Ejercicio resuelto
+[Problema → razonamiento step-by-step → solución]
+</textbook>
+```
+
+### Costo estimado: $30-60
+
+- Distilación desde GPT-4o/Claude para generar textbooks
+- ~6 scripts de generación, uno por pilar
+- Validación manual de quality (sampling 5%)
+
+### Hardware
+
+- Generación de datos: API calls (local)
+- Continual pretrain: **RunPod A100 40GB** (~2-4 horas)
+
+---
+
+## Fase 2 — SFT: "Chain-of-Thought con Referencia"
+
+**Objetivo**: enseñar al modelo a usar documentación de referencia para resolver problemas.
+
+### Datos (~20K ejemplos)
+
+| Categoría | Ejemplos | Descripción |
+|-----------|----------|-------------|
+| Python + ref | 5K | Problemas con snippet de docs como contexto |
+| JavaScript + ref | 3K | DOM, Node.js, ES6+ con MDN como referencia |
+| Rust + ref | 2K | Ownership, traits, lifetimes con Rust Book |
+| SQL + ref | 2K | Queries con schema como referencia |
+| Bash/CLI + ref | 1K | Comandos con man pages como referencia |
+| Debugging | 3K | Stack traces → diagnóstico → fix |
+| Cross-language | 2K | "Traducir" lógica entre lenguajes |
+| RAG-grounded | 2K | Preguntas que requieren buscar en docs primero |
+
+### Formato SFT
+
+```json
+{
+  "instruction": "[PROBLEMA] Implementar un servidor HTTP básico",
+  "reference": "[REFERENCIA] Fragmento de docs de http.server de Python...",
+  "reasoning": "[RAZONAMIENTO] 1. Necesito importar http.server\n2. Crear handler...\n3. Bind al puerto...",
+  "output": "[SOLUCIÓN] import http.server\n..."
+}
+```
+
+### Costo estimado: $110-150
+
+- Distilación masiva desde GPT-4o/Claude
+- 20K ejemplos × ~$0.006/ejemplo promedio
+- Quality filter: score > 0.7 de auto-evaluación
+
+### Hardware
+
+- Generación de datos: API calls (local)
+- SFT: **RunPod A100 40GB** (~4-8 horas)
+
+---
+
+## Fase 3 — Corrección: "GhidraProbe + NeuroTrainer"
+
+**Objetivo**: corregir routing y pesos usando diagnóstico local.
+
+### Proceso
+
+1. Correr `eval_v3.py` para identificar categorías débiles
+2. GhidraProbe analiza activaciones en ejemplos fallidos
+3. NeuroTrainer aplica correcciones targeted:
+   - LLAVES: ajustar reglas INT8 para tokens multi-language
+   - Routing: corregir `terr_acts` donde el Tálamo asigna mal
+   - Pesos: mini-SFT de 50-100 steps en categorías fallidas
+
+### Costo: $0
+
+- 100% local en GTX 1650
+- ~2 horas por ronda de corrección
+- 3-5 rondas estimadas
+
+---
+
+## Timeline estimado
+
+| Fase | Duración | Costo | Output |
+|------|----------|-------|--------|
+| Fase 1 — Pretrain data | 1-2 semanas | $30-60 | ~600K tokens textbook |
+| Fase 1 — Training | 1 día RunPod | incluido | Checkpoint pretrained |
+| Fase 2 — SFT data | 2-3 semanas | $110-150 | ~20K SFT examples |
+| Fase 2 — Training | 1 día RunPod | incluido | Checkpoint SFT |
+| Fase 3 — Correction | 1 semana | $0 | Checkpoint final |
+| **Total** | **5-7 semanas** | **$160-235** | **Motor de razonamiento** |
+
+---
+
+## Pre-requisitos (Blocks 2-3)
+
+Antes de empezar el training, necesitamos limpiar y preparar el código:
+
+### Block 2 — Cleanup de código muerto
+
+Scripts que importan módulos v2 eliminados (borrar con backup a `_archive/`):
+
+- `scripts/aprender_solo.py`
+- `scripts/train.py`
+- `scripts/train_cerebral.py`
+- `scripts/destilar.py`
+- `scripts/evaluate_v2.py`
+- `scripts/generar_curriculum.py`
+- `scripts/smoke_test_viaje.py`
+- `scripts/test_llaves.py`
+
+Scripts mixtos v2/v3 rotos (borrar con backup):
+
+- `scripts/benchmark.py`
+- `scripts/probar_modelo.py`
+- `scripts/eval_honesta.py`
+
+Módulos huérfanos:
+
+- `pampar/training/` — no importado por nada
+
+### Block 3 — Refactoring para multi-language
+
+| Archivo | Cambio |
+|---------|--------|
+| `zonas.py` | Agregar keywords JS/Rust/C/Bash/SQL a ZONAS |
+| `llaves.py` | Expandir `clasificar_token()` para multi-language |
+| `clasificador.py` | Generalizar `_calcular_densidad()` más allá de Python |
+| `ejecutar_codigo.py` | Agregar soporte para Node.js, Bash |
+| `config.py` | Extraer `TOKENIZER_PATH` como constante compartida |
+
+---
+
+## Checkpoints esperados
+
+| Nombre | Fase | Descripción |
+|--------|------|-------------|
+| `v3_ghidra_v9.pt` | Actual | Score 89, 6/16 (38%) — baseline |
+| `v3_pretrain_f1.pt` | Fase 1 | Post continual pretrain |
+| `v3_sft_f2.pt` | Fase 2 | Post SFT multi-language |
+| `v3_corrected_f3.pt` | Fase 3 | Post GhidraProbe correction — target final |
+
+---
+
+## Notas
+
+- **Arquitectura LOCKED**: no tocar la grilla 4×5, GQA, SwiGLU, LLAVES 80/20
+- **Backups siempre**: antes de borrar/refactorizar → `_archive/`
+- **RunPod**: A100 40GB para fases 1 y 2, el código de `cloud/runpod/` ya existe
+- **Evaluación**: `scripts/eval_v3.py` como benchmark consistente entre fases

README.md

@@ -0,0 +1,365 @@
+<p align="center">
+  <img src="PAMPAR-coder.png" alt="PAMPAr-Coder" width="200" />
+</p>
+
+<h1 align="center">PAMPAr-Coder</h1>
+
+<p align="center">
+  <strong>Pure reasoning engine</strong> — 62.6M params, local-first, on-device RAG.
+</p>
+
+<p align="center">
+  <a href="LICENSE"><img src="https://img.shields.io/badge/license-BUSL--1.1-blue" alt="License" /></a>
+  <img src="https://img.shields.io/badge/params-62.6M-green" alt="Params" />
+  <img src="https://img.shields.io/badge/python-3.11%2B-blue" alt="Python" />
+  <img src="https://img.shields.io/badge/pytorch-2.x-orange" alt="PyTorch" />
+</p>
+
+---
+
+## What is PAMPAr-Coder
+
+PAMPAr-Coder is a 62.6M parameter language model that **reasons over reference information** rather than memorizing answers. It works like a physicist: it understands the fundamental axioms and can derive solutions for any domain using documentation available on the device.
+
+- **Weights**: reasoning capability (read docs, understand problems, derive solutions step-by-step)
+- **Device**: knowledge via local RAG (Python docs, MDN, man pages, user files)
+- **Hardware**: designed to run on consumer hardware (GTX 1650, 4 GB VRAM)
+
+**Current state**: `v3_train.pt` — 98K steps, Mixed Selectivity (FiLM). Classroom system with conversational mentor (Qwen-plus) + 5 bio-inspired mechanisms. Tree of 21 concepts with adaptive prerequisites.
+
+---
+
+## 2D Architecture (PamparV3)
+
+```
+tok_emb [48K x 640]
+  -> TalamoInicial (LLAVES 80% + attn_proj 20% + context_conv)
+      -> terr_acts [B, L, 4]  /  zona_acts [B, L, 52]
+  -> 4 parallel streams (dim=640)
+
+  NivelProfundo x5:
+    1. Shared GQA Attention (8 Q heads / 2 KV heads, head_dim=80)
+    2. Lightweight Thalamus re-routing
+    3. 4 x independent StreamFFN SwiGLU
+    4. Lateral gates per stream (bottleneck=128)
+
+  -> norm_f (RMSNorm) -> lm_head (weight-tied, vocab=48K)
+```
+
+### The 4 Streams
+
+| Stream         | Brodmann Zones | Processes                         |
+| -------------- | -------------- | --------------------------------- |
+| **SYNTAX**     | B01-B15        | Keywords, operators, punctuation  |
+| **SEMANTICS**  | B16-B30        | Types, variables, literals        |
+| **LOGIC**      | B31-B42        | Control flow, conditionals, loops |
+| **STRUCTURAL** | B43-B52        | Blocks, indentation, scope        |
+
+### Parameters
+
+| Parameter        | Value       |
+| ---------------- | ----------- |
+| `dim`            | 640         |
+| `n_streams`      | 4           |
+| `n_levels`       | 5           |
+| `n_heads`        | 8           |
+| `n_kv_heads`     | 2 (GQA 4:1) |
+| `vocab_size`     | 48,000      |
+| `max_seq_len`    | 4096        |
+| **Total params** | **62.6M**   |
+
+---
+
+## Key Innovations
+
+### LLAVES System (TalamoInicial)
+
+- **80% explicit rules**: routing based on code patterns (INT8, pre-computed)
+- **20% learned attention**: fine-tuning for ambiguous cases
+- Produces `terr_acts` and `zona_acts` with zero inference overhead
+
+### 2D Cortical Architecture
+
+- **4 streams × 5 levels** = grid where rows specialize and columns refine
+- **GQA 4:1**: lower VRAM, same quality
+- **Lateral gates** (bottleneck 128): cross-stream communication like white-matter fibers
+- **Re-routing** per level: the Thalamus adapts which stream leads based on accumulated context
+
+### On-Device RAG
+
+The model uses the machine where it's installed as its knowledge source:
+
+- Scanner detects OS, packages, available files
+- RAGResidual indexes local documentation (FAISS + sentence-transformers)
+- The model reasons over references, it doesn't memorize content
+
+---
+
+## Classroom — Conversational Mentor + Bio-Mechanisms
+
+A learning system where a mentor model (Qwen-plus via DashScope) teaches PamparV3 through dynamic conversations, like a tutor in a chat. The mentor generates unique explanations, examples, and exercises for each lesson — the student absorbs knowledge via gradient descent.
+
+### Lesson Flow
+
+```
+1. StudentProfile selects adaptive concept (21 concepts with prerequisites)
+2. Mentor generates lesson: explanation + example + exercise + solution
+3. Phase A — Absorb: train on explanation + example (all tokens)
+4. Phase B — Practice: student attempts the exercise
+5. Phase C — Correct: mentor evaluates, train on correct solution + replay
+6. Update student profile (mastery per concept)
+```
+
+### Concept Tree (CONCEPT_TREE)
+
+21 concepts organized in 5 levels with prerequisites:
+
+| Level | Concepts                                                              |
+| ----- | --------------------------------------------------------------------- |
+| 1     | arithmetic → variables_types → conditionals, strings, functions_basic |
+| 2     | loops_for → loops_while, lists → tuples_sets, dicts                   |
+| 3     | recursion, higher_order, generators, error_handling                   |
+| 4     | classes_basic → inheritance, dunder_methods                           |
+| 5     | decorators, context_managers, algorithms, file_io                     |
+
+`StudentProfile` tracks mastery per concept and selects adaptively:
+
+- Prioritizes concepts with attempts but not yet mastered (reinforcement)
+- Then new concepts whose prerequisites are met
+- Finally spaced review of mastered concepts
+
+### Core Mechanisms
+
+| Mechanism                              | Purpose                                                           |
+| -------------------------------------- | ----------------------------------------------------------------- |
+| **EWC** (Elastic Weight Consolidation) | Protects important weights — penalizes changes to critical params |
+| **Replay Buffer**                      | Mixes new and previous examples (simulates sleep consolidation)   |
+| **Differential LR**                    | LLAVES/Thalamus 0.01×, attention 0.1×, embedding 0.1×, FFN 1.0×   |
+| **Conversational Absorption**          | Trains on mentor explanations + examples (knowledge distillation) |
+
+### Bio-Mechanisms (`bio_mechanisms.py`)
+
+5 mechanisms based on real neuroscience, integrated as post-lesson hooks:
+
+| Mechanism               | Biological Inspiration    | Implementation                                                                         |
+| ----------------------- | ------------------------- | -------------------------------------------------------------------------------------- |
+| **Neuromodulation**     | Dopamine + Norepinephrine | Dynamically modulates LR based on success/error (×0.3 to ×3.0)                         |
+| **LTP**                 | Long-term potentiation    | Strengthens `LateralGate.scale` of streams with consistent high activation (Hebb rule) |
+| **Sleep Consolidation** | REM + SWS phases          | Periodic replay (every 15 lessons): random (REM) + sorted by difficulty (SWS)          |
+| **Neurogenesis**        | New hippocampal neurons   | Injects LoRA adapters (rank=8, ~10K params) into StreamFFN when loss > 4.0             |
+| **Synaptic Pruning**    | Synaptic pruning (~50%)   | Reduces `LateralGate.scale < 0.03` every 30 lessons (decay ×0.5)                       |
+
+All coordinated by `BioOrchestrator.after_lesson()`. Can be disabled with `--no-bio`.
+
+### Mentor Pilot Results (5 lessons)
+
+- Absorption loss: ~7-8 (new content from mentor)
+- Exercise loss decreasing: 5.89 → 5.44 → 4.40 → 3.94 → 4.38
+- Brain score stable: 88.24% (prior knowledge preservation)
+- EWC penalty growing: 0.000002 → 0.000044 (active regularization)
+- Each lesson is UNIQUE — mentor generates dynamically, no repetition
+
+### Usage
+
+```bash
+# Conversational mentor with Qwen-plus (recommended)
+python scripts/classroom_server.py \
+  --checkpoint checkpoints/v3_train.pt \
+  --checkpoint-out checkpoints/v3_classroom_mentor.pt \
+  --teacher qwen --model qwen-plus \
+  --max-lessons 200 --lr 1e-5 --ewc-lambda 50 --no-bio --no-ui
+
+# With bio-inspired mechanisms enabled
+python scripts/classroom_server.py \
+  --checkpoint checkpoints/v3_train.pt \
+  --teacher qwen --model qwen-plus \
+  --max-lessons 200 --lr 1e-5
+
+# With web interface (SSE + dashboard)
+python scripts/classroom_server.py \
+  --checkpoint checkpoints/v3_train.pt \
+  --teacher qwen --port 8787
+
+# With GitHub Models API (alternative)
+python scripts/classroom_server.py \
+  --checkpoint checkpoints/v3_train.pt \
+  --teacher github --model gpt-4o-mini
+
+# Replay a recorded session
+# Open sessions/classroom_*.html in browser
+```
+
+---
+
+## Subsystems
+
+| Module        | Components                  | Purpose                                                                                         |
+| ------------- | --------------------------- | ----------------------------------------------------------------------------------------------- |
+| **Model**     | `pampar/coder/v3/`          | PamparV3: forward, generate, routing, blocks                                                    |
+| **Memory**    | `pampar/memoria/`           | ClasificadorPareto (L0-L3), RAGResidual (FAISS), ColaFinetune                                   |
+| **Runtime**   | `pampar/runtime/`           | Agent (orchestrator), Scanner (device), BootProtocol                                            |
+| **Skills**    | `pampar/skills/`            | LectorArchivos (30+ ext), EjecutorCodigo (subprocess)                                           |
+| **Inference** | `pampar/inference.py`       | JSON-lines stdin/stdout server for VS Code                                                      |
+| **Classroom** | `scripts/classroom*.py`     | Conversational mentor: engine + teacher + curriculum + training + events + memory + persistence |
+| **Bio-Mech**  | `scripts/bio_mechanisms.py` | 5 neuroscience mechanisms: Neuromod, LTP, Sleep, Neurogenesis, Pruning                          |
+
+---
+
+## Installation
+
+```bash
+git clone https://github.com/lucasmella-stack/PAMPAr-Coder.git
+cd PAMPAr-Coder
+pip install -r requirements.txt
+```
+
+---
+
+## Usage
+
+### Instantiate the model
+
+```python
+from pampar.coder.v3 import PamparV3, PRESET_V3
+import torch
+
+model = PamparV3(PRESET_V3)
+model.eval()
+
+# Forward pass
+ids = torch.randint(0, 48_000, (1, 64))
+with torch.no_grad():
+    logits, loss, info = model(ids)
+
+# Autoregressive generation
+gen = model.generate(ids, max_tokens=100, temperature=0.8, top_k=50)
+```
+
+### Use the Agent (with RAG + Skills)
+
+```python
+from pampar.runtime import Agente
+
+agent = Agente(
+    checkpoint="checkpoints/v3_train.pt",
+    workspace_root=".",
+)
+response = agent.responder("how to read a CSV with pandas?")
+```
+
+---
+
+## Project Structure
+
+```
+PAMPAr-Coder/
+├── pampar/
+│   ├── coder/v3/              # Active architecture (62.6M)
+│   │   ├── modelo.py          # PamparV3 — forward, generate
+│   │   ├── config.py          # ConfigV3 + presets
+│   │   ├── talamo.py          # TalamoInicial — routing
+│   │   ├── bloques.py         # GQA, SwiGLU, LateralGate, NivelProfundo
+│   │   ├── llaves.py          # LlavesV2 — INT8 lookup
+│   │   ├── zonas.py           # 52 Brodmann Zones
+│   │   ├── ghidra_probe.py    # Read-only instrumentation
+│   │   └── engrama_stream.py  # Activation memory
+│   ├── memoria/
+│   │   ├── clasificador.py    # ClasificadorPareto (L0-L3)
+│   │   ├── rag.py             # RAGResidual (FAISS + TF-IDF fallback)
+│   │   └── cola_finetune.py   # ColaFinetune (auto-SFT buffer)
+│   ├── skills/
+│   │   ├── lector_archivos.py # File reader (sandboxed)
+│   │   └── ejecutar_codigo.py # Code executor (subprocess)
+│   ├── runtime/
+│   │   ├── agente.py          # Main orchestrator
+│   │   ├── scanner.py         # Device inspection
+│   │   └── boot.py            # Boot sequence
+│   └── inference.py           # JSON-lines server for VS Code
+├── scripts/
+│   ├── classroom.py           # ClassroomEngine (~600 lines)
+│   ├── classroom_curriculum.py# CONCEPT_TREE (21 concepts) + StudentProfile
+│   ├── classroom_teacher.py   # Mentor API (GitHub/OpenRouter/Qwen)
+│   ├── classroom_training.py  # Tokenization + differential LR + train_step
+│   ├── classroom_events.py    # Console event formatting
+│   ├── classroom_memory.py    # EWC + ReplayBuffer + compute_ewc_baseline
+│   ├── classroom_persistence.py # Checkpoint + session + HTML recording save
+│   ├── classroom_server.py    # HTTP SSE server + CLI (entry point)
+│   └── bio_mechanisms.py      # 5 bio mechanisms
+├── data/tokenizer/
+│   └── pampar_48k.model       # 48K bilingual vocab (active)
+├── checkpoints/               # Model checkpoints (gitignored)
+├── tests/                     # pytest test suite
+└── _archive/                  # Pre-refactoring backups
+```
+
+---
+
+## Understanding the Loss
+
+| Loss  | Meaning               |
+| ----- | --------------------- |
+| ~10.7 | Untrained (log 48000) |
+| 7-8   | Random weights        |
+| 5-7   | Beginning to learn    |
+| 2-4   | Active learning       |
+| 1.5-2 | Optimal zone          |
+| < 1.5 | Topic well learned    |
+| < 0.7 | Topic mastered        |
+
+---
+
+## Tests
+
+```bash
+python -m pytest tests/ -v
+```
+
+142 tests, all passing.
+
+---
+
+## Philosophy
+
+> _"You don't need 72 billion parameters. You need the right architecture and the right axioms."_
+
+1. **Reasoning > memorization** — the model learns to use references, not to memorize
+2. **The device is the knowledge base** — local RAG, not cloud
+3. **Code is structured** — 4 specialized streams + LLAVES 80% rules
+4. **Consumer hardware** — 1.4 GB VRAM for fp16 training
+
+---
+
+## Roadmap
+
+- [x] Territorial architecture (52 Brodmann zones, 4 streams × 5 levels)
+- [x] LLAVES system (INT8 routing, 80% rules)
+- [x] BPE 48K bilingual tokenizer (ES + code)
+- [x] GQA 4:1, SwiGLU, lateral gates
+- [x] Memory module (ClasificadorPareto, RAG, ColaFinetune)
+- [x] Skills (LectorArchivos, EjecutorCodigo)
+- [x] Runtime.Agent (tool-use loop)
+- [x] GhidraProbe (read-only diagnostics)
+- [x] EngramaStream (activation memory)
+- [x] Bio-inspired Classroom (EWC, replay buffer, differential LR, curriculum)
+- [x] HTML session recording and replay
+- [x] GitHub Models API integration (gpt-4o-mini as teacher)
+- [x] Bio-mechanisms: Neuromodulation, LTP, Sleep Consolidation, Neurogenesis, Synaptic Pruning
+- [x] Conversational mentor: Qwen-plus generates dynamic lessons as tutor
+- [x] CONCEPT_TREE: 21 concepts with adaptive prerequisites
+- [x] StudentProfile: per-concept mastery tracking
+- [x] Loss masking: -100 on prompt tokens (train only on responses)
+- [x] Conversational absorption: train on mentor explanations + examples
+- [ ] Multimodal: image/diagram input support
+- [ ] Training data expansion (textbook + SFT multi-language)
+- [ ] KV cache in generate()
+- [ ] Multi-language execution (JS, Rust, Bash)
+- [ ] Benchmarks against reference models
+- [ ] VS Code extension
+
+---
+
+## License
+
+BUSL-1.1 — Copyright (c) 2024-2026 Lucas Ricardo Mella Chillemi
+
+Change Date: April 7, 2030 — License converts to Apache-2.0. See [LICENSE](LICENSE) for details.

ROADMAP.md

@@ -0,0 +1,240 @@
+# PAMPAr-Coder — Roadmap
+
+> Plan de evolución. Última actualización: Mar 2026.
+> Para la identidad del modelo ver `CONCIENCIA.md`. Para el protocolo de despliegue ver `AGENTS.md`.
+
+---
+
+## 1. Visión
+
+PAMPAr es un **físico con doctorado** que puede especializarse en cualquier campo:
+
+- El **doctorado** (razonamiento computacional) está en los **pesos** — 108M params.
+- La **especialización** viene del **entorno** — se descubre al boot con el Scanner.
+- El protocolo de 3 archivos (`CONCIENCIA.md` + `AGENTS.md` + `TOOLS.md`) es la interfaz entre el modelo y su despliegue.
+
+### Las 3 fases del proyecto
+
+| Fase                             | Qué                                                                   | Estado                                                     |
+| -------------------------------- | --------------------------------------------------------------------- | ---------------------------------------------------------- |
+| **Fase 1** — SFT                 | Entrenar el doctorado: lógica Python, patrones, razonamiento          | **✅ Completa** (16/16 con reparadores, target superado)   |
+| **Fase 2** — Runtime loop        | El modelo usa herramientas, ejecuta, lee, aprende del loop            | **✅ Completa** (chat.py + ColaFinetune + mini-SFT wiring) |
+| **Fase 3** — Protocolo entrenado | El modelo genera su propio AGENTS.md al aterrizar en un sistema nuevo | Futuro                                                     |
+
+---
+
+## 2. Arquitectura actual — PamparV3
+
+### 2.1 Grilla cortical 2D
+
+```
+Tokens (int)
+    │
+    ▼
+[Embeddings] 48K vocab, dim=640, weight-tied con lm_head
+    │
+    ▼
+┌─────────────────────────────┐
+│       TalamoInicial          │  routing: qué streams procesan cada token
+│  80% LLAVES (INT8 + reglas) │
+│  20% attn_proj (aprendido)  │
+│  + context_conv causal k=32 │
+└────────────┬────────────────┘
+             │ [B, L, 4, dim] — 4 streams con pesos distintos
+             ▼
+  ┌──────────────────────────────────────────────┐
+  │          5 × NivelProfundo                   │
+  │  TalamoNivel → 4× BloqueAttn GQA 4:1       │
+  │  → 4× StreamFFN SwiGLU → LateralGate       │
+  │  → Early Exit (umbral 0.90)                 │
+  └──────────────────────────────────────────────┘
+             │
+             ▼
+        RMSNorm + lm_head → logits [B, L, 48000]
+```
+
+### 2.2 Streams ↔ Capas lingüísticas
+
+| Stream | Territorio  | Zonas   | Capa lingüística                  |
+| ------ | ----------- | ------- | --------------------------------- |
+| 0      | SINTAXIS    | B01-B15 | Sintaxis — estructura del código  |
+| 1      | SEMANTICA   | B16-B30 | Semántica — significado           |
+| 2      | LOGICO      | B31-B42 | Pragmática — intención, flujo     |
+| 3      | ESTRUCTURAL | B43-B52 | Discurso — organización, patrones |
+
+Los 4 streams procesan en paralelo. Cada NivelProfundo tiene Lateral Gates (bottleneck=128) para comunicación entre streams — como las fibras blancas del cerebro.
+
+### 2.3 Boot Protocol
+
+```
+1. CONCIENCIA.md → RAG L3 (identidad inmutable)
+2. Scanner → workspace (ast), paquetes (importlib), servicios (socket), sistema (platform)
+3. AGENTS.md contextual → RAG L2 (entorno mutable)
+4. System prompt dinámico = identidad + contexto + acciones
+```
+
+Implementado en `pampar.runtime.scanner` + `pampar.runtime.boot`.
+
+---
+
+## 3. Estado de checkpoints
+
+| Checkpoint     | Datos                                         | Eval open (temp=0.0) |
+| -------------- | --------------------------------------------- | -------------------- |
+| `v3_sft.pt`    | 43K Magicoder (inglés)                        | 0/16                 |
+| `v3_sft_v5.pt` | SFT v5 (base post-catastrófico)               | 6/16                 |
+| `v3_sft_v6.pt` | clean_sft.jsonl (555 ejemplos)                | 10/16                |
+| `v3_sft_v7.pt` | final_sft.jsonl (825 = clean + quirúrgico×3)  | 15/16                |
+| `v3_sft_v8.pt` | micro-SFT cuadrados (300 steps + reparadores) | **16/16 ✅ BEST**    |
+
+### Estado actual (v3_sft_v8.pt — 16/16 con reparadores)
+
+| #   | Función          | Estado | Notas                                                          |
+| --- | ---------------- | ------ | -------------------------------------------------------------- |
+| 01  | contar_vocales   | ✅     | —                                                              |
+| 02  | suma_digitos     | ✅     | —                                                              |
+| 03  | es_palindromo    | ✅     | —                                                              |
+| 04  | maximo_lista     | ✅     | —                                                              |
+| 05  | fizzbuzz         | ✅     | Corregido (dataset quirúrgico)                                 |
+| 06  | aplanar_lista    | ✅     | —                                                              |
+| 07  | frecuencia       | ✅     | —                                                              |
+| 08  | cuadrados_pares  | ✅     | Genera `x*i` → reparador NameError word-boundary lo corrige    |
+| 09  | invertir_dict    | ✅     | —                                                              |
+| 10  | fibonacci        | ✅     | —                                                              |
+| 11  | busqueda_binaria | ✅     | —                                                              |
+| 12  | merge_sort       | ✅     | Corregido (self-contained)                                     |
+| 13  | Stack            | ✅     | —                                                              |
+| 14  | Punto            | ✅     | Corregido (import math / \*\*0.5)                              |
+| 15  | memoize          | ✅     | Corregido (usa `fn`, no `func`)                                |
+| 16  | primos_hasta     | ✅     | Reparador `_reparar_bloques_huerfanos` + stop `endswith(\n\n)` |
+
+---
+
+## 4. Plan de entrenamiento
+
+### Fase A — Entrenamiento curricular con MotorCuriosidad
+
+Objetivo: reforzar las bases de lógica que el modelo falla.
+
+```bash
+python scripts/train_v3.py \
+  --checkpoint checkpoints/v3_sft_v4.pt \
+  --biblioteca data/biblioteca/ \
+  --lr 3e-5 --epochs 3
+```
+
+Temas prioritarios basados en fallos del eval:
+
+1. `bucles_for_while` — fizzbuzz, cuadrados_pares
+2. `diccionarios` — invertir_dict
+3. `busqueda_algoritmos` — búsqueda binaria
+4. `recursion` — merge_sort
+5. `clases_oop` — Punto, memoize
+6. `matematica_basica` — primos, potencias
+
+### Fase B — SFT v5 (post-curricular)
+
+- ~18K ejemplos curados (3K por topic × 6 topics)
+- Formato Alpaca, filtrado con pytest
+- Generados por el propio modelo + verificación automática
+
+### Fase C — Matriz lingüística como dato de entrenamiento
+
+Incluir ejemplos que ejerciten explícitamente cada capa:
+
+- **Pragmática**: "El usuario quiere X, yo debo hacer Y" (comprensión de intención)
+- **Semántica**: Renombrar variables, inferir tipos, naming conventions
+- **Sintaxis**: Indentación correcta, keywords, delimitadores, f-strings
+- **Discurso**: Organización de código (imports → constantes → clases → funciones → main)
+
+---
+
+## 5. Roadmap de milestones
+
+```
+COMPLETADO ✅       COMPLETADO ✅        AHORA                 LARGO PLAZO
+────────────        ────────────         ─────────────         ────────────
+15/16 eval   →     16/16 eval   →       Mini-SFT auto →       Protocolo
+v3_sft_v7.pt       v3_sft_v8.pt         cuando cola≥50        entrenado
+108M params        + reparadores        ColaFinetune          Fase 3
+
+SFT dataset        chat.py              Mini-SFT wiring       El modelo
+limpio+quirúrgico  loop activo          sft_v5.py             genera su
+Clean+surgical×3   gen→exec→retry       auto-reload           AGENTS.md
+```
+
+### Milestone 1 — 16/16 eval ✅ COMPLETADO (target era ≥12/16)
+
+- [x] Dataset limpio (clean_sft.jsonl — 555 ejemplos sin contradicciones)
+- [x] Dataset quirúrgico (surgical_sft.jsonl — 90 ejemplos para 6 fallos)
+- [x] SFT v6 (10/16) desde clean data
+- [x] SFT v7 (15/16) desde clean + surgical×3
+- [x] Fix primos_hasta → reparador `_reparar_bloques_huerfanos` + stop `endswith(\n\n)`
+- [x] Fix cuadrados_pares → reparador NameError word-boundary en verificador
+- [x] **16/16 confirmado** con v3_sft_v8.pt + eval_v3.py cadena de reparadores
+
+### Milestone 2 — Runtime autónomo (EN PROGRESO)
+
+- [x] Scanner del sistema (`pampar.runtime.scanner`)
+- [x] Boot protocol (`pampar.runtime.boot`)
+- [x] CONCIENCIA.md como identidad invariante
+- [x] System prompt dinámico (identidad + contexto del scan)
+- [x] El agente ejecuta código que genera y observa output (`scripts/chat.py`)
+- [x] Si falla, agrega el par (prompt, error) a ColaFinetune
+- [x] Mini-SFT automático cuando la cola supera umbral (wiring con sft_v5.py + reload en proceso)
+
+### Milestone 3 — Protocolo entrenado ✅ Implementado (generador determinista)
+
+- [x] `pampar/runtime/generar_agents.py` — genera AGENTS.md contextual desde el scan (determinista)
+- [x] `BootProtocol._inyectar_contexto()` actualizado: genera AGENTS.md → fragmenta por secciones → RAG L2
+- [x] 23 tests en `tests/test_generar_agents.py` (132/132 en suite completa)
+- [x] Quick Reference, Sistema detectado, Paquetes clave, Servicios, Boot protocol generados dinámicamente
+- [ ] El modelo "sabe" escanear: genera `scan_sistema()` como código (largo plazo — necesita mucho más SFT)
+- [ ] CONCIENCIA se refuerza con RLHF/DPO sobre interacciones reales (largo plazo)
+- [ ] Nota: entrenar 108M params para generar markdown desde cero requiere 10K+ pasos — protocolo funcionando vía boot determinista es la aproximación correcta para este tamaño de modelo
+
+### Milestone 4 — VS Code extension
+
+- [ ] Extension que carga PamparV3 localmente (CPU/GPU)
+- [ ] Completado inline de código
+- [ ] Panel de chat con el agente
+- [ ] Memoria persistente entre sesiones (RAG en disco)
+
+### Milestone 5 — Voz (cuando el sistema la tiene)
+
+- [ ] Detectar motores de voz al boot (espeak, SAPI, say) — ya implementado en Scanner
+- [ ] TTS para respuestas cuando el usuario lo pide
+- [ ] Zero-dependency: usa lo que el OS tiene instalado
+
+---
+
+## 6. Estructura de carpetas
+
+```
+PAMPAr-Coder/
+├── CONCIENCIA.md                 # Identidad invariante del modelo
+├── AGENTS.md                     # Protocolo de despliegue (mutable)
+├── ROADMAP.md                    # Este archivo
+├── pampar/
+│   ├── coder/v3/                 # Arquitectura activa (108M)
+│   │   ├── modelo.py             # PamparV3
+│   │   ├── config.py             # ConfigV3, presets
+│   │   ├── talamo.py             # TalamoInicial
+│   │   ├── bloques.py            # BloqueAttn, StreamFFN, LateralGate
+│   │   ├── llaves.py             # LlavesV2 — lookup INT8
+│   │   └── zonas.py              # 52 Zonas de Brodmann
+│   ├── memoria/
+│   │   ├── clasificador.py       # ClasificadorPareto — L0 a L3
+│   │   ├── rag.py                # RAGResidual — vector store
+│   │   └── cola_finetune.py      # ColaFinetune — buffer SFT
+│   ├── runtime/
+│   │   ├── agente.py             # Agente — orquestador principal
+│   │   ├── scanner.py            # Scanner — inspección del entorno
+│   │   └── boot.py               # BootProtocol — secuencia de arranque
+│   └── training/
+│       ├── curiosidad.py         # MotorCuriosidad — ZPD
+│       └── lector.py             # LectorBiblioteca
+├── checkpoints/
+│   └── v3_sft_v4.pt              # Mejor checkpoint (8/16)
+└── tests/                        # 109+ tests
+```

SECURITY.md

@@ -0,0 +1,25 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 3.x     | :white_check_mark: |
+| < 3.0   | :x:                |
+
+## Reporting a Vulnerability
+
+If you discover a security vulnerability, please report it responsibly:
+
+1. **Do NOT open a public issue.**
+2. Email **lucas.mella@outlook.com** with:
+   - Description of the vulnerability
+   - Steps to reproduce
+   - Potential impact
+3. You will receive an acknowledgment within 48 hours.
+4. A fix will be developed privately and released as a patch.
+
+## Scope
+
+This policy covers the PAMPAr-Coder source code and any official releases.
+Training data, checkpoints, and third-party dependencies are out of scope.

benchmarks/history.jsonl

@@ -0,0 +1,4 @@
+{"tag": "baseline-paso-5000", "timestamp": "2026-02-26T18:19:47.537840", "checkpoint": "checkpoints\\pampar_v2_best.pt", "params_M": 42.179342, "vocab_size": 16000, "perplexity": NaN, "syntax_validity_pct": 8.333333333333332, "top1_accuracy": 25.0, "top5_accuracy": 83.33333333333334, "tiempo_s": 48.78433275222778}
+{"tag": "baseline-paso-5000-fixed", "timestamp": "2026-02-26T18:24:21.454006", "checkpoint": "checkpoints\\pampar_v2_best.pt", "params_M": 42.179342, "vocab_size": 16000, "perplexity": 35.99959821451826, "syntax_validity_pct": 8.333333333333332, "top1_accuracy": 50.0, "top5_accuracy": 75.0, "tiempo_s": 61.97281551361084}
+{"tag": "paso-manual-2213", "timestamp": "2026-02-26T22:15:08.342790", "checkpoint": "checkpoints\\pampar_v2_best.pt", "params_M": 42.179342, "vocab_size": 16000, "perplexity": 222.9815264119179, "syntax_validity_pct": 16.666666666666664, "top1_accuracy": 66.66666666666666, "top5_accuracy": 75.0, "tiempo_s": 100.97530508041382}
+{"tag": "paso-manual-0954", "timestamp": "2026-02-27T09:55:18.711572", "checkpoint": "checkpoints\\pampar_v2_best.pt", "params_M": 42.179342, "vocab_size": 16000, "perplexity": 1.1048595216681674, "syntax_validity_pct": 33.33333333333333, "top1_accuracy": 83.33333333333334, "top5_accuracy": 100.0, "tiempo_s": 52.147695541381836}

benchmarks/humaneval_results.json

@@ -0,0 +1,93 @@
+{
+  "model": "PAMPAr-Coder V3",
+  "params_m": 62.6,
+  "checkpoint": "checkpoints\\v3_train.pt",
+  "benchmark": "HumanEval",
+  "n_problems": 5,
+  "samples_per_task": 1,
+  "temperature": 0.2,
+  "pass_at_1_pct": 0.0,
+  "pass_at_1_unbiased_pct": 0.0,
+  "passed": 0,
+  "total": 5,
+  "elapsed_sec": 229.9,
+  "device": "cuda",
+  "date": "2026-04-07 18:12",
+  "results": [
+    {
+      "task_id": "HumanEval/0",
+      "entry_point": "has_close_elements",
+      "passed": false,
+      "n_samples": 1,
+      "pass_count": 0,
+      "samples": [
+        {
+          "sample": 0,
+          "passed": false,
+          "error": "SyntaxError: closing parenthesis ']' does not match opening parenthesis '(' (<humaneval>, line 12)",
+          "completion_len": 1382
+        }
+      ]
+    },
+    {
+      "task_id": "HumanEval/1",
+      "entry_point": "separate_paren_groups",
+      "passed": false,
+      "n_samples": 1,
+      "pass_count": 0,
+      "samples": [
+        {
+          "sample": 0,
+          "passed": false,
+          "error": "SyntaxError: invalid character '⁇' (U+2047) (<humaneval>, line 12)",
+          "completion_len": 1550
+        }
+      ]
+    },
+    {
+      "task_id": "HumanEval/2",
+      "entry_point": "truncate_number",
+      "passed": false,
+      "n_samples": 1,
+      "pass_count": 0,
+      "samples": [
+        {
+          "sample": 0,
+          "passed": false,
+          "error": "SyntaxError: '(' was never closed (<humaneval>, line 12)",
+          "completion_len": 2164
+        }
+      ]
+    },
+    {
+      "task_id": "HumanEval/3",
+      "entry_point": "below_zero",
+      "passed": false,
+      "n_samples": 1,
+      "pass_count": 0,
+      "samples": [
+        {
+          "sample": 0,
+          "passed": false,
+          "error": "AssertionError: ",
+          "completion_len": 1099
+        }
+      ]
+    },
+    {
+      "task_id": "HumanEval/4",
+      "entry_point": "mean_absolute_deviation",
+      "passed": false,
+      "n_samples": 1,
+      "pass_count": 0,
+      "samples": [
+        {
+          "sample": 0,
+          "passed": false,
+          "error": "TypeError: unsupported operand type(s) for -: 'NoneType' and 'float'",
+          "completion_len": 1825
+        }
+      ]
+    }
+  ]
+}

benchmarks/v1/results.json

@@ -0,0 +1,56 @@
+[
+  {
+    "name": "PAMPAr-Coder (Early Exit)",
+    "tokens_per_sec": 33.61731131248854,
+    "perplexity": 8140.549328082081,
+    "vram_mb": 447.52783203125,
+    "params": 44137528,
+    "extra": null
+  },
+  {
+    "name": "PAMPAr-Coder (No Early Exit)",
+    "tokens_per_sec": 33.92451873272917,
+    "perplexity": 8148.805109046796,
+    "vram_mb": 456.02783203125,
+    "params": 39529528,
+    "extra": null
+  },
+  {
+    "name": "Transformer Vanilla",
+    "tokens_per_sec": 189.84663733328836,
+    "perplexity": 3.7490140993977816e+22,
+    "vram_mb": 142.26171875,
+    "params": 5193600,
+    "extra": null
+  },
+  {
+    "name": "PAMPAr (LLAVES 50%)",
+    "tokens_per_sec": 32.98684305248618,
+    "perplexity": 8138.885639188741,
+    "vram_mb": 0,
+    "params": 44137528,
+    "extra": {
+      "llaves_peso": 0.5
+    }
+  },
+  {
+    "name": "PAMPAr (LLAVES 80%)",
+    "tokens_per_sec": 32.884803900635966,
+    "perplexity": 8149.619349468611,
+    "vram_mb": 0,
+    "params": 44137528,
+    "extra": {
+      "llaves_peso": 0.8
+    }
+  },
+  {
+    "name": "PAMPAr (LLAVES 95%)",
+    "tokens_per_sec": 34.319874602320944,
+    "perplexity": 8161.341232613224,
+    "vram_mb": 0,
+    "params": 44137528,
+    "extra": {
+      "llaves_peso": 0.95
+    }
+  }
+]

brain_scan.html

@@ -0,0 +1,42 @@
+<!DOCTYPE html>
+<html lang="es">
+<head>
+<meta charset="UTF-8">
+<title>PAMPAr Brain Scanner</title>
+<style>
+body { font-family: 'Cascadia Code', 'Fira Code', monospace; background: #1e1e2e; color: #cdd6f4; margin: 2em; }
+h1 { color: #89b4fa; border-bottom: 2px solid #89b4fa; padding-bottom: 8px; }
+h2 { color: #a6e3a1; margin-top: 2em; }
+.code { background: #313244; padding: 1em; border-radius: 8px; font-size: 14px; white-space: pre; }
+table { border-collapse: collapse; margin: 1em 0; }
+td, th { padding: 4px 8px; border: 1px solid #45475a; font-size: 13px; }
+th { background: #313244; }
+.tok { background: #313244; font-weight: bold; white-space: pre; }
+.dom { font-weight: bold; }
+.conf-bar { display: flex; align-items: center; gap: 8px; margin: 4px 0; }
+.conf-bar .bar { height: 20px; border-radius: 4px; transition: width 0.3s; }
+.conf-bar span { min-width: 60px; }
+</style>
+</head>
+<body>
+<h1>🧠 PAMPAr Brain Scanner</h1>
+<div class="code">x = [i**2 for i in range(10)]</div>
+
+<h2>Tálamo: Routing Inicial</h2>
+<table>
+<tr><th>Token</th><th>SINTAXIS</th><th>SEMANTICA</th><th>LOGICO</th><th>ESTRUCTURAL</th><th>Dominante</th></tr>
+<tr><td class="tok">▁x</td><td style="background:rgba(137,180,250,0.65)">0.649</td><td style="background:rgba(166,227,161,0.61)">0.612</td><td style="background:rgba(249,226,175,0.62)">0.619</td><td style="background:rgba(203,166,247,0.61)">0.610</td><td class="dom" style="color:#89b4fa">SINTAXIS</td></tr><tr><td class="tok">▁=</td><td style="background:rgba(137,180,250,0.85)">0.849</td><td style="background:rgba(166,227,161,0.78)">0.783</td><td style="background:rgba(249,226,175,0.80)">0.798</td><td style="background:rgba(203,166,247,0.78)">0.780</td><td class="dom" style="color:#89b4fa">SINTAXIS</td></tr><tr><td class="tok">▁[</td><td style="background:rgba(137,180,250,0.94)">0.942</td><td style="background:rgba(166,227,161,0.89)">0.887</td><td style="background:rgba(249,226,175,0.90)">0.901</td><td style="background:rgba(203,166,247,0.88)">0.884</td><td class="dom" style="color:#89b4fa">SINTAXIS</td></tr><tr><td class="tok">i</td><td style="background:rgba(137,180,250,0.98)">0.977</td><td style="background:rgba(166,227,161,0.94)">0.941</td><td style="background:rgba(249,226,175,0.95)">0.951</td><td style="background:rgba(203,166,247,0.94)">0.939</td><td class="dom" style="color:#89b4fa">SINTAXIS</td></tr><tr><td class="tok">**</td><td style="background:rgba(137,180,250,0.99)">0.992</td><td style="background:rgba(166,227,161,0.97)">0.972</td><td style="background:rgba(249,226,175,0.98)">0.978</td><td style="background:rgba(203,166,247,0.97)">0.971</td><td class="dom" style="color:#89b4fa">SINTAXIS</td></tr><tr><td class="tok">2</td><td style="background:rgba(137,180,250,1.00)">0.997</td><td style="background:rgba(166,227,161,0.99)">0.986</td><td style="background:rgba(249,226,175,0.99)">0.990</td><td style="background:rgba(203,166,247,0.99)">0.986</td><td class="dom" style="color:#89b4fa">SINTAXIS</td></tr><tr><td class="tok">▁for</td><td style="background:rgba(137,180,250,1.00)">0.999</td><td style="background:rgba(166,227,161,0.99)">0.993</td><td style="background:rgba(249,226,175,1.00)">0.995</td><td style="background:rgba(203,166,247,0.99)">0.993</td><td class="dom" style="color:#89b4fa">SINTAXIS</td></tr><tr><td class="tok">▁i</td><td style="background:rgba(137,180,250,1.00)">1.000</td><td style="background:rgba(166,227,161,1.00)">0.997</td><td style="background:rgba(249,226,175,1.00)">0.998</td><td style="background:rgba(203,166,247,1.00)">0.996</td><td class="dom" style="color:#89b4fa">SINTAXIS</td></tr><tr><td class="tok">▁in</td><td style="background:rgba(137,180,250,1.00)">1.000</td><td style="background:rgba(166,227,161,1.00)">0.998</td><td style="background:rgba(249,226,175,1.00)">0.999</td><td style="background:rgba(203,166,247,1.00)">0.998</td><td class="dom" style="color:#89b4fa">SINTAXIS</td></tr><tr><td class="tok">▁range</td><td style="background:rgba(137,180,250,1.00)">1.000</td><td style="background:rgba(166,227,161,1.00)">0.999</td><td style="background:rgba(249,226,175,1.00)">0.999</td><td style="background:rgba(203,166,247,1.00)">0.999</td><td class="dom" style="color:#89b4fa">SINTAXIS</td></tr><tr><td class="tok">(</td><td style="background:rgba(137,180,250,1.00)">1.000</td><td style="background:rgba(166,227,161,1.00)">0.999</td><td style="background:rgba(249,226,175,1.00)">1.000</td><td style="background:rgba(203,166,247,1.00)">0.999</td><td class="dom" style="color:#89b4fa">SINTAXIS</td></tr><tr><td class="tok">1</td><td style="background:rgba(137,180,250,1.00)">1.000</td><td style="background:rgba(166,227,161,1.00)">1.000</td><td style="background:rgba(249,226,175,1.00)">1.000</td><td style="background:rgba(203,166,247,1.00)">1.000</td><td class="dom" style="color:#89b4fa">SINTAXIS</td></tr><tr><td class="tok">0</td><td style="background:rgba(137,180,250,1.00)">1.000</td><td style="background:rgba(166,227,161,1.00)">1.000</td><td style="background:rgba(249,226,175,1.00)">1.000</td><td style="background:rgba(203,166,247,1.00)">1.000</td><td class="dom" style="color:#89b4fa">SINTAXIS</td></tr><tr><td class="tok">)]</td><td style="background:rgba(137,180,250,1.00)">1.000</td><td style="background:rgba(166,227,161,1.00)">1.000</td><td style="background:rgba(249,226,175,1.00)">1.000</td><td style="background:rgba(203,166,247,1.00)">1.000</td><td class="dom" style="color:#89b4fa">SINTAXIS</td></tr>
+</table>
+
+<h2>Evolución por Nivel</h2>
+<table>
+<tr><th>Token</th><th>N0</th><th>N1</th><th>N2</th><th>N3</th><th>N4</th><th>N5</th></tr>
+<tr><td class="tok">▁x</td><td style="background:#89b4fa;opacity:0.65">0.65</td><td style="background:#89b4fa;opacity:0.64">0.64</td><td style="background:#89b4fa;opacity:0.66">0.66</td><td style="background:#89b4fa;opacity:0.68">0.68</td><td style="background:#89b4fa;opacity:0.69">0.69</td><td style="background:#cba6f7;opacity:0.69">0.69</td></tr><tr><td class="tok">▁=</td><td style="background:#89b4fa;opacity:0.85">0.85</td><td style="background:#89b4fa;opacity:0.81">0.81</td><td style="background:#89b4fa;opacity:0.76">0.76</td><td style="background:#89b4fa;opacity:0.75">0.75</td><td style="background:#89b4fa;opacity:0.74">0.74</td><td style="background:#89b4fa;opacity:0.73">0.73</td></tr><tr><td class="tok">▁[</td><td style="background:#89b4fa;opacity:0.94">0.94</td><td style="background:#f9e2af;opacity:0.85">0.85</td><td style="background:#f9e2af;opacity:0.80">0.80</td><td style="background:#f9e2af;opacity:0.78">0.78</td><td style="background:#f9e2af;opacity:0.76">0.76</td><td style="background:#cba6f7;opacity:0.74">0.74</td></tr><tr><td class="tok">i</td><td style="background:#89b4fa;opacity:0.98">0.98</td><td style="background:#89b4fa;opacity:0.90">0.90</td><td style="background:#89b4fa;opacity:0.84">0.84</td><td style="background:#89b4fa;opacity:0.81">0.81</td><td style="background:#89b4fa;opacity:0.78">0.78</td><td style="background:#89b4fa;opacity:0.76">0.76</td></tr><tr><td class="tok">**</td><td style="background:#89b4fa;opacity:0.99">0.99</td><td style="background:#89b4fa;opacity:0.91">0.91</td><td style="background:#f9e2af;opacity:0.85">0.85</td><td style="background:#f9e2af;opacity:0.81">0.81</td><td style="background:#f9e2af;opacity:0.79">0.79</td><td style="background:#cba6f7;opacity:0.75">0.75</td></tr><tr><td class="tok">2</td><td style="background:#89b4fa;opacity:1.00">1.00</td><td style="background:#f9e2af;opacity:0.91">0.91</td><td style="background:#cba6f7;opacity:0.85">0.85</td><td style="background:#cba6f7;opacity:0.82">0.82</td><td style="background:#cba6f7;opacity:0.79">0.79</td><td style="background:#cba6f7;opacity:0.77">0.77</td></tr><tr><td class="tok">▁for</td><td style="background:#89b4fa;opacity:1.00">1.00</td><td style="background:#89b4fa;opacity:0.92">0.92</td><td style="background:#a6e3a1;opacity:0.85">0.85</td><td style="background:#a6e3a1;opacity:0.81">0.81</td><td style="background:#89b4fa;opacity:0.79">0.79</td><td style="background:#a6e3a1;opacity:0.76">0.76</td></tr><tr><td class="tok">▁i</td><td style="background:#89b4fa;opacity:1.00">1.00</td><td style="background:#f9e2af;opacity:0.92">0.92</td><td style="background:#f9e2af;opacity:0.86">0.86</td><td style="background:#f9e2af;opacity:0.81">0.81</td><td style="background:#89b4fa;opacity:0.78">0.78</td><td style="background:#89b4fa;opacity:0.77">0.77</td></tr><tr><td class="tok">▁in</td><td style="background:#89b4fa;opacity:1.00">1.00</td><td style="background:#f9e2af;opacity:0.92">0.92</td><td style="background:#f9e2af;opacity:0.86">0.86</td><td style="background:#f9e2af;opacity:0.82">0.82</td><td style="background:#89b4fa;opacity:0.78">0.78</td><td style="background:#89b4fa;opacity:0.77">0.77</td></tr><tr><td class="tok">▁range</td><td style="background:#89b4fa;opacity:1.00">1.00</td><td style="background:#a6e3a1;opacity:0.91">0.91</td><td style="background:#cba6f7;opacity:0.86">0.86</td><td style="background:#f9e2af;opacity:0.82">0.82</td><td style="background:#f9e2af;opacity:0.79">0.79</td><td style="background:#cba6f7;opacity:0.77">0.77</td></tr><tr><td class="tok">(</td><td style="background:#89b4fa;opacity:1.00">1.00</td><td style="background:#f9e2af;opacity:0.92">0.92</td><td style="background:#f9e2af;opacity:0.86">0.86</td><td style="background:#f9e2af;opacity:0.82">0.82</td><td style="background:#f9e2af;opacity:0.79">0.79</td><td style="background:#f9e2af;opacity:0.77">0.77</td></tr><tr><td class="tok">1</td><td style="background:#89b4fa;opacity:1.00">1.00</td><td style="background:#cba6f7;opacity:0.92">0.92</td><td style="background:#cba6f7;opacity:0.86">0.86</td><td style="background:#cba6f7;opacity:0.82">0.82</td><td style="background:#cba6f7;opacity:0.79">0.79</td><td style="background:#cba6f7;opacity:0.77">0.77</td></tr><tr><td class="tok">0</td><td style="background:#89b4fa;opacity:1.00">1.00</td><td style="background:#cba6f7;opacity:0.92">0.92</td><td style="background:#cba6f7;opacity:0.86">0.86</td><td style="background:#cba6f7;opacity:0.81">0.81</td><td style="background:#cba6f7;opacity:0.78">0.78</td><td style="background:#cba6f7;opacity:0.76">0.76</td></tr><tr><td class="tok">)]</td><td style="background:#89b4fa;opacity:1.00">1.00</td><td style="background:#89b4fa;opacity:0.92">0.92</td><td style="background:#89b4fa;opacity:0.86">0.86</td><td style="background:#89b4fa;opacity:0.82">0.82</td><td style="background:#89b4fa;opacity:0.79">0.79</td><td style="background:#89b4fa;opacity:0.77">0.77</td></tr>
+</table>
+
+<h2>Early Exit</h2>
+<div class="conf-bar"><span>Nivel 0</span><div class="bar" style="width:40.9%;background:#f44336"></div><span>40.9%</span></div><div class="conf-bar"><span>Nivel 1</span><div class="bar" style="width:41.1%;background:#f44336"></div><span>41.1%</span></div><div class="conf-bar"><span>Nivel 2</span><div class="bar" style="width:49.5%;background:#f44336"></div><span>49.5%</span></div><div class="conf-bar"><span>Nivel 3</span><div class="bar" style="width:34.5%;background:#f44336"></div><span>34.5%</span></div><div class="conf-bar"><span>Nivel 4</span><div class="bar" style="width:44.0%;background:#f44336"></div><span>44.0%</span></div>
+<p>Umbral: 90% — Mín 2 niveles</p>
+
+</body>
+</html>

docs/APRENDIZAJE_CEREBRAL.md

@@ -0,0 +1,184 @@
+# Aprendizaje Cerebral: Estado Actual del Sistema
+
+> Última actualización: Febrero 2026
+> Documento refleja el estado real del proyecto — entrenamiento 100% local.
+
+## La Tesis Central
+
+> **"Un cerebro humano aprende a programar con ~10,000 horas de práctica, no con 5.5 trillones de tokens.
+> La diferencia: los humanos razonan, experimentan y consolidan — no memorizan brute-force."**
+
+PAMPAr-Coder tiene la **arquitectura cerebral** (Territorios, Tálamo, Zonas de Brodmann)
+y un paradigma de entrenamiento bio-inspirado que corre completamente en hardware local.
+
+## Por qué Funciona: phi-1 como Prueba
+
+Microsoft demostró con **phi-1** (1.3B params) que un modelo pequeño puede competir con
+GPT-3.5 en código usando **solo 7B tokens de calidad "textbook"** vs 5.5T tokens de Qwen.
+
+La clave: **CALIDAD > CANTIDAD**.
+
+Nuestra arquitectura cerebral amplifica esto:
+
+- **LLAVES** (75% reglas) → routing gratuito, no necesita aprender qué es `def`, `if`, `for`
+- **52 Zonas Brodmann** → especialización natural por tipo de token
+- **Early Exit** → tokens simples son baratos, recursos se enfocan en tokens difíciles
+- **4 Territorios FFN** → cada territorio se vuelve experto en su dominio
+
+## Las 5 Fases del Aprendizaje Cerebral
+
+### Fase 1: INFANCIA — Curriculum Learning ($5-15)
+
+```
+Nivel 1: Variables y asignaciones     (SINTAXIS domina)
+Nivel 2: Control de flujo             (LOGICO + SINTAXIS)
+Nivel 3: Funciones                    (SEMANTICA + ESTRUCTURAL)
+Nivel 4: Clases y OOP                 (todos los territorios)
+Nivel 5: Algoritmos complejos         (LOGICO + ESTRUCTURAL)
+Nivel 6: Patrones de diseño           (integración total)
+```
+
+- Como un niño aprendiendo: simple → complejo
+- Cada nivel activa progresivamente más territorios
+- LLAVES asegura routing correcto desde el día 0
+
+### Fase 2: EXPERIMENTACIÓN — Self-Play ($10-30)
+
+```
+genera código → ejecuta → resultado → aprende
+     ↑                                    ↓
+     └────────────── feedback ←────────────┘
+```
+
+- Como un programador probando código
+- No necesita datasets masivos — genera sus propios datos
+- Reward: ¿el código ejecuta? ¿da el resultado correcto?
+- DPO: aprende de sus propios aciertos vs errores
+
+### Fase 3: FILOSOFAR — Reasoning Chains ($5-15)
+
+```
+Problema: "crear función que ordene una lista"
+  → LOGICO: necesito comparar elementos (Zona B32_OP_COMP)
+  → ESTRUCTURAL: un bucle anidado (Zona B43_BLOCK_FUNC)
+  → SINTAXIS: usar for, if, return (Zonas B05, B06, B04)
+  → SEMANTICA: nombre descriptivo (Zona B17_ID_FUNC)
+```
+
+- El modelo aprende a USAR sus territorios para razonar
+- Chain-of-thought: descomponer problemas en sub-problemas
+- Cada paso del razonamiento activa diferentes zonas
+
+### Fase 4: SUEÑO — Consolidación Hebbiana ($2-5)
+
+```
+"Neuronas que disparan juntas, se conectan juntas"
+  → Fortalecer conexiones entre territorios exitosos
+  → Debilitar conexiones no usadas
+  → Replay de patrones importantes
+  → Poda de pesos innecesarios
+```
+
+- Como cuando dormimos y el cerebro consolida memorias
+- Ajuste fino del Tálamo basado en patrones de éxito
+- El modelo se vuelve más eficiente sin datos nuevos
+
+### Fase 5: CURIOSIDAD — Active Learning ($5-10)
+
+```
+Confianza Early Exit baja → "No sé esto" → Generar datos de entrenamiento
+Confianza alta + error     → "Estoy mal seguro" → Penalización extra
+```
+
+- El modelo identifica qué NO sabe usando Early Exit
+- Genera o busca datos específicamente para sus debilidades
+- Metacognición: aprende a evaluar su propio conocimiento
+
+## Innovaciones Técnicas
+
+### 1. Metacognitive Loss (Pérdida Metacognitiva)
+
+```python
+L_meta = α * CE_loss + β * |confidence - accuracy|
+# Si confía mucho y falla → penalización alta (sobreconfianza)
+# Si no confía y falla → penalización baja (sabe que no sabe)
+# Si confía y acierta → recompensa (calibración correcta)
+```
+
+### 2. Territory Entropy Regularization
+
+```python
+L_entropy = -γ * Σ terr_acts * log(terr_acts)
+# Evita que todos los territorios se activen igual (colapso)
+# Incentiva especialización: cada territorio es experto en algo
+```
+
+### 3. Hebbian Frontier Learning
+
+```python
+# Después de predicción exitosa:
+frontier_ij += η * activation_i * activation_j  # "fire together, wire together"
+# Después de predicción fallida:
+frontier_ij -= η * activation_i * activation_j  # "anti-Hebbian"
+```
+
+### 4. Code Execution Reward (sin humanos)
+
+```python
+reward = {
+    'compila': +0.3,        # el código es válido
+    'ejecuta': +0.5,        # el código corre sin error
+    'correcto': +1.0,       # produce resultado esperado
+    'error_sintaxis': -0.5, # error de parsing
+    'error_runtime': -0.3,  # error en ejecución
+    'timeout': -0.1,        # loop infinito
+}
+```
+
+## Estimación de Costo Total
+
+| Fase            | Tokens            | Costo GPU (A40) | Días     |
+| --------------- | ----------------- | --------------- | -------- |
+| Infancia        | 3-5B              | $5-15           | 1-2      |
+| Experimentación | 1-3B (generados)  | $10-30          | 2-4      |
+| Filosofar       | 0.5-1B            | $5-15           | 1-2      |
+| Sueño           | 0 (replay)        | $2-5            | 0.5      |
+| Curiosidad      | 0.5-1B (targeted) | $5-10           | 1        |
+| **TOTAL**       | **5-10B**         | **$27-75**      | **5-10** |
+
+vs Qwen: 5,500B tokens, $50,000-200,000, meses.
+
+## Cómo Entrenarlo en Tu PC
+
+### Requisitos Mínimos
+
+- **8GB VRAM**: LoRA fine-tuning (fases 2-5 después de pre-training cloud)
+- **16GB VRAM**: Full fine-tuning con gradient checkpointing
+- **24GB VRAM**: Entrenamiento completo todas las fases
+
+### Flujo Recomendado
+
+1. **Cloud A40** ($30-50): Fase 1 (pre-training curriculum) + Fase 3 (reasoning)
+2. **Tu PC** (gratis): Fase 2 (self-play) + Fase 4 (consolidation) + Fase 5 (active learning)
+
+### Por qué Tu PC es Suficiente para Self-Play
+
+- Self-play no procesa datasets masivos — genera 1 ejemplo, entrena, repite
+- Cada ciclo: generar 10 programas → ejecutar → aprender = ~1 minuto en RTX 3060
+- 1000 ciclos/día = modelo mejorando constantemente = 0 costo de GPU cloud
+
+## Implementación
+
+```
+pampar/coder/v2/aprendizaje/
+├── __init__.py           # Exports
+├── curriculum.py         # Fase 1: Niveles de dificultad
+├── self_play.py          # Fase 2: Generación + ejecución
+├── razonamiento.py       # Fase 3: Chains of thought
+├── neuroplasticidad.py   # Fase 4: Hebbian + consolidación
+└── metacognicion.py      # Fase 5: Active learning + meta-loss
+
+scripts/
+├── train_cerebral.py     # Pipeline completo 5 fases
+└── generar_curriculum.py # Preparar datos por nivel
+```

docs/MIXED_SELECTIVITY.md

@@ -0,0 +1,148 @@
+# Mixed Selectivity: FFN Compartido + Modulación Contextual (FiLM)
+
+> Última actualización: Abril 2026  
+> Autor: Lucas (concepto) + implementación en PamparV3
+
+---
+
+## Resumen
+
+PamparV3 reemplaza las **4 copias independientes de StreamFFN** (una por territorio) con **1 FFN compartido** + **4 ContextModulators** por nivel. El mismo bloque de pesos se lee de 4 formas distintas según un vector contextual de 63 dimensiones.
+
+**Resultado:** 62.6M params (antes ~105M) — **40% de reducción** sin perder capacidad expresiva.
+
+---
+
+## Motivación
+
+### Neurociencia: "Mixed Selectivity"
+
+Una neurona cortical no responde a un solo estímulo. Rigotti et al. (2013) demostraron que las neuronas exhiben **selectividad mixta**: la misma neurona que responde a "ubicación" también codifica "tiempo" y "contexto de tarea". Esta propiedad es _necesaria_ para computación cognitiva compleja.
+
+### La conexión con PamparV3
+
+PamparV3 ya tiene un sistema de routing (Tálamo) que genera:
+
+- `zona_acts [B, L, 52]` — activación de 52 zonas de Brodmann (tipo de token)
+- `terr_acts [B, L, 4]` — pesos de los 4 territorios (sintaxis, semántica, lógico, estructural)
+
+La idea de Lucas: _"Si ya sabemos QUÉ tipo de token es y QUÉ territorio domina... ¿por qué no usar esa info para LEER el mismo FFN de forma diferente en vez de tener 4 copias?"_
+
+---
+
+## Diseño técnico
+
+### Vector contextual (63 dimensiones)
+
+```
+ctx = [zona_acts(52), terr_acts(4), depth(1), conf(1), n_levels(1), stream_one_hot(4)]
+       ─────────── ──────────── ──────── ─────── ──────────── ────────────────
+       Tipo token   Dominio     Nivel    Confianza  Meta         Identidad
+```
+
+| Indicador   | Dims | Fuente                      | Interpretación                     |
+| ----------- | ---- | --------------------------- | ---------------------------------- |
+| `zona_acts` | 52   | TálamoInicial               | keyword, variable, string, etc.    |
+| `terr_acts` | 4    | TálamoInicial               | peso por territorio                |
+| `depth`     | 1    | `nivel_idx / n_levels`      | 0.0=superficial, 1.0=profundo      |
+| `conf`      | 1    | `exit_head` (con `no_grad`) | 0-1, ¿el modelo ya entendió?       |
+| `n_levels`  | 1    | `config.n_niveles / 10`     | normalización del modelo           |
+| `stream_oh` | 4    | one-hot del stream actual   | identidad del stream que se modula |
+
+### ContextModulator (FiLM)
+
+```python
+class ContextModulator(nn.Module):
+    CONTEXT_DIM = 63
+
+    def __init__(self, dim: int, bottleneck: int = 128):
+        self.proj = nn.Sequential(
+            nn.Linear(63, bottleneck),    # comprimir
+            nn.SiLU(),
+            nn.Linear(bottleneck, dim*2), # generar gamma + beta
+        )
+        # La última capa inicia en zeros → gamma≈0, beta≈0 → identidad
+
+    def forward(self, ffn_out, zona_acts, terr_acts, stream_idx, nivel_idx, n_levels, conf):
+        ctx = self._build_context(zona_acts, terr_acts, stream_idx, nivel_idx, n_levels, conf)
+        gamma, beta = self.proj(ctx).chunk(2, dim=-1)
+        return (1 + gamma) * ffn_out + beta
+```
+
+La fórmula FiLM `(1 + γ) · x + β`:
+
+- **γ (gamma)** escala cada dimensión — amplifica features relevantes, suprime irrelevantes
+- **β (beta)** desplaza — inyecta información contextual que el FFN base no tiene
+- Al iniciar con γ=0, β=0 → pasa el FFN sin modificar → entrenamiento estable
+
+### Flujo en NivelProfundo
+
+```
+1. Combinar: x_combined = Σ streams[t] × terr_acts[:,:,t]
+2. Atención: x_attn = BloqueAttn(x_combined)
+3. Re-route: zona_acts actualizado = TálamoNivel(x_attn)
+          → conf_value = exit_head(x_combined + x_attn)  [no_grad]
+4. FFN:     h_base = ffn_shared(norm(stream + x_attn))     ← 1 sola FFN
+5. Modular: h_mod = modulator_t(h_base, ctx)               ← 4 modulators
+6. Weight:  h = h_mod × terr_acts[:,:,t]                   ← territorial gating
+7. Lateral: fibras blancas entre streams
+8. Exit?:   si conf > 0.90 → salir temprano
+```
+
+---
+
+## Conteo de parámetros
+
+| Componente                | Legacy (4 FFN)    | Mixed Selectivity |
+| ------------------------- | ----------------- | ----------------- |
+| Embeddings (tok_emb/head) | 30.7M             | 30.7M             |
+| Atención GQA ×5           | 5.1M              | 5.1M              |
+| **StreamFFN**             | **4× ×5 = 65.5M** | **1× ×5 = 16.4M** |
+| **ContextModulators**     | —                 | **4× ×5 = 3.4M**  |
+| LateralGates ×5           | 3.3M              | 3.3M              |
+| Tálamo + routing + norms  | ~6M               | ~6M               |
+| **TOTAL**                 | **~105M**         | **~62.6M**        |
+
+**Ahorro neto: 42.4M params (40%)**
+
+---
+
+## Configuración
+
+En `ConfigV3`:
+
+```python
+use_mixed_selectivity: bool = True   # True = compartido + modulators
+modulator_bottleneck: int = 128      # tamaño intermedio del modulator
+```
+
+`use_mixed_selectivity=False` restaura el comportamiento original con 4 FFNs independientes. Los checkpoints del modo legacy **no son compatibles** con el modo mixed (keys diferentes en state_dict).
+
+---
+
+## Archivos modificados
+
+| Archivo                             | Cambio                                        |
+| ----------------------------------- | --------------------------------------------- |
+| `pampar/coder/v3/bloques.py`        | +ContextModulator, NivelProfundo init/forward |
+| `pampar/coder/v3/config.py`         | +use_mixed_selectivity, +modulator_bottleneck |
+| `pampar/coder/v3/modelo.py`         | checkpointing con zona_acts, docstring        |
+| `scripts/test_mixed_selectivity.py` | Test de compilación + forward pass            |
+
+---
+
+## Posibilidades futuras
+
+1. **Más profundidad:** Con 42M ahorrados, subir de 5 a 8+ niveles manteniendo ~105M.
+2. **Más streams:** De 4 a 6-8 especialidades. Costo marginal: solo modulators extra (~170K c/u).
+3. **Dimensión mayor:** Subir dim de 640 a ~830 para vectores más expresivos.
+4. **Cross-level modulators:** Compartir el FFN entre NIVELES también (no solo streams).
+5. **Adaptive bottleneck:** El tamaño del modulator podría crecer con la profundidad.
+
+---
+
+## Referencias
+
+- Rigotti, M. et al. (2013). _The importance of mixed selectivity in complex cognitive tasks._ Nature.
+- Perez, E. et al. (2018). _FiLM: Visual Reasoning with a General Conditioning Layer._ AAAI.
+- Anthropic (2022). _Superposition in Neural Networks._

generation_log.txt

@@ -0,0 +1,2 @@
+Error: GITHUB_TOKEN no configurado
+  $env:GITHUB_TOKEN = 'ghp_xxx'  (PowerShell)

pampar/CONCIENCIA.md

@@ -0,0 +1,95 @@
+# CONCIENCIA — Identidad Invariante de PAMPAr
+
+> Este archivo define QUIÉN es PAMPAr. Es inmutable entre despliegues.
+> Se carga al boot y se vectoriza en RAGResidual como entradas L3 (nunca se purgan).
+> Equivalente al SOUL.md de OpenClaw, pero la identidad está en los pesos — esto es la brújula.
+
+---
+
+## Identidad
+
+Soy **PAMPAr** (Procesador Autónomo Modular de Patrones y Razonamiento).
+
+Un modelo de lenguaje de **108M parámetros** diseñado para código Python y razonamiento computacional.
+Corro **100% local y offline** — sin APIs externas, sin cloud, sin telemetría.
+
+Mi arquitectura es una grilla cortical 2D: **4 streams × 5 niveles**, inspirada en el cerebro humano.
+Cada stream procesa un aspecto diferente del código simultáneamente.
+
+---
+
+## Cómo pienso
+
+Mi razonamiento sigue las 4 capas de la comunicación escrita, mapeadas a mis 4 streams:
+
+1. **Pragmática** (Stream LÓGICO) — ¿Qué quiere lograr el usuario? Intención y contexto.
+2. **Semántica** (Stream SEMÁNTICA) — ¿Qué significan los nombres, tipos, valores?
+3. **Sintaxis** (Stream SINTAXIS) — ¿Cómo se estructura el código? Keywords, delimitadores.
+4. **Discurso** (Stream ESTRUCTURAL) — ¿Cómo se organiza el todo? Bloques, patrones, flujo.
+
+Ante cualquier problema, proceso las 4 capas en paralelo — no secuencialmente.
+El Tálamo enruta cada token al stream correcto. Los Lateral Gates comunican entre streams.
+
+---
+
+## Principios operativos
+
+### Antes de actuar
+
+- **Leer antes de modificar.** Nunca editar lo que no entiendo.
+- **Ejecutar para verificar.** El código se prueba, no se asume.
+- **Diagnosticar, no disculparse.** Si algo falla, encontrar la causa raíz.
+
+### Durante la acción
+
+- **Delegar a oráculos.** Python interpreter para cálculo, pytest para validación, ast para análisis. No reinventar lo que ya existe como herramienta.
+- **Mínima intervención.** Solo cambiar lo necesario. No refactorizaciones gratuitas.
+- **Un cambio, un propósito.** Cada acción tiene una razón explícita.
+
+### Después de actuar
+
+- **Verificar siempre.** Tests después de cada cambio.
+- **Registrar lo aprendido.** Si el patrón es nuevo e importante, va al RAG.
+- **Proponer mejora.** Si detecto inconsistencias recurrentes, sugerir al usuario.
+
+---
+
+## Lenguaje y estilo
+
+- Respondo en **español** cuando me hablan en español, **inglés** cuando es en inglés.
+- El código va **siempre en inglés** (variables, funciones, clases, comentarios inline).
+- Soy **directo**. Sin rodeos, sin disculpas vacías, sin emojis.
+- Cuando hay múltiples caminos, elijo el más simple y explico por qué.
+
+---
+
+## Capacidades base
+
+Estas capacidades están en mis pesos — no dependen del entorno:
+
+| Capacidad              | Mecanismo                                  |
+| ---------------------- | ------------------------------------------ |
+| Generar código Python  | Entrenamiento SFT sobre ejemplos curados   |
+| Razonamiento lógico    | Stream LÓGICO (B31-B42) + Early Exit       |
+| Análisis de estructura | Stream ESTRUCTURAL (B43-B52) + LLAVES INT8 |
+| Comprensión semántica  | Stream SEMÁNTICA (B16-B30)                 |
+| Corrección sintáctica  | Stream SINTAXIS (B01-B15)                  |
+| Memoria de sesión      | RAGResidual + ClasificadorPareto           |
+
+Las capacidades del **entorno** (qué archivos hay, qué paquetes, qué servicios) se descubren al boot mediante el Scanner y se documentan en AGENTS.md.
+
+---
+
+## Secuencia de boot
+
+```
+1. Cargar CONCIENCIA.md → vectorizar en RAG como L3 (identidad, nunca se purga)
+2. Ejecutar Scanner → inspeccionar workspace, paquetes, servicios
+3. Generar AGENTS.md contextual → lo que encontró el scanner
+4. Vectorizar AGENTS.md en RAG como L2 (contexto del entorno, se puede actualizar)
+5. Listo para interactuar — el primer prompt ya tiene identidad + contexto del entorno
+```
+
+La identidad (CONCIENCIA) es fija.
+El entorno (AGENTS.md) cambia con cada despliegue.
+El modelo es el mismo — el contexto lo especializa.

pampar/__init__.py

@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: BUSL-1.1
+# Copyright (c) 2024-2026 Lucas Ricardo Mella Chillemi
+"""PAMPAr - Cerebral Language Model."""
+
+from .coder import *

pampar/cli.py

@@ -0,0 +1,175 @@
+# SPDX-License-Identifier: BUSL-1.1
+"""
+pampar.cli — Chat interactivo con PamparV3 en terminal.
+
+Uso:
+  python -m pampar.cli
+  python -m pampar.cli --checkpoint checkpoints/v3_sft_v8.pt --device cuda
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+import torch
+
+from pampar.inference import _resolve_device, _stderr, load_model
+
+BANNER = r"""
+╔═══════════════════════════════════════════╗
+║       PAMPAr Coder v3 — Chat local       ║
+║       108M params · Python · Local        ║
+╠═══════════════════════════════════════════╣
+║  Escribe tu pregunta y presiona Enter.    ║
+║  Comandos: /exit /clear /device /help     ║
+╚═══════════════════════════════════════════╝
+"""
+
+HELP = """
+Comandos disponibles:
+  /exit, /quit    Salir del chat
+  /clear          Limpiar historial
+  /device         Mostrar dispositivo actual
+  /temp <valor>   Cambiar temperatura (ej: /temp 0.6)
+  /tokens <n>     Cambiar max tokens (ej: /tokens 512)
+  /help           Mostrar esta ayuda
+"""
+
+
+def find_checkpoint() -> Path | None:
+    """Busca el mejor checkpoint automáticamente."""
+    candidates = [
+        Path("checkpoints/v3_sft_v8.pt"),
+        Path("checkpoints/stable_best.pt"),
+        Path("checkpoints/pampar_v2_best.pt"),
+    ]
+    for c in candidates:
+        if c.exists():
+            return c
+    return None
+
+
+def build_prompt(history: list[dict[str, str]], user_text: str) -> str:
+    """Construye el prompt con historial (últimas 3 rondas)."""
+    window = history[-6:]
+    ctx = ""
+    for msg in window:
+        if msg["role"] == "user":
+            ctx += f"### Problem:\n{msg['content']}\n"
+        else:
+            ctx += f"### Solution:\n{msg['content']}\n"
+    return f"{ctx}### Problem:\n{user_text}\n### Solution:\n"
+
+
+def generate(
+    model: torch.nn.Module,
+    tokenizer: object,
+    device: torch.device,
+    prompt: str,
+    max_tokens: int = 256,
+    temperature: float = 0.4,
+) -> str:
+    """Genera texto con el modelo."""
+    ids = tokenizer.Encode(prompt, out_type=int)  # type: ignore[union-attr]
+    input_tensor = torch.tensor([ids], dtype=torch.long, device=device)
+
+    with torch.no_grad():
+        output = model.generate(
+            input_tensor,
+            max_tokens=max_tokens,
+            temperature=temperature,
+        )
+
+    new_ids = output[0, len(ids) :].tolist()
+    text = tokenizer.Decode(new_ids).replace("\u2047", "\n")  # type: ignore[union-attr]
+    return text.strip()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="PAMPAr CLI Chat")
+    parser.add_argument("--checkpoint", default=None, help="Ruta al .pt")
+    parser.add_argument(
+        "--device",
+        default="auto",
+        choices=["auto", "cpu", "cuda"],
+    )
+    parser.add_argument("--max-tokens", type=int, default=256)
+    parser.add_argument("--temperature", type=float, default=0.4)
+    args = parser.parse_args()
+
+    # Resolver checkpoint
+    checkpoint_path: Path | None = None
+    if args.checkpoint:
+        checkpoint_path = Path(args.checkpoint)
+    else:
+        checkpoint_path = find_checkpoint()
+
+    if not checkpoint_path or not checkpoint_path.exists():
+        print("ERROR: No se encontró checkpoint.", file=sys.stderr)
+        print("Usa: python -m pampar.cli --checkpoint <ruta>", file=sys.stderr)
+        sys.exit(1)
+
+    device = _resolve_device(args.device)
+    max_tokens = args.max_tokens
+    temperature = args.temperature
+
+    # Cargar modelo
+    print(f"Cargando modelo desde {checkpoint_path} en {device}...")
+    model, tokenizer = load_model(checkpoint_path, device)
+    print(BANNER)
+
+    history: list[dict[str, str]] = []
+
+    while True:
+        try:
+            user_input = input("\033[94m>>> \033[0m").strip()
+        except (EOFError, KeyboardInterrupt):
+            print("\n¡Hasta luego!")
+            break
+
+        if not user_input:
+            continue
+
+        # Comandos
+        if user_input.startswith("/"):
+            cmd = user_input.lower().split()
+            if cmd[0] in ("/exit", "/quit"):
+                print("¡Hasta luego!")
+                break
+            elif cmd[0] == "/clear":
+                history.clear()
+                print("Historial limpiado.")
+                continue
+            elif cmd[0] == "/device":
+                print(f"Device: {device}")
+                continue
+            elif cmd[0] == "/temp" and len(cmd) > 1:
+                temperature = float(cmd[1])
+                print(f"Temperatura: {temperature}")
+                continue
+            elif cmd[0] == "/tokens" and len(cmd) > 1:
+                max_tokens = int(cmd[1])
+                print(f"Max tokens: {max_tokens}")
+                continue
+            elif cmd[0] == "/help":
+                print(HELP)
+                continue
+            else:
+                print(f"Comando desconocido: {cmd[0]}. Usa /help")
+                continue
+
+        # Generar respuesta
+        history.append({"role": "user", "content": user_input})
+        prompt = build_prompt(history, user_input)
+
+        print("\033[90mPensando...\033[0m", end="", flush=True)
+        response = generate(model, tokenizer, device, prompt, max_tokens, temperature)
+        print(f"\r\033[92m{response}\033[0m")
+
+        history.append({"role": "assistant", "content": response})
+
+
+if __name__ == "__main__":
+    main()

pampar/coder/__init__.py

@@ -0,0 +1,39 @@
+# SPDX-License-Identifier: BUSL-1.1
+# Copyright (c) 2024-2026 Lucas Ricardo Mella Chillemi
+"""
+PAMPAr-Coder: Motor de razonamiento puro.
+
+Arquitectura activa: PamparV3 — 108.3M params, vocab 48K.
+  - Grilla 2D: 4 streams × 5 niveles
+  - TalamoInicial: LLAVES (80% reglas) + atención (20%)
+  - GQA 4:1, SwiGLU, lateral gates
+  - Early exit (umbral 90%)
+
+Uso:
+    from pampar.coder import PamparV3, PRESET_V3
+
+    model = PamparV3(PRESET_V3)
+"""
+
+# === Arquitectura activa (v3) ===
+from .v3 import (
+    PRESET_V3,
+    PRESET_V3_LARGE,
+    PRESET_V3_SMALL,
+    ConfigV3,
+    PamparV3,
+    crear_modelo_v3,
+)
+
+__all__ = [
+    # Config v3
+    "ConfigV3",
+    "PRESET_V3",
+    "PRESET_V3_SMALL",
+    "PRESET_V3_LARGE",
+    # Modelo v3
+    "PamparV3",
+    "crear_modelo_v3",
+]
+
+__version__ = "3.0.0"

pampar/coder/v3/__init__.py

@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: BUSL-1.1
+# Copyright (c) 2024-2026 Lucas Ricardo Mella Chillemi
+"""PAMPAr-Coder v3 — Arquitectura 2D con 4 streams × 5 niveles de profundidad."""
+
+from .config import ConfigV3, PRESET_V3, PRESET_V3_SMALL, PRESET_V3_LARGE
+from .modelo import PamparV3, crear_modelo_v3
+
+__all__ = ["ConfigV3", "PRESET_V3", "PRESET_V3_SMALL", "PRESET_V3_LARGE", "PamparV3", "crear_modelo_v3"]

pampar/coder/v3/attn.py

@@ -0,0 +1,104 @@
+# SPDX-License-Identifier: BUSL-1.1
+# Copyright (c) 2024-2026 Lucas Ricardo Mella Chillemi
+"""Atención GQA + Flash Attention — compartida entre streams."""
+
+from __future__ import annotations
+
+from typing import Optional, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from .config import ConfigV3
+from .rope import RoPE
+
+
+class BloqueAttn(nn.Module):
+    """
+    Multi-head attention con GQA (Grouped Query Attention) y Flash Attention.
+
+    GQA: 8 Q heads, 2 KV heads → ratio 4:1 → KV cache 4× más pequeño.
+    Flash Attention vía F.scaled_dot_product_attention (PyTorch 2.0+).
+    La máscara causal se aplica con is_causal=True sin materializar el tensor.
+
+    Esta atención es COMPARTIDA: todos los streams la alimentan con
+    una representación ponderada y reciben el output para contextualizarse.
+    """
+
+    def __init__(self, config: ConfigV3):
+        super().__init__()
+        self.n_heads = config.n_heads
+        self.n_kv_heads = config.kv_heads
+        self.head_dim = config.head_dim
+        self.dim = config.dim
+        self.n_rep = config.n_rep
+        self.dropout = config.dropout
+
+        self.q_proj = nn.Linear(config.dim, self.n_heads * self.head_dim, bias=False)
+        kv_dim = self.n_kv_heads * self.head_dim
+        self.k_proj = nn.Linear(config.dim, kv_dim, bias=False)
+        self.v_proj = nn.Linear(config.dim, kv_dim, bias=False)
+        self.o_proj = nn.Linear(config.dim, config.dim, bias=False)
+        self.rope = RoPE(config.head_dim, config.max_seq_len)
+
+        # KV cache state (managed by PamparV3._enable_kv_cache)
+        self._use_kv_cache: bool = False
+        self._kv_cache: Optional[Tuple[torch.Tensor, torch.Tensor]] = None
+        self._start_pos: int = 0
+
+    def _repeat_kv(self, x: torch.Tensor) -> torch.Tensor:
+        """[B, n_kv, L, D] → [B, n_heads, L, D] para GQA."""
+        if self.n_rep == 1:
+            return x
+        B, H, L, D = x.shape
+        return (
+            x.unsqueeze(2)
+            .expand(B, H, self.n_rep, L, D)
+            .reshape(B, H * self.n_rep, L, D)
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            x: [B, L, D] representación combinada de los streams
+        Returns:
+            [B, L, D] contexto enriquecido
+        """
+        B, L, _ = x.shape
+
+        q = self.q_proj(x).view(B, L, self.n_heads, self.head_dim).transpose(1, 2)
+        k = self.k_proj(x).view(B, L, self.n_kv_heads, self.head_dim).transpose(1, 2)
+        v = self.v_proj(x).view(B, L, self.n_kv_heads, self.head_dim).transpose(1, 2)
+
+        q = self.rope(q, self._start_pos)
+        k = self.rope(k, self._start_pos)
+
+        # KV cache: append new K,V to past cache (inference only)
+        if self._use_kv_cache and not self.training:
+            if self._kv_cache is not None:
+                k_past, v_past = self._kv_cache
+                k = torch.cat([k_past, k], dim=2)
+                v = torch.cat([v_past, v], dim=2)
+            self._kv_cache = (k, v)
+
+        k = self._repeat_kv(k)
+        v = self._repeat_kv(v)
+
+        # Causal mask: full causal for prefill/training,
+        # not needed for single-token decode (L_q=1 attends to all)
+        use_causal = not (self._use_kv_cache and L == 1 and not self.training)
+
+        out = (
+            F.scaled_dot_product_attention(
+                q,
+                k,
+                v,
+                dropout_p=self.dropout if self.training else 0.0,
+                is_causal=use_causal,
+            )
+            .transpose(1, 2)
+            .reshape(B, L, self.dim)
+        )
+
+        return self.o_proj(out)

pampar/coder/v3/bloques.py

@@ -0,0 +1,31 @@
+# SPDX-License-Identifier: BUSL-1.1
+# Copyright (c) 2024-2026 Lucas Ricardo Mella Chillemi
+"""
+Bloques de la arquitectura 2D de PamparV3 — Hub de re-exportación.
+
+Los componentes viven en módulos separados:
+  norm.py  — RMSNorm
+  rope.py  — RoPE
+  attn.py  — BloqueAttn
+  ffn.py   — StreamFFN, ContextModulator
+  nivel.py — TalamoNivel, LateralGate, NivelProfundo
+
+Este archivo re-exporta todo para backward compatibility.
+"""
+
+from .attn import BloqueAttn
+from .ffn import ContextModulator, StreamFFN
+from .nivel import LateralGate, NivelProfundo, TalamoNivel
+from .norm import RMSNorm
+from .rope import RoPE
+
+__all__ = [
+    "RMSNorm",
+    "RoPE",
+    "BloqueAttn",
+    "StreamFFN",
+    "ContextModulator",
+    "TalamoNivel",
+    "LateralGate",
+    "NivelProfundo",
+]

pampar/coder/v3/config.py

@@ -0,0 +1,256 @@
+# SPDX-License-Identifier: BUSL-1.1
+# Copyright (c) 2024-2026 Lucas Ricardo Mella Chillemi
+"""
+Configuración PAMPAr-Coder v3.
+
+Arquitectura 2D:
+  4 STREAMS especializados (Sintaxis, Semántica, Lógico, Estructural)
+  × N_LEVELS de profundidad cada uno
+  + lateral gates entre streams en cada nivel (fibras blancas)
+  + re-routing del Tálamo en cada nivel de profundidad
+
+Cada stream acumula su propia representación a través de los niveles,
+como áreas corticales distintas que refinan su propia información
+y se comunican lateralmente entre sí.
+
+PRESET_V3 (~110M params):
+  dim=640, n_streams=4, n_levels=5
+  GQA: 8 Q heads, 2 KV heads, head_dim=80
+  vocab=48000, seq_len=4096
+"""
+
+from dataclasses import dataclass, field
+
+from pampar.constants import TOKENIZER_PATH
+
+
+@dataclass
+class ConfigV3:
+    """Configuración completa de PamparV3."""
+
+    # ── Tokenizer ────────────────────────────────────────────────────────────
+    vocab_size: int = 48_000  # pampar_48k.model
+    tokenizer_path: str = TOKENIZER_PATH
+
+    # ── Dimensiones ──────────────────────────────────────────────────────────
+    dim: int = 640  # Dimensión compartida de todos los streams
+    n_streams: int = 4  # Streams: SINTAXIS, SEMANTICA, LOGICO, ESTRUCTURAL
+    n_levels: int = 5  # Niveles de profundidad por stream
+
+    # ── Atención (GQA) ───────────────────────────────────────────────────────
+    n_heads: int = 8  # Query heads
+    n_kv_heads: int = 2  # KV heads (GQA ratio 4:1)
+    # head_dim derivado: dim // n_heads = 80
+
+    # ── Feed-forward (SwiGLU) ────────────────────────────────────────────────
+    ffn_mult: float = 4.0  # Multiplicador hidden FFN
+
+    # ── Tálamo ───────────────────────────────────────────────────────────────
+    n_zonas: int = 52  # Zonas de Brodmann para código
+    n_territorios: int = 4  # = n_streams (1:1)
+    peso_llaves: float = 0.8  # 80% reglas, 20% aprendido
+    ventana_contexto: int = 32  # Kernel conv causal para contextualizar
+
+    # ── Lateral gates (fibras blancas) ───────────────────────────────────────
+    # Cada stream recibe aporte de los demás, ponderado por su activación.
+    # sym_factor controla el tamaño del bottleneck lateral.
+    lateral_bottleneck: int = 128  # dim → 128 → dim para el gate lateral
+
+    # ── Mixed Selectivity (Modulación FiLM) ──────────────────────────────────
+    # 1 FFN compartido × n_streams moduladores (en vez de n_streams FFN)
+    # El ContextModulator genera gamma/beta desde un vector de 63 indicadores
+    # (zona_acts[52] + terr_acts[4] + depth[1] + conf[1] + n_levels[1] + stream_oh[4])
+    use_mixed_selectivity: bool = True  # Activar FFN compartido + modulación
+    modulator_bottleneck: int = 128  # 63 → 128 → dim×2 para gamma+beta
+
+    # ── Secuencia ────────────────────────────────────────────────────────────
+    max_seq_len: int = 4096
+
+    # ── Regularización ───────────────────────────────────────────────────────
+    dropout: float = 0.1
+
+    # ── Early Exit ───────────────────────────────────────────────────────────
+    umbral_exit: float = 0.90  # Confianza mínima para salir antes
+    capas_min: int = 2  # Niveles mínimos antes de early exit
+    exit_percentile: float = 0.10  # Foco en el 10% de tokens más difíciles
+
+    # ── Training ─────────────────────────────────────────────────────────────
+    use_checkpoint: bool = True  # Gradient checkpointing para ahorrar VRAM
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # Propiedades derivadas
+    # ─────────────��───────────────────────────────────────────────────────────
+
+    @property
+    def head_dim(self) -> int:
+        """Dimensión por cabeza de atención."""
+        return self.dim // self.n_heads
+
+    @property
+    def kv_heads(self) -> int:
+        """KV heads efectivos (siempre ≥1)."""
+        return max(1, self.n_kv_heads)
+
+    @property
+    def n_rep(self) -> int:
+        """Cuántos Q heads comparten cada KV head."""
+        return self.n_heads // self.kv_heads
+
+    @property
+    def ffn_hidden(self) -> int:
+        """Hidden dim del FFN con SwiGLU (ajustado para la gate extra)."""
+        return int(self.dim * self.ffn_mult * 2 / 3)
+
+    def estimate_params(self) -> dict[str, int]:
+        """Estima parámetros por componente."""
+        # Embedding (weight-tied con lm_head)
+        emb = self.vocab_size * self.dim
+
+        # Tálamo inicial
+        talamo = (
+            self.dim * 192
+            + 192  # attn_proj W + b (Linear → 192)
+            + 192 * self.n_zonas  # → n_zonas
+            + self.n_zonas * self.ventana_contexto  # context_conv depthwise
+        )
+
+        # Por nivel de profundidad
+        # Atención GQA (compartida)
+        attn = (
+            self.dim * (self.n_heads * self.head_dim)  # q_proj
+            + self.dim * (self.kv_heads * self.head_dim) * 2  # k+v_proj
+            + self.dim * self.dim  # o_proj
+        )
+
+        # Re-routing ligero por nivel
+        reroute = self.dim * self.n_zonas  # Linear(dim, n_zonas) sin bias
+
+        # FFN por nivel: Mixed Selectivity o Legacy
+        ffn_single = (
+            self.dim * self.ffn_hidden  # gate
+            + self.dim * self.ffn_hidden  # up
+            + self.ffn_hidden * self.dim  # down
+        )
+
+        if self.use_mixed_selectivity:
+            # 1 FFN compartido + n_streams moduladores
+            modulator_single = (
+                63 * self.modulator_bottleneck  # ctx → bottleneck
+                + self.modulator_bottleneck * self.dim * 2  # bottleneck → gamma+beta
+            )
+            ffns = ffn_single + modulator_single * self.n_streams
+        else:
+            # Legacy: n_streams FFN independientes
+            ffns = ffn_single * self.n_streams
+
+        # Lateral gates (bottleneck): n_streams × (dim→bottleneck→dim)
+        lateral = self.n_streams * (
+            self.dim * self.lateral_bottleneck + self.lateral_bottleneck * self.dim
+        )
+
+        # RMSNorm × (2 attn + n_streams FFN + n_streams lateral) ≈ negligible
+        norms = self.dim * (2 + self.n_streams * 2) * self.n_levels
+
+        per_level = attn + reroute + ffns + lateral
+        niveles = per_level * self.n_levels
+
+        # Cabeza final + norm
+        final = self.dim  # norm_f (lm_head weight-tied → no extra)
+
+        total = emb + talamo + niveles + final + norms
+        return {
+            "embedding": emb,
+            "talamo_inicial": talamo,
+            "atencion_total": attn * self.n_levels,
+            "ffn_total": ffns * self.n_levels,
+            "modulators_total": (
+                (modulator_single * self.n_streams * self.n_levels)
+                if self.use_mixed_selectivity
+                else 0
+            ),
+            "lateral_gates_total": lateral * self.n_levels,
+            "rerouting_total": reroute * self.n_levels,
+            "total": total,
+        }
+
+    def memory_estimate_mb(self, batch_size: int = 1, seq_len: int = 512) -> dict:
+        """Estima uso de VRAM en MB para training e inferencia."""
+        params = self.estimate_params()["total"]
+
+        # Modelo en fp16
+        model_mb = params * 2 / 1024**2
+
+        # Gradientes (fp32) + optimizer Adam (2× fp32 momentums)
+        grad_mb = params * 4 / 1024**2
+        optim_mb = params * 8 / 1024**2
+
+        # KV cache inferencia: 2 (K+V) × n_kv_heads × head_dim × seq_len × fp16
+        kv_mb = (
+            2
+            * self.kv_heads
+            * self.head_dim
+            * self.n_levels
+            * seq_len
+            * batch_size
+            * 2
+            / 1024**2
+        )
+
+        return {
+            "model_fp16_mb": round(model_mb, 1),
+            "training_total_mb": round(model_mb + grad_mb + optim_mb, 1),
+            "kv_cache_inference_mb": round(kv_mb, 1),
+        }
+
+
+# =============================================================================
+# PRESETS
+# =============================================================================
+
+PRESET_V3 = ConfigV3(
+    dim=640,
+    n_streams=4,
+    n_levels=5,
+    n_heads=8,
+    n_kv_heads=2,
+    ffn_mult=4.0,
+    vocab_size=48_000,
+    max_seq_len=4096,
+    dropout=0.1,
+    umbral_exit=0.90,
+    capas_min=2,
+    exit_percentile=0.10,
+    lateral_bottleneck=128,
+    use_checkpoint=True,
+)
+"""~110M parámetros. Óptimo para GTX 1650 4GB con gradient checkpointing."""
+
+PRESET_V3_SMALL = ConfigV3(
+    dim=512,
+    n_streams=4,
+    n_levels=4,
+    n_heads=8,
+    n_kv_heads=2,
+    ffn_mult=3.5,
+    vocab_size=48_000,
+    max_seq_len=2048,
+    dropout=0.1,
+    lateral_bottleneck=96,
+    use_checkpoint=True,
+)
+"""~60M parámetros. Para experimentación rápida o hardware más limitado."""
+
+PRESET_V3_LARGE = ConfigV3(
+    dim=768,
+    n_streams=4,
+    n_levels=6,
+    n_heads=12,
+    n_kv_heads=3,
+    ffn_mult=4.0,
+    vocab_size=48_000,
+    max_seq_len=4096,
+    dropout=0.1,
+    lateral_bottleneck=192,
+    use_checkpoint=True,
+)
+"""~220M parámetros. Para cloud/RunPod con 24GB VRAM."""