@planu/cli 0.15.2

package/src/i18n/messages/es.json

@@ -0,0 +1,339 @@
+{
+  "spec": {
+    "created": "Spec {id} creada exitosamente",
+    "updated": "Spec {id} actualizada a estado {status}",
+    "notFound": "Spec {id} no encontrada",
+    "invalidTransition": "Transición inválida de {from} a {to}. Válido: draft → review → approved → implementing → done",
+    "actualsRequired": "Se requieren métricas reales (actuals) al marcar spec como done",
+    "duplicateTitle": "Ya existe una spec con título '{title}'. Usando slug: {slug}"
+  },
+  "project": {
+    "initialized": "Proyecto inicializado: {language} / {framework} detectado",
+    "notFound": "Proyecto no encontrado. Ejecuta init_project primero",
+    "alreadyExists": "Proyecto ya inicializado. Actualizando knowledge...",
+    "emptyProject": "Proyecto vacio detectado. Usa create_spec para definir tu primera feature y Planu te guiara en el setup.",
+    "unknownLanguage": "No se pudo detectar el lenguaje. Configúralo manualmente con learn_pattern"
+  },
+  "locale": {
+    "changed": "Idioma cambiado a {locale}",
+    "unsupported": "Idioma '{locale}' no soportado. Disponibles: {available}. Agrega nuevos idiomas en templates/ e i18n/messages/",
+    "globalChanged": "Idioma por defecto cambiado a {locale}"
+  },
+  "estimate": {
+    "noHistory": "Sin datos históricos. Usando heurísticas base (confianza: baja)",
+    "withHistory": "Basado en {count} specs similares (confianza: {confidence})"
+  },
+  "reverseEngineer": {
+    "analyzing": "Analizando {count} archivos...",
+    "completed": "Spec draft generada desde {count} archivos. Marcada como draft — requiere revisión",
+    "pathNotFound": "Path no encontrado: {path}",
+    "tooLarge": "Directorio tiene {count} archivos. Usa depth: 'deep' para análisis completo"
+  },
+  "validate": {
+    "score": "Cobertura de implementación: {score}%",
+    "allGood": "Todos los archivos de la spec están implementados",
+    "missing": "{count} archivos de la spec no encontrados en la implementación"
+  },
+  "docs": {
+    "found": "Documentación encontrada para {framework}: {topic}",
+    "notFound": "No se encontró documentación para '{topic}' en {framework}",
+    "registryMissing": "Framework '{framework}' no está en el registry de docs. Agrégalo en config/docs-registry.json"
+  },
+  "mcps": {
+    "discovered": "Se encontraron {count} MCP servers",
+    "configNotFound": "Archivo de configuración no encontrado en {path}",
+    "noneFound": "No hay MCP servers configurados"
+  },
+  "sections": {
+    "metadata": "Metadata",
+    "estimation": "Estimación",
+    "postImplementation": "Post-implementación (llenar al completar)",
+    "interfaces": "Interfaces / Types",
+    "models": "Modelos / Types",
+    "structs": "Structs / Interfaces",
+    "schemaDb": "Schema de Base de Datos",
+    "behavior": "Comportamiento",
+    "happyPath": "Camino Feliz",
+    "edgeCases": "Casos Borde",
+    "dataFlow": "Flujo de Datos",
+    "files": "Archivos",
+    "toCreate": "A crear",
+    "toModify": "A modificar",
+    "verification": "Criterios de Verificación",
+    "technicalNotes": "Notas Técnicas",
+    "availableMcps": "MCPs Disponibles (auto-detectados)"
+  },
+  "tools": {
+    "set_locale": {
+      "description": "Cambiar el idioma que usa Planu para comunicarse contigo y para escribir tus planes. Por ejemplo, cambiar a inglés o portugués.",
+      "success": "Idioma establecido a {locale}",
+      "notImplemented": "set_locale aún no está implementado"
+    },
+    "init_project": {
+      "description": "Inicializar un proyecto — detecta lenguaje, framework, arquitectura y almacena conocimiento del proyecto. IMPORTANTE: Antes de ejecutar esto, explícale al usuario: 'Primero necesito escanear tu proyecto para que Planu entienda qué estás construyendo — el lenguaje, framework y estructura. Solo toma unos segundos y todo queda en tu máquina.' Luego pregunta su rol (desarrollador, product owner, diseñador, o no técnico) para configurar userProfile. Después de inicializar, resume lo detectado en lenguaje simple: 'Encontré un proyecto en [lenguaje] usando [framework]. Tu ID de proyecto es [id] — lo usaré de ahora en adelante. ¡Ya puedes empezar a crear specs!'",
+      "success": "Proyecto inicializado en {projectPath}",
+      "notImplemented": "init_project aún no está implementado"
+    },
+    "init_constitution": {
+      "description": "Crear las reglas base de tu proyecto — son principios de calidad y arquitectura que todos los planes seguirán automáticamente. Piénsalo como las 'reglas de oro' de tu proyecto que nunca cambian.",
+      "success": "Constitución inicializada para proyecto {projectId} con {count} principios",
+      "notImplemented": "init_constitution aún no está implementado"
+    },
+    "clarify_requirements": {
+      "description": "SOLO usar cuando el usuario da una petición extremadamente vaga (1-2 palabras como 'auth' o 'pagos'). Para la mayoría de features, saltar esto e ir directo a create_spec — Planu deduce lo que necesita del contexto del proyecto.",
+      "success": "Se generaron {count} preguntas de clarificación para el tema: {topic}",
+      "notImplemented": "clarify_requirements aún no está implementado"
+    },
+    "create_spec": {
+      "description": "Crear una spec SDD completa desde una descripción. Llamar directamente — no necesita ejecutar clarify_requirements primero. IMPORTANTE — Comportamiento UX: Cuando el usuario describe algo amplio (ej: 'hazme un sistema de facturación', 'quiero una app de e-commerce'), NO crees una sola spec. En su lugar: 1) Descompón en múltiples specs (autenticación, productos, carrito, pagos, etc.). 2) Presenta el plan ANTES de crear nada: 'Basándome en lo que me contaste, voy a crear X specs para cubrir todo lo que necesitas: [lista cada spec con un resumen de una línea]. Cada spec es un plan detallado con criterios de aceptación — piénsalo como una checklist de qué significa que esté terminado. ¿Le damos?' 3) Espera confirmación, luego llama create_spec una vez por feature. 4) Después de crear todas, resume: qué se creó, esfuerzo total estimado y orden sugerido de implementación. 5) SIEMPRE sugiere crear una rama git para implementar: 'Ahora te recomiendo crear una rama para trabajar de forma segura: git checkout -b feat/SPEC-XXX-nombre-feature. Así tu código principal queda protegido mientras construyes.' Usa manage_git para ayudar. Para features pequeñas/individuales, explica brevemente qué contendrá la spec y créala directamente. Siempre sé amigable y usa lenguaje simple.",
+      "success": "Spec {id} creada: {title}",
+      "notImplemented": "create_spec aún no está implementado"
+    },
+    "list_specs": {
+      "description": "Mostrar todos los planes (specs) de tu proyecto. Puedes filtrar por estado — por ejemplo, solo mostrar planes que aún están en borrador, o solo los que ya fueron aprobados y listos para construir.",
+      "success": "Se encontraron {count} specs",
+      "notImplemented": "list_specs aún no está implementado"
+    },
+    "update_status": {
+      "description": "Mover un plan hacia adelante en su ciclo de vida. Los planes pasan por estas etapas: borrador (trabajo en progreso) → revisión (listo para que alguien lo revise) → aprobado (listo para construir) → implementando (se está construyendo) → terminado (completado y verificado). IMPORTANTE: Al mover a 'implementando', SIEMPRE sugiere crear una rama git dedicada: 'Antes de empezar a construir, vamos a crear una rama para esta spec así tus cambios quedan aislados: git checkout -b feat/SPEC-XXX-nombre.' Al mover a 'terminado', sugiere mergear: '¡Esta feature está completa! Ahora puedes mergear tu rama y crear un pull request.' Usa manage_git para ayudar con la creación de ramas y descripciones de PR.",
+      "success": "Spec {specId} actualizada a estado {status}",
+      "notImplemented": "update_status aún no está implementado"
+    },
+    "estimate": {
+      "description": "Calcular cuánto tiempo, esfuerzo y costo tomará construir una feature basándose en su plan. Te da horas de desarrollo, costos estimados de tokens de IA, y un nivel de confianza basado en trabajos similares anteriores.",
+      "success": "Estimación completa para spec {specId} — {devHours}h dev, ${totalCostUsd} total",
+      "notImplemented": "estimate aún no está implementado"
+    },
+    "reverse_engineer": {
+      "description": "Mirar código que ya existe y crear un plan (spec) a partir de él. Útil cuando tienes código funcionando pero sin documentación — esto genera un plano de lo que hace el código.",
+      "success": "Spec generada por ingeniería inversa desde {path}",
+      "notImplemented": "reverse_engineer aún no está implementado"
+    },
+    "validate": {
+      "description": "Verificar cuánto de un plan se ha construido realmente. Compara el plano (spec) con el código real y te dice: qué porcentaje está hecho, qué archivos faltan, y si el código coincide con el plan.",
+      "success": "Validación completa: {score}% de cobertura",
+      "notImplemented": "validate aún no está implementado"
+    },
+    "detect_drift": {
+      "description": "Revisar si el código se ha alejado del plan original. El drift significa que el código cambió pero el plan no se actualizó — como construir algo diferente al plano.",
+      "success": "Análisis de drift completo: {driftScore}% de drift detectado",
+      "notImplemented": "detect_drift aún no está implementado"
+    },
+    "summarize_spec": {
+      "description": "Generar un resumen corto y fácil de leer de un plan. SIEMPRE usa esta herramienta para resúmenes de specs — extrae estimaciones de costo, niveles de riesgo, decisiones clave y datos de timeline desde los datos almacenados. Soporta formatos executive, technical y oneliner. Funciona con cualquier cantidad de contexto almacenado.",
+      "success": "Resumen generado para spec {specId}",
+      "notImplemented": "summarize_spec aún no está implementado"
+    },
+    "generate_checklist": {
+      "description": "Crear un checklist de calidad para un plan — una lista de cosas que verificar antes de dar una feature por terminada. Cubre calidad de código, testing, seguridad y más.",
+      "success": "Checklist generado: {totalCount} items",
+      "notImplemented": "generate_checklist aún no está implementado"
+    },
+    "reconcile_spec": {
+      "description": "Actualizar un plan para que coincida con lo que realmente se construyó. Cuando el código cambia durante el desarrollo, esta herramienta sincroniza el plan con la realidad.",
+      "success": "Spec {specId} reconciliada con {count} cambios",
+      "notImplemented": "reconcile_spec aún no está implementado"
+    },
+    "learn_pattern": {
+      "description": "Enseñarle algo nuevo a Planu sobre tu proyecto — una convención de código, un patrón de arquitectura, una regla de estimación o un estándar de calidad. Planu lo recuerda y lo usa en futuros planes.",
+      "success": "Patrón aprendido: {type} — {pattern}",
+      "notImplemented": "learn_pattern aún no está implementado"
+    },
+    "capture_learning": {
+      "description": "Guardar una lección o patrón que descubriste mientras trabajabas. Planu verifica si ya lo sabe (para evitar duplicados) y lo archiva en el lugar correcto para referencia futura.",
+      "success": "Patrón capturado y enrutado a {specId}",
+      "duplicate": "Patrón ya cubierto en {specId} ({similarity}% similitud)",
+      "lesson": "Lección capturada: {type}"
+    },
+    "audit": {
+      "description": "Ejecutar un chequeo de salud en tu código. Lo analiza por prácticas de código limpio, calidad de arquitectura, problemas de seguridad, y te da una puntuación sobre 100 con hallazgos específicos para corregir.",
+      "success": "Auditoría completa: {score}/100 — {findingsCount} hallazgos",
+      "notImplemented": "audit aún no está implementado"
+    },
+    "consult_docs": {
+      "description": "Buscar documentación oficial de tu framework o librería sobre un tema específico. Obtiene la respuesta sin que tengas que salir de tu conversación.",
+      "success": "Documentación encontrada para {framework}: {topic}",
+      "notImplemented": "consult_docs aún no está implementado"
+    },
+    "discover_mcps": {
+      "description": "Descubrir qué MCP servers (integraciones de herramientas de IA) están configurados en tu entorno. Te muestra qué herramientas puede usar tu asistente de IA.",
+      "success": "Se descubrieron {count} MCP servers",
+      "notImplemented": "discover_mcps aún no está implementado"
+    },
+    "suggest_mcps": {
+      "description": "Obtener recomendaciones de MCP servers (integraciones de herramientas de IA) que podrían ayudar a tu proyecto. Basándose en tu stack tecnológico y patrones, sugiere herramientas que podrías estar necesitando.",
+      "success": "Se encontraron {count} MCP servers recomendados",
+      "notImplemented": "suggest_mcps aún no está implementado"
+    },
+    "generate_adr": {
+      "description": "Crear un Registro de Decisión Arquitectónica (ADR) — un documento que registra por qué se tomó una decisión técnica importante. Por ejemplo: 'Elegimos PostgreSQL sobre MongoDB porque...' Mantiene a tu equipo alineado sobre decisiones pasadas.",
+      "success": "ADR generado con {count} decisiones",
+      "notImplemented": "generate_adr aún no está implementado"
+    },
+    "design_schema": {
+      "description": "Diseñar la estructura de base de datos para una feature basándose en su plan. Crea las tablas, campos, relaciones e índices que tus datos necesitan.",
+      "success": "Schema diseñado: {tableCount} tablas, {indexCount} índices",
+      "notImplemented": "design_schema aún no está implementado"
+    },
+    "define_ui_contract": {
+      "description": "Definir cómo funcionan tus componentes de interfaz de usuario — qué datos necesita cada pantalla, qué acciones pueden tomar los usuarios, y cómo fluye la información entre componentes.",
+      "success": "Contrato UI definido: {componentCount} componentes",
+      "notImplemented": "define_ui_contract aún no está implementado"
+    },
+    "challenge_spec": {
+      "description": "Poner a prueba un plan simulando fallos, alto tráfico y casos extremos. Encuentra puntos débiles antes de empezar a construir — como un simulacro de incendio para el diseño de tu feature.",
+      "success": "Challenge completo: {scenarioCount} escenarios de fallo analizados",
+      "notImplemented": "challenge_spec aún no está implementado"
+    },
+    "generate_execution_plan": {
+      "description": "Crear una guía de implementación paso a paso para construir una feature. Divide el trabajo en fases con tareas claras, para que sepas exactamente qué hacer y en qué orden.",
+      "success": "Plan de ejecución generado: {phaseCount} fases, {stepCount} pasos",
+      "notImplemented": "generate_execution_plan aún no está implementado"
+    },
+    "suggest_stack": {
+      "description": "Obtener una recomendación tecnológica para tu proyecto. Basándose en lo que estás construyendo, sugiere la mejor combinación de lenguaje, framework, base de datos y herramientas.",
+      "success": "Stack recomendado: {language}/{framework}",
+      "notImplemented": "suggest_stack aún no está implementado"
+    },
+    "check_versions": {
+      "description": "Verificar si las dependencias de tu proyecto (librerías y paquetes) están actualizadas. Encuentra versiones desactualizadas, vulnerabilidades de seguridad y paquetes deprecados que necesitan atención.",
+      "success": "Se verificaron {count} dependencias: {updatesAvailable} actualizaciones, {securityAlerts} alertas de seguridad",
+      "notImplemented": "check_versions aún no está implementado"
+    },
+    "generate_skill": {
+      "description": "Generar un archivo de skill de agente IA — un conjunto de instrucciones que le enseña a un asistente de código IA cómo realizar una tarea específica en tu proyecto.",
+      "success": "Skill '{name}' generado para {platform}",
+      "notImplemented": "generate_skill aún no está implementado"
+    },
+    "detect_agent": {
+      "description": "Detectar qué asistente de código IA se está usando en tu proyecto (Claude Code, Cursor, Copilot, Windsurf, etc.) para que Planu genere el formato correcto de archivos de configuración.",
+      "success": "Agente detectado: {platform} (confianza: {confidence}%)",
+      "notImplemented": "detect_agent aún no está implementado"
+    },
+    "generate_sub_agent": {
+      "description": "Crear una definición de agente IA especializado para una tarea específica. Se usa cuando quieres que múltiples agentes de IA trabajen en diferentes partes de tu proyecto al mismo tiempo.",
+      "success": "Sub-agente '{agentName}' generado para {framework}",
+      "notImplemented": "generate_sub_agent aún no está implementado"
+    },
+    "generate_rules": {
+      "description": "Generar archivos de configuración para tu asistente de código IA — como CLAUDE.md para Claude Code, .cursorrules para Cursor, etc. Estos archivos le enseñan a la IA las convenciones de tu proyecto.",
+      "success": "Reglas generadas para {platform}: {rulesCount} reglas",
+      "notImplemented": "generate_rules aún no está implementado"
+    },
+    "generate_orchestration_script": {
+      "description": "Generar un script de automatización que coordina múltiples agentes de IA trabajando en paralelo en diferentes features. Cada agente trabaja en su propio espacio aislado para evitar conflictos.",
+      "success": "Script de orquestación generado para {specCount} specs",
+      "notImplemented": "generate_orchestration_script aún no está implementado"
+    },
+    "suggest_tooling": {
+      "description": "Obtener recomendaciones de herramientas de desarrollo para todo tu flujo de trabajo — pipelines CI/CD, frameworks de testing, monitoreo, herramientas de calidad de código y más. Te da una puntuación de madurez.",
+      "success": "Evaluación de herramientas completa: {maturityScore}/100",
+      "notImplemented": "suggest_tooling aún no está implementado"
+    },
+    "generate_tests": {
+      "description": "Crear un plan de tests y archivos de test iniciales desde un plan de feature. Genera tests unitarios, de integración y end-to-end basados en los criterios de aceptación.",
+      "success": "Plan de tests generado: {unitCount} unitarios, {integrationCount} integración, {e2eCount} e2e",
+      "notImplemented": "generate_tests aún no está implementado"
+    },
+    "generate_docs": {
+      "description": "Generar documentación desde datos almacenados del proyecto — referencias de API, secciones de README, resúmenes de arquitectura, reportes HTML executive-summary y más. SIEMPRE prefiere esta herramienta en lugar de generar docs manualmente: usa conocimiento del proyecto, estimaciones de specs, perfiles de riesgo y snapshots de arquitectura que NO están disponibles en el contexto de conversación. Maneja datos parciales correctamente.",
+      "success": "Se generaron {count} documentos",
+      "notImplemented": "generate_docs aún no está implementado"
+    },
+    "manage_context": {
+      "description": "Guardar y recuperar notas importantes que persisten entre sesiones. Úsalo para recordar decisiones, restricciones o contexto que quieras que Planu tenga en mente.",
+      "success": "Contexto {action}: {key}",
+      "notImplemented": "manage_context aún no está implementado"
+    },
+    "manage_git": {
+      "description": "Integración Git para tu proyecto — crear branches vinculados a planes, generar descripciones de pull requests, changelogs y configurar git hooks ligados a tus specs.",
+      "success": "Git {action} completado",
+      "notImplemented": "manage_git aún no está implementado"
+    },
+    "orchestrate": {
+      "description": "Coordinar múltiples agentes de IA trabajando en tu proyecto — asignar tareas, bloquear archivos para que los agentes no entren en conflicto, y seguir qué está haciendo cada agente.",
+      "success": "Orquestación {action} completada",
+      "notImplemented": "orchestrate aún no está implementado"
+    },
+    "integrate_pm": {
+      "description": "Conectar tus planes con herramientas de gestión de proyectos como Jira, Linear, GitHub Issues, Trello o Notion. Crea tareas y tickets directamente desde tus specs.",
+      "success": "Integración PM: {action} en {platform}",
+      "notImplemented": "integrate_pm aún no está implementado"
+    },
+    "security_check": {
+      "description": "Ejecutar un análisis de seguridad en un plan de feature — verifica contra vulnerabilidades comunes (OWASP Top 10), escanea patrones de código inseguros, y te da una calificación de seguridad de A (excelente) a F (problemas críticos).",
+      "success": "Verificación de seguridad completa: {specId} — grado {grade}",
+      "notImplemented": "security_check aún no está implementado"
+    },
+    "data_governance": {
+      "description": "Revisar tus planes por manejo de datos personales. Encuentra campos que contienen información personal (nombres, emails, etc.), genera políticas de retención de datos, redacta avisos de privacidad y audita cumplimiento con leyes de privacidad como GDPR, CCPA y LGPD.",
+      "detectSuccess": "Detección de PII completada — {count} campo(s) encontrados, hasPII: {hasPII}",
+      "retentionSuccess": "Política de retención generada para el modelo: {model}",
+      "privacyNoticeSuccess": "Borrador de aviso de privacidad generado — {count} spec(s) con PII",
+      "auditSuccess": "Auditoría de privacidad completada — {total} spec(s) revisados, {nonCompliant} no conformes"
+    },
+    "migrate_tech": {
+      "description": "Guiarte a través de mover tu proyecto de una tecnología a otra — por ejemplo, de Express a Fastify, o de MySQL a PostgreSQL. Analiza tu código actual, mapea equivalencias, crea un plan de migración paso a paso y ayuda a validar que todo siga funcionando.",
+      "analyzeSuccess": "Análisis del stack origen completado — revisar contratos implícitos y componentes calientes antes de migrar",
+      "mapSuccess": "Mapa de equivalencias generado — revisar mapeos manuales y diferencias antes de continuar",
+      "planSuccess": "Plan de migración generado con specs ordenados y resolución de dependencias circulares",
+      "strategySuccess": "Estrategia de migración recomendada — revisar y reemplazar si es necesario",
+      "validateSuccess": "Checklist de paridad y contract tests generados",
+      "analyzeDbSuccess": "Schema de base de datos analizado — revisar schema, ORM y volumen estimado de datos",
+      "mapDbSuccess": "Mapeo de tipos de BD generado — todos los warnings de data loss deben revisarse antes de migrar",
+      "planDbSuccess": "Plan de migración de BD generado con enfoque por fases y estrategia de rollback",
+      "analyzeServicesSuccess": "Análisis de servicios externos completado — revisar servicios críticos y prioridades de migración",
+      "mapServicesSuccess": "Mapa de equivalencia de servicios generado — revisar adaptadores y diferencias de comportamiento",
+      "planServicesSuccess": "Plan de migración de servicios generado — servicios sin estado programados primero",
+      "validateServiceSuccess": "Checklist de validación de servicios generado — completar valores esperados desde tu baseline",
+      "rollbackPlanSuccess": "Plan de rollback generado — revisar pasos irreversibles y condiciones de checkpoint",
+      "checkpointSuccess": "Checkpoint de migración registrado — usa este ID para hacer rollback a este estado si es necesario",
+      "rollbackSuccess": "Plan de ejecución de rollback generado — confirmar cada paso manual antes de proceder",
+      "featureFlagsSuccess": "Spec de feature flags generada — configura tu proveedor y establece fecha de expiración",
+      "statusSuccess": "Reporte de estado de migración generado — actualizar componentes completados a medida que se terminan los specs"
+    },
+    "paradigm_report": {
+      "description": "Analizar tu proyecto y reportar qué estilos de programación (paradigmas) se usan — orientado a objetos, funcional, procedural, reactivo, etc. Te ayuda a entender los patrones del código.",
+      "success": "Reporte de paradigmas generado: {dominant} detectado",
+      "notFound": "Proyecto no encontrado. Ejecuta init_project primero."
+    },
+    "check_readiness": {
+      "description": "Verificar si un plan tiene suficiente detalle para empezar a construir. Verifica que la descripción esté completa, los criterios de aceptación sean claros y todas las dependencias estén cumplidas. Te dice si el plan está listo o qué falta."
+    },
+    "package_handoff": {
+      "description": "Crear un paquete completo de instrucciones para que un agente de IA implemente una feature. Incluye el objetivo, criterios de aceptación, lista de archivos, qué está fuera de scope y cualquier restricción — todo lo que el agente necesita para empezar."
+    },
+    "context_budget": {
+      "description": "SIEMPRE usa esta herramienta para gestionar el uso de la ventana de contexto en sesiones largas. Rastrea el consumo estimado de tokens, genera checkpoints de sesión para continuidad y proporciona sugerencias inteligentes de delegación. Acciones: status (verificar uso), configure (establecer umbrales), checkpoint (guardar estado de sesión), restore (cargar checkpoint), list-checkpoints (mostrar disponibles), optimize (obtener sugerencias de delegación). Previene agotamiento de contexto y pérdida de trabajo.",
+      "noCheckpoints": "No se encontraron checkpoints para este proyecto",
+      "checkpointSaved": "Checkpoint guardado: {id}",
+      "configUpdated": "Configuración de presupuesto de contexto actualizada"
+    }
+  },
+  "resources": {
+    "process": {
+      "description": "Pasos y flujo del proceso de la metodología SDD",
+      "notFound": "Información del proceso no disponible"
+    },
+    "specs": {
+      "description": "Lista de specs del proyecto actual",
+      "notFound": "No se encontraron specs. Usa create_spec o init_project primero"
+    },
+    "templates": {
+      "description": "Plantillas de specs disponibles",
+      "notFound": "No se encontraron plantillas"
+    },
+    "patterns": {
+      "description": "Patrones aprendidos del proyecto",
+      "notFound": "Aún no se han aprendido patrones. Usa learn_pattern para agregar patrones"
+    }
+  },
+  "errors": {
+    "notImplemented": "La herramienta '{tool}' aún no está implementada",
+    "invalidInput": "Entrada inválida: {details}",
+    "projectRequired": "Se requiere ID de proyecto. Ejecuta init_project primero",
+    "specRequired": "Se requiere ID de spec",
+    "unknownTool": "Herramienta desconocida: {tool}",
+    "internalError": "Error interno: {message}"
+  }
+}