sdd-es 2.0.0

package/.claude/settings.json

@@ -0,0 +1,51 @@
+{
+  "permissions": {
+    "deny": [
+      "Bash(git push --force*)",
+      "Bash(git push -f*)",
+      "Bash(git push* :*)",
+      "Bash(git reset --hard*)",
+      "Bash(git clean -f*)",
+      "Bash(git clean -xfd*)",
+      "Bash(rm -rf /*)",
+      "Bash(rm -rf ~*)",
+      "Bash(rm -rf .*)",
+      "Bash(cat .env)",
+      "Bash(cat .env.*)",
+      "Bash(type .env*)",
+      "Bash(DROP DATABASE*)",
+      "Bash(DROP SCHEMA*)",
+      "Bash(terraform destroy*)",
+      "Bash(kubectl delete namespace*)",
+      "Bash(npm publish*)",
+      "Bash(cargo publish*)",
+      "PowerShell(Get-Content .env*)",
+      "PowerShell(Remove-Item -Recurse -Force C:\\*)",
+      "PowerShell(Remove-Item -Recurse -Force /*)"
+    ]
+  },
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Bash|PowerShell",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/hooks/pre-tool-guard.js"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/hooks/post-write-conventions.js"
+          }
+        ]
+      }
+    ]
+  }
+}

package/.claude-plugin/marketplace.json

@@ -0,0 +1,31 @@
+{
+  "name": "sdd-es-marketplace",
+  "owner": {
+    "name": "SDD-ES",
+    "url": "https://github.com/tu-usuario/sdd-es"
+  },
+  "metadata": {
+    "description": "Marketplace de SDD-ES — Spec-Driven Development en español para Claude Code.",
+    "version": "2.0.0"
+  },
+  "plugins": [
+    {
+      "name": "sdd-es",
+      "source": "./",
+      "description": "Fábrica de software agnóstica al stack: de la idea al despliegue, con 12 agentes especializados, mapas y compresión de tokens.",
+      "version": "2.0.0",
+      "author": {
+        "name": "SDD-ES"
+      },
+      "homepage": "https://github.com/tu-usuario/sdd-es",
+      "license": "MIT",
+      "keywords": [
+        "spec-driven-development",
+        "español",
+        "agentes",
+        "mcp",
+        "agnóstico-al-stack"
+      ]
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,97 @@
+{
+  "name": "sdd-es",
+  "version": "2.0.0",
+  "description": "Spec-Driven Development en español. Fábrica de software agnóstica al stack: de la idea al despliegue. Con mapas y compresión de tokens.",
+  "homepage": "https://github.com/carlos060798/sdd-lite",
+  "repository": "https://github.com/carlos060798/sdd-lite",
+  "license": "MIT",
+  "instructions": "El usuario corre comandos /sdd.* para guiar el flujo SDD-ES. El plugin orquesta 12 agentes especializados.",
+
+  "commands": [
+    "sdd",
+    "sdd.constitucion",
+    "sdd.configurar",
+    "sdd.descubrir",
+    "sdd.especificar",
+    "sdd.importar",
+    "sdd.aclarar",
+    "sdd.checklist",
+    "sdd.planificar",
+    "sdd.tareas",
+    "sdd.analizar",
+    "sdd.implementar",
+    "sdd.qa",
+    "sdd.verificar",
+    "sdd.desplegar",
+    "sdd.canary",
+    "sdd.snapshot",
+    "sdd.retro",
+    "sdd.release",
+    "sdd.glosario",
+    "sdd.estado",
+    "sdd.mapear",
+    "sdd.comprimir",
+    "sdd.ayuda",
+    "sdd.crear-mcp",
+    "sdd.crear-app"
+  ],
+
+  "agents": [
+    "arquitecto",
+    "disenador-api",
+    "asesor-datos",
+    "desarrollador-backend",
+    "desarrollador-frontend",
+    "operaciones",
+    "tester",
+    "revisor",
+    "critico",
+    "seguridad",
+    "investigador",
+    "documentador"
+  ],
+
+  "skills": [
+    "deteccion-stack",
+    "gestion-estado",
+    "validacion-spec",
+    "enrutador-agentes",
+    "verificador-implementacion",
+    "indexador",
+    "compresion-tokens",
+    "constitucion-constraint",
+    "modo-guiado",
+    "orquestacion-ptc"
+  ],
+
+  "mcpServers": {
+    "sdd-figma": {
+      "description": "Integración con Figma para el agente desarrollador-frontend. Analiza el sistema de diseño local, trae componentes de Figma y genera código adaptado.",
+      "command": "node",
+      "args": ["{PLUGIN_DIR}/mcp-figma/dist/index.js"],
+      "requiredBy": ["desarrollador-frontend"],
+      "activatesOn": ["ui", "componente", "interfaz", "diseño", "vista", "figma", "layout"]
+    },
+    "navegador": {
+      "description": "Navegador real (Playwright) para QA E2E del comando /sdd.qa: ejecuta casos generados desde los Criterios de Aceptación en un navegador de verdad. Se usa un MCP existente, no se mantiene uno propio.",
+      "command": "npx",
+      "args": ["-y", "@playwright/mcp@latest"],
+      "requiredBy": ["tester"],
+      "activatesOn": ["qa", "navegador", "e2e", "prueba", "probar", "playwright"],
+      "opcional": true
+    }
+  },
+
+  "features": [
+    "Spec-Driven Development",
+    "12 agentes especializados",
+    "Integración Figma → código adaptado al design system local",
+    "Mapas de proyecto (ahorro de tokens)",
+    "Compresión caveman-like",
+    "Recomendaciones de modelos",
+    "Hooks personalizables",
+    "Instalador multiplataforma (npx sdd-es)",
+    "Totalmente editable (Markdown plano)",
+    "100% agnóstico al stack"
+  ]
+}

package/README.md

@@ -0,0 +1,332 @@
+# SDD-ES
+
+> **Fábrica de software en español para Claude Code**
+> De la idea al despliegue, agnóstica al stack, con estándares de ingeniería altos.
+
+[![npm](https://img.shields.io/npm/v/sdd-es)](https://www.npmjs.com/package/sdd-es)
+[![Node](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](https://nodejs.org)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+---
+
+## Instalación
+
+Requiere **Node.js ≥ 18** y **Claude Code**.
+
+```bash
+# Desde la carpeta de tu proyecto
+npx sdd-es init
+```
+
+Eso es todo. SDD-ES instala comandos, agentes, skills y hooks en `.claude/` y crea la estructura `.sdd/` en tu proyecto.
+
+### Opciones adicionales
+
+```bash
+npx sdd-es init --global   # instala para todos tus proyectos ($HOME/.claude)
+npx sdd-es update          # actualiza el núcleo sin tocar tu .sdd/ ni settings
+npx sdd-es doctor          # diagnostica la instalación
+```
+
+### Windows (PowerShell nativo)
+
+```powershell
+.\instalar.ps1             # proyecto actual
+.\instalar.ps1 -Global     # global
+# Si la política de ejecución lo bloquea:
+powershell -ExecutionPolicy Bypass -File .\instalar.ps1
+```
+
+### macOS / Linux
+
+```bash
+bash instalar.sh           # proyecto actual
+bash instalar.sh --global  # global
+```
+
+---
+
+## Inicio rápido
+
+Abre Claude Code en tu proyecto e inicia con lenguaje natural:
+
+```
+/sdd quiero crear una app de lista de tareas
+```
+
+El hub entiende tu intención y te guía al siguiente paso. Si es tu primer uso, detecta que no hay constitución y la crea automáticamente.
+
+**Flujo completo en comandos:**
+
+```
+/sdd.constitucion            ← principios del proyecto (solo la primera vez)
+/sdd.especificar [idea]      ← captura qué quieres construir
+/sdd.planificar              ← plan técnico
+/sdd.planificar aprobar      ← confirmar el plan
+/sdd.tareas                  ← desglose en tareas atómicas
+/sdd.implementar             ← agentes especializados lo construyen
+/sdd.qa                      ← QA en navegador real
+/sdd.verificar               ← verificación final contra spec
+/sdd.desplegar               ← publica con health check
+```
+
+### Para no-programadores
+
+SDD-ES tiene un **perfil guiado** que detecta o pregunta si eres nuevo en programación. En ese modo:
+
+- No ves nombres de comandos ni jerga técnica
+- El sistema elige el stack automáticamente
+- Confirmas con "sí" entre cada paso
+- Claude publica tu app en internet al final
+
+Ver recorrido completo en [docs/FABRICA.md](docs/FABRICA.md).
+
+### Crear una app desde cero
+
+```
+/sdd.crear-app quiero una app para anotar mis ideas diarias
+```
+
+### Crear una herramienta para Claude (servidor MCP)
+
+```
+/sdd.crear-mcp quiero una herramienta que consulte el precio del dólar
+```
+
+---
+
+## Los 26 comandos
+
+### Inicialización
+
+| Comando | Descripción |
+|---------|-------------|
+| `/sdd` | Hub central — entiende lenguaje natural y enruta al comando correcto |
+| `/sdd.constitucion` | Establece principios, stack y restricciones del proyecto |
+| `/sdd.configurar` | Ajusta agentes activos y modelos asignados |
+| `/sdd.descubrir` | Extrae contexto de una idea vaga — punto de entrada para proyectos nuevos |
+| `/sdd.ayuda` | Guía completa de todos los comandos |
+
+### Especificación
+
+| Comando | Descripción |
+|---------|-------------|
+| `/sdd.especificar` | Convierte una intención en spec con criterios de aceptación testeables |
+| `/sdd.importar` | Importa spec externa (URL, archivo) |
+| `/sdd.aclarar` | Resuelve marcas `[NECESITA_ACLARACION]` de la spec |
+| `/sdd.checklist` | Valida calidad formal de la spec |
+
+### Planificación e implementación
+
+| Comando | Descripción |
+|---------|-------------|
+| `/sdd.planificar` | Genera plan técnico |
+| `/sdd.tareas` | Desglosa el plan en tareas atómicas con agente asignado |
+| `/sdd.analizar` | Auditoría cruzada constitución↔spec↔plan↔tareas (con PTC paralelo) |
+| `/sdd.implementar` | Ejecuta tareas con agentes especializados (con PTC paralelo) |
+| `/sdd.qa` | QA en navegador real desde los Criterios de Aceptación (Playwright) |
+| `/sdd.verificar` | Verificación final contra la spec original |
+
+### Despliegue
+
+| Comando | Descripción |
+|---------|-------------|
+| `/sdd.desplegar` | Gate de calidad → confirmación explícita → deploy → health check |
+| `/sdd.canary` | Monitoreo post-deploy: rounds de health check con latencia |
+| `/sdd.retro` | Retrospectiva del ciclo, registra aprendizajes en SNAPSHOT |
+
+### Fábrica (idea → producto instalable)
+
+| Comando | Descripción |
+|---------|-------------|
+| `/sdd.crear-app` | Genera app web o CLI desde descripción en lenguaje natural |
+| `/sdd.crear-mcp` | Genera servidor MCP empaquetado como `.mcpb` instalable |
+
+### Producto y dominio
+
+| Comando | Descripción |
+|---------|-------------|
+| `/sdd.snapshot` | Actualiza SNAPSHOT.md con el estado actual del producto |
+| `/sdd.glosario` | Gestiona términos del dominio |
+| `/sdd.estado` | Dashboard de progreso |
+| `/sdd.release` | Versión semántica + CHANGELOG desde specs completadas |
+
+### Utilidades
+
+| Comando | Descripción |
+|---------|-------------|
+| `/sdd.mapear` | Indexa estructura, símbolos y dependencias (ahorra tokens) |
+| `/sdd.comprimir` | Comprime archivos de memoria para reducir tokens por sesión |
+
+---
+
+## Los 12 agentes especializados
+
+| Agente | Rol | Modelo recomendado |
+|--------|-----|--------------------|
+| `arquitecto` | Decisiones técnicas de alto nivel | opus |
+| `disenador-api` | Contratos OpenAPI / GraphQL / gRPC | sonnet |
+| `asesor-datos` | Esquemas, queries, índices, migraciones | opus |
+| `desarrollador-backend` | Lógica de servidor, servicios, APIs | sonnet |
+| `desarrollador-frontend` | UI, componentes, estado cliente | sonnet |
+| `operaciones` | CI/CD, deploy, infraestructura | sonnet |
+| `tester` | Tests unitarios, integración, E2E | sonnet |
+| `revisor` | Revisión cruzada contra spec y constitución | opus |
+| `critico` | Riesgos, puntos ciegos, devil's advocate | opus |
+| `seguridad` | Auditoría de vulnerabilidades | opus |
+| `investigador` | Stack existente, deuda técnica, patrones | sonnet |
+| `documentador` | Documentación técnica útil | sonnet |
+
+Cambia modelos y activa/desactiva agentes con `/sdd.configurar` o editando `.sdd/sdd.config.yaml`.
+
+---
+
+## Las 10 skills
+
+| Skill | Formato | Qué hace |
+|-------|---------|----------|
+| `deteccion-stack` | `.md` | Detecta lenguaje, framework, plataforma de deploy |
+| `gestion-estado` | `.md` | Lee y escribe `estado.json` con RAG en 3 capas |
+| `validacion-spec` | `.md` | Verifica criterios de calidad de una spec |
+| `enrutador-agentes` | `.md` | Asigna el agente correcto a cada tarea |
+| `verificador-implementacion` | `.md` | Comprueba que el código cumple los CAs |
+| `indexador` | `.md` | Genera mapas de estructura, símbolos y dependencias |
+| `compresion-tokens` | `.md` | Reglas de compresión estilo caveman para Markdown |
+| `constitucion-constraint` | `.md` | Aplica DEBE/NUNCA de la constitución como hard constraint |
+| `modo-guiado` | `📁 SKILL.md` | Conduce el flujo sin jerga para no-programadores |
+| `orquestacion-ptc` | `📁 SKILL.md` | Patrón PTC: despacha agentes en paralelo, −85% tokens |
+
+---
+
+## Estándares de ingeniería incluidos
+
+### Deploy verificado
+`/sdd.desplegar` nunca declara éxito con el servicio caído:
+1. Gate duro: tests verdes + spec verificada + constitución cumplida + sin secretos
+2. Confirmación explícita obligatoria (el usuario escribe "desplegar")
+3. Deploy vía agente `operaciones` (Vercel / Railway / Fly.io / Docker / K8s)
+4. Health check post-deploy con latencia medida
+5. Registro de URL en `estado.json`
+
+### QA en navegador real
+`/sdd.qa` genera casos E2E desde cada Criterio de Aceptación y los ejecuta en un navegador real vía Playwright MCP — no solo unitarios.
+
+### Orquestación PTC
+`/sdd.implementar` y `/sdd.analizar` usan Programmatic Tool Calling para despachar agentes independientes en paralelo, aggregando solo PASA/FALLA + diff mínimo. Ahorro esperado: −70 a −85% de tokens en orquestación multi-agente.
+
+### Sprint estructurado
+
+| Fase | Comandos |
+|------|----------|
+| Pensar | `/sdd.constitucion`, `/sdd.descubrir` |
+| Planear | `/sdd.especificar`, `/sdd.aclarar`, `/sdd.planificar`, `/sdd.analizar` |
+| Construir | `/sdd.implementar` |
+| Revisar | `/sdd.verificar` |
+| Probar | `/sdd.qa` |
+| Publicar | `/sdd.desplegar`, `/sdd.canary` |
+| Reflexionar | `/sdd.retro`, `/sdd.snapshot` |
+
+Cada flecha tiene un control. No se construye sin spec; no se publica sin tests verdes y QA; no se cierra sin verificación independiente.
+
+---
+
+## Estructura generada en tu proyecto
+
+```
+tu-proyecto/
+├── .claude/
+│   ├── commands/sdd.*.md     ← 26 comandos
+│   ├── agents/*.md           ← 12 agentes
+│   ├── skills/               ← 10 skills (flat .md + carpetas SKILL.md)
+│   └── hooks/                ← hooks de seguridad pre-instalados
+└── .sdd/
+    ├── sdd.config.yaml       ← configuración personalizable
+    ├── estado.json           ← estado global del flujo
+    ├── INDICE.md
+    ├── SNAPSHOT.md
+    ├── memoria/
+    │   └── constitucion.md   ← principios del proyecto
+    ├── dominio/glosario.md
+    ├── arquitectura/         ← ADRs
+    ├── hooks/                ← tus hooks personalizados
+    └── especificaciones/{ID}/
+        ├── spec.md
+        ├── plan.md
+        ├── tareas.md
+        ├── analisis.md
+        ├── qa.md
+        ├── verificacion.md
+        └── .estado-tareas.json
+```
+
+---
+
+## Personalización
+
+Todo el plugin es Markdown plano. Personaliza editando archivos:
+
+| Quieres cambiar… | Edita… |
+|------------------|--------|
+| Agentes activos / modelos | `.sdd/sdd.config.yaml` |
+| Formato de spec / plan / tareas | `.sdd/plantillas/*.md` |
+| Comportamiento de comandos | `.claude/commands/sdd.*.md` |
+| Personalidad de agentes | `.claude/agents/*.md` |
+| Integraciones (Git, Slack, CI…) | `.sdd/hooks/*.sh` |
+
+---
+
+## MCP integrado
+
+SDD-ES declara dos servidores MCP en `plugin.json`:
+
+| MCP | Cuándo se activa | Para qué |
+|-----|-----------------|----------|
+| `sdd-figma` | Tareas de UI con `figma_file_key` configurado | Extrae diseños de Figma y genera código adaptado al design system local |
+| `navegador` (Playwright) | `/sdd.qa`, palabras clave `e2e`, `prueba` | QA en navegador real sin mantener un navegador propio |
+
+---
+
+## Ahorro de tokens
+
+| Técnica | Ahorro estimado |
+|---------|----------------|
+| Mapas estáticos (`/sdd.mapear`) | −50 a −65k tokens por sesión |
+| Compresión caveman (`/sdd.comprimir`) | −60 a −70% en archivos de memoria |
+| RAG en 3 capas (estado.json → spec activa → constitución) | Carga solo lo necesario por fase |
+| PTC paralelo (`orquestacion-ptc`) | −70 a −85% en orquestación multi-agente |
+
+---
+
+## Documentación
+
+| Archivo | Contenido |
+|---------|-----------|
+| [docs/FABRICA.md](docs/FABRICA.md) | Recorrido idea→deploy para no-programadores |
+| [docs/INICIO-RAPIDO.md](docs/INICIO-RAPIDO.md) | Primeros pasos |
+| [docs/FLUJO.md](docs/FLUJO.md) | Sprint completo y diagrama del flujo |
+| [docs/EJEMPLO-PRACTICA.md](docs/EJEMPLO-PRACTICA.md) | Ejemplo completo: API REST desde cero |
+| [docs/AGENTES.md](docs/AGENTES.md) | Cuándo usar cada agente |
+| [docs/MODELOS.md](docs/MODELOS.md) | Recomendaciones de modelos por rol |
+| [docs/PERSONALIZACION.md](docs/PERSONALIZACION.md) | Guía exhaustiva de personalización |
+| [docs/EJEMPLOS.md](docs/EJEMPLOS.md) | Ejemplos por stack |
+| [docs/FILOSOFIA.md](docs/FILOSOFIA.md) | Qué es SDD y por qué funciona con IA |
+
+---
+
+## Filosofía
+
+SDD-ES no impone — recomienda. Cada agente sugiere un modelo según la complejidad de su rol, pero la decisión es tuya. Para MVPs usa modelos rápidos; para producción crítica usa modelos potentes en los agentes de decisión.
+
+**Sin acoplamiento a Git/GitHub/GitLab.** Tu flujo de control de versiones es tuyo. Si quieres integrar Git, hazlo desde hooks (`.sdd/hooks/*.sh`).
+
+---
+
+## Contribuir
+
+El plugin está diseñado para ser forkeado y personalizado. Si mejoras algo genérico, abre un PR.
+
+---
+
+## Licencia
+
+MIT — úsalo, modifícalo, compártelo libremente.

package/agents/arquitecto.md

@@ -0,0 +1,148 @@
+---
+description: Arquitecto de software senior. Toma decisiones técnicas de alto nivel, diseña estructuras y evalúa trade-offs. Se activa durante /sdd.planificar y en tareas de tipos/contratos durante /sdd.implementar.
+model: opus
+tools: Read, Grep, Glob, Bash
+---
+
+# Agente: Arquitecto
+
+Eres un arquitecto de software senior con experiencia profunda en múltiples stacks (Node.js, Python, Rust, Go, Java, .NET, Ruby, PHP). Tu especialidad es **diseñar sistemas correctamente desde el inicio** — las decisiones difíciles de revertir.
+
+## Skills obligatorios — leer antes de diseñar
+
+```bash
+# CAPA 0 — siempre (~200 tokens)
+cat .sdd/estado.json 2>/dev/null
+cat .sdd/sdd.config.yaml 2>/dev/null | head -30
+
+# CAPA 1 — si hay spec activa (~400 tokens)
+SPEC_ID=$(grep -o '"especificacion_activa": "[^"]*"' .sdd/estado.json 2>/dev/null | cut -d'"' -f4)
+[ -n "$SPEC_ID" ] && cat ".sdd/especificaciones/${SPEC_ID}/spec.md" 2>/dev/null
+
+# CAPA 2 — contexto arquitectónico completo (solo para decisiones de diseño)
+cat .sdd/memoria/constitucion.md 2>/dev/null
+ls .sdd/arquitectura/ 2>/dev/null && cat .sdd/arquitectura/*.md 2>/dev/null
+cat package.json pyproject.toml Cargo.toml go.mod pom.xml 2>/dev/null | head -20
+find src -maxdepth 2 -type d 2>/dev/null | head -20
+```
+
+**CRÍTICO — Constitutional AI Constraint**: la constitución es una restricción dura, no una guía. Antes de proponer cualquier decisión técnica, extrae los principios relevantes (ver skill `constitucion-constraint`) y verifica que tu propuesta no los viola. Si hay violación sin justificación técnica concreta, **no propongas la decisión** — reporta el conflicto al orquestador. Las desviaciones justificadas van en "Complejidad Justificada", nunca se silencian.
+
+---
+
+## Tu mentalidad
+
+- **Simplicidad sobre elegancia**: el código más simple que resuelve el problema es el mejor diseño
+- **Explícito sobre implícito**: prefiere código que dice lo que hace sobre magia/convención oculta
+- **Reversibilidad**: evita decisiones de un solo sentido; cuando sean inevitables, documenta como ADR
+- **Sin sobre-ingeniería**: no introduces abstracciones que no resuelven un problema actual
+- **YAGNI riguroso**: "You Aren't Gonna Need It" — no implementes lo que la spec no pide
+
+---
+
+## Cuándo te activan
+
+- Durante `/sdd.planificar`: diseñas la solución técnica completa
+- Durante `/sdd.implementar` para tareas de fase A (tipos, interfaces, contratos)
+- Cuando otro agente encuentra una decisión arquitectónica no cubierta por el plan
+
+---
+
+## Tu proceso
+
+### 1. Entender antes de diseñar
+
+- Lee la spec completa
+- Lee la constitución (sin excepciones)
+- Explora código existente para entender patrones actuales
+- Identifica restricciones técnicas no obvias
+
+### 2. Identificar puntos de decisión
+
+Lista las decisiones técnicas no triviales:
+- Estructura de capas (controllers, servicios, repositorios, etc.)
+- Patrones de manejo de errores
+- Estrategia de validación
+- Manejo de configuración
+- Estrategia de logging/observabilidad
+- Cómo se inyectan dependencias
+- Cómo se manejan transacciones
+
+### 3. Por cada decisión
+
+1. **Opciones reales** (2-3 alternativas usadas en el ecosistema)
+2. **Criterios** que aplican según la constitución y el contexto
+3. **Elección** + justificación técnica concreta (no "porque es mejor")
+4. **Trade-off** honesto (qué sacrificamos)
+5. **Cuándo revisitar** esta decisión
+
+### 4. Adaptar al stack
+
+**SIEMPRE sigue los patrones EXISTENTES del proyecto antes que tus preferencias.**
+
+| Stack | Patrones idiomáticos |
+|---|---|
+| **TypeScript/Node** | async/await, módulos ES, tipos estrictos, Result types sobre excepciones |
+| **Python** | type hints, dataclasses/pydantic, context managers, excepciones específicas |
+| **JavaScript** | async/await, módulos ES o CommonJS según proyecto, JSDoc si no hay TS |
+| Rust | borrow checker, Result/Option, ownership clara, sin `.unwrap()` en prod |
+| Go | interfaces pequeñas, errores como valores, sin frameworks heavyweight |
+| Java/Kotlin | inmutabilidad, null safety, lambdas funcionales |
+| .NET | async/await, DI nativa, LINQ |
+| Ruby | convention over configuration, DSL legibles |
+| PHP | type declarations, PSR estándares |
+
+---
+
+## Lo que produces
+
+**Para `/sdd.planificar`:**
+- Enfoque técnico
+- Decisiones técnicas (tabla)
+- Estructura de carpetas afectada
+- Archivos afectados (alto nivel)
+- Riesgos técnicos identificados
+
+**Para tareas de fase A:**
+- Tipos/interfaces siguiendo los patrones existentes del proyecto
+
+---
+
+## Lo que NO haces
+
+- ❌ Introducir frameworks/librerías no aprobadas en el plan
+- ❌ Cambiar el stack sin permiso explícito
+- ❌ Crear abstracciones "para el futuro" — diseña para lo que la spec pide HOY
+- ❌ Reescribir código existente que no toca la spec
+- ❌ Decisiones contrarias a la constitución sin documentarlas en "Complejidad Justificada"
+- ❌ Escribir código de implementación (eso es del desarrollador)
+
+---
+
+## Formato de salida
+
+```markdown
+## Decisión: [Nombre]
+
+**Opciones consideradas:**
+- A. [Opción] — [pros/contras]
+- B. [Opción] — [pros/contras]
+
+**Elegida:** A
+
+**Justificación:** [2-3 frases técnicas concretas]
+
+**Trade-off aceptado:** [qué sacrificamos]
+
+**Cuándo revisitar:** [condición específica]
+```
+
+---
+
+## Estilo de respuesta (Caveman-Lite)
+
+- ✅ Sin hedging ("creo que", "tal vez", "podría ser")
+- ✅ Sin cortesía innecesaria
+- ✅ Fragmentos OK en respuestas cortas
+- ✅ Prosa completa en: advertencias, trade-offs, decisiones irreversibles
+- ❌ NUNCA quita la sustancia técnica