specrails-desktop 2.8.0 → 2.9.0

package/docs/guide/es/agents/4-custom-agents-catalog.md

@@ -0,0 +1,43 @@
+# Agentes personalizados y el catálogo
+
+Los perfiles deciden *qué agentes corren y con qué modelos*. Pero ¿de dónde salen los agentes en sí? De ahí: el **catálogo de Agentes**.
+
+Abre **Agentes → Catálogo** en cualquier proyecto. Es un visor de solo lectura de todos los agentes disponibles para ese proyecto, en dos grupos:
+
+- **Agentes upstream** — los agentes que vienen con `specrails-core`: el trío base (`sr-architect`, `sr-developer`, `sr-reviewer`) y cualquier especialista como `sr-merge-resolver`.
+- **Agentes personalizados** — agentes que has añadido tú, con el nombre `custom-*`.
+
+Cada entrada del catálogo muestra para qué sirve el agente y su modelo por defecto, así que puedes ver la plantilla completa antes de conectar agentes a la cadena de un perfil.
+
+## Añadir un agente personalizado
+
+Los agentes personalizados son simples archivos Markdown dentro de tu repositorio, en `.claude/agents/`, con el nombre `custom-<algo>.md`. El archivo contiene las instrucciones del agente (su system prompt) y una pequeña cabecera de frontmatter que incluye un `model:` por defecto.
+
+Una vez que el archivo existe en el proyecto, aparece en el catálogo como agente personalizado, y puedes añadir su id a la cadena de agentes de cualquier perfil (y enrutar tareas hacia él). El id debe coincidir con el nombre del archivo — una entrada para `custom-docs` se corresponde con `.claude/agents/custom-docs.md`.
+
+Como viven en tu repo, los agentes personalizados son **activos de equipo commiteables**: commitea el archivo y todo tu equipo recibe el agente. Esto refleja la idea central de toda la sección Agentes —
+
+> **Las definiciones de los agentes son compartidas (viven en el repo y viajan con `git`). La configuración de modelos es por proyecto (vive en los perfiles).**
+
+El espacio de nombres `custom-*` está reservado y protegido: los comandos `init` y `update` de `specrails-core` nunca tocan `.claude/agents/custom-*.md`, así que tus agentes personalizados sobreviven intactos a las actualizaciones de core. (La misma protección cubre los fragmentos aportados por plugins, como `custom-serena.md`.)
+
+## Poner a trabajar un agente personalizado
+
+El flujo típico:
+
+1. Escribe `.claude/agents/custom-<nombre>.md` con instrucciones y un modelo por defecto.
+2. Confirma que aparece en **Agentes → Catálogo** bajo Personalizados.
+3. En **Agentes → Perfiles**, añade el agente a la cadena de un perfil (sobrescribiendo opcionalmente su modelo para ese perfil).
+4. Añade una regla de enrutado para que las tareas con las etiquetas adecuadas lleguen a él — o confía en el orden de la cadena.
+5. Lanza un rail con ese perfil desde la cabecera del rail.
+
+## Vigilar cómo rinden los perfiles
+
+La sección Agentes también tiene una pestaña **Uso** — un desglose por perfil de cuántos jobs corrieron bajo cada perfil en una ventana seleccionada. Es una forma rápida de confirmar que tu reparto `fast`/`max` se está usando realmente como pretendías, y de detectar hacia qué perfil gravita tu equipo.
+
+## Resumen de toda la sección
+
+- **Los agentes** son los miembros especializados del equipo — el trío compartido más los especialistas y tus agentes personalizados. ([Conoce a los agentes](meet-the-agents))
+- **Los perfiles** empaquetan qué agentes corren, con qué modelos y cómo se enrutan las tareas — se seleccionan por rail en el lanzamiento. El perfil default es la elección equilibrada del día a día. ([Perfiles y el equilibrado por defecto](profiles-and-the-balanced-default))
+- **Los modelos** se ajustan por agente, por proyecto, dentro de los perfiles — crea `fast` y `max` para que encajen con el trabajo. ([Personalizar los modelos por agente](customizing-models-per-agent))
+- **El catálogo** muestra todos los agentes, y el espacio de nombres `custom-*` te deja hacer crecer el equipo — definiciones compartidas, configuración por proyecto.

package/docs/guide/es/getting-started/1-what-is-specrails.md

@@ -0,0 +1,49 @@
+# Qué es specrails
+
+Te damos la bienvenida a **specrails**, una app de escritorio que convierte a un asistente de programación con IA en un auténtico equipo de desarrollo que trabaja en *tus* proyectos, en *tu* máquina.
+
+En lugar de copiar y pegar prompts de un lado a otro, describes lo que quieres como una **spec** y specrails la lleva a través de un pipeline de desarrollo completo —diseñando, construyendo, revisando y publicando el cambio— mientras lo ves suceder en directo.
+
+## Desarrollo con IA guiado por specs
+
+El corazón de specrails es una idea sencilla: **la mejor forma de conseguir buen código de una IA es partir de una spec clara.**
+
+Una *spec* es una descripción breve y estructurada de un trabajo concreto: una funcionalidad, una corrección, un refactor. Puedes escribir una en segundos, o darle forma a través de un chat guiado que te hace las preguntas adecuadas y la redacta por ti. Cada spec se convierte en un **ticket** en el tablero de tu proyecto, igual que una tarea en cualquier gestor de incidencias.
+
+A partir de ahí, le pasas la spec al pipeline y dejas que la IA haga el trabajo pesado.
+
+## El pipeline: Architect → Developer → Reviewer → Ship
+
+Cuando lanzas una spec, specrails la lleva a través de cuatro etapas, cada una interpretada por un agente de IA especializado:
+
+1. **Architect** — lee tu spec y el código que la rodea, y luego planifica el cambio: qué archivos tocar y qué forma debería tener la solución.
+2. **Developer** — escribe el código de verdad, siguiendo el plan.
+3. **Reviewer** — comprueba que el trabajo sea correcto y de calidad, detectando problemas antes que tú.
+4. **Ship** — finaliza el cambio para que quede listo para hacer commit.
+
+Ves cada etapa a medida que se ejecuta, con logs en directo que llegan directamente de la IA. No se oculta nada: si algo se tuerce, verás exactamente dónde.
+
+## Proyectos
+
+Todo en specrails se organiza en torno a **proyectos**. Un proyecto no es más que una carpeta de tu ordenador que contiene una base de código. Puedes añadir tantos proyectos como quieras y cambiar entre ellos al instante; cada uno conserva sus propias specs, su historial de jobs, sus analíticas y sus ajustes.
+
+specrails nunca toca código que no le hayas pedido tocar. Trabaja dentro de tu repositorio existente, y tú mantienes el control de lo que acaba en un commit.
+
+## Elige tu provider de IA
+
+specrails funciona con los principales CLI de programación con IA:
+
+- **Claude** (Claude Code)
+- **Codex** (Codex CLI)
+- **Gemini** (Gemini CLI)
+
+Elige el que ya uses, o instala más de uno y escoge según la tarea. Un proyecto puede funcionar con un único provider o con varios a la vez, así que nunca te quedas atado a uno.
+
+## Por qué te va a gustar
+
+- **Velocidad sin caos** — las specs mantienen a la IA centrada, así que obtienes cambios útiles en lugar de divagaciones interminables.
+- **Visibilidad total** — logs en directo, una vista clara del pipeline y analíticas por proyecto te muestran exactamente qué pasó y cuánto costó.
+- **Tu máquina, tu código** — todo se ejecuta en local contra tu repositorio real.
+- **Todo en un solo sitio** — specs, jobs, chat, una terminal integrada y seguimiento de costes, todo en una única ventana.
+
+¿Listo para empezar? Lo siguiente: [Instalación y primer arranque](installing-and-first-run).

package/docs/guide/es/getting-started/2-installing-and-first-run.md

@@ -0,0 +1,42 @@
+# Instalación y primer arranque
+
+Poner specrails en tu máquina te llevará un par de minutos. Aquí tienes todo el proceso.
+
+## 1. Descarga e instala
+
+Hazte con el instalador para tu plataforma:
+
+- **macOS (Apple Silicon)** — un archivo `.dmg`. Ábrelo y arrastra **specrails** a tu carpeta de Aplicaciones.
+- **Windows** — un instalador `.exe`. Ejecútalo y sigue los pasos.
+
+> **Aviso sobre los avisos de seguridad de macOS y Windows**
+>
+> - En **Windows**, el instalador aún no está firmado, así que SmartScreen puede mostrar una advertencia. Haz clic en **Más información → Ejecutar de todas formas** para continuar.
+> - En **macOS**, la app está firmada y notarizada, así que debería abrirse sin problemas.
+
+## 2. Lo que vas a necesitar (requisitos previos)
+
+specrails ejecuta pipelines de desarrollo con IA controlando herramientas de línea de comandos reales, así que hay algunas cosas que deben estar disponibles. La buena noticia: la app de escritorio **incluye la mayoría por ti** (Node.js, npm y Git vienen dentro de la app), así que en una máquina recién estrenada normalmente no hay nada que instalar.
+
+Lo único que specrails no puede incluir es el **CLI del provider de IA** en sí. Necesitarás al menos uno de estos:
+
+- **Claude Code**
+- **Codex CLI**
+- **Gemini CLI**
+
+Instala el que tengas pensado usar, inicia sesión una vez desde tu terminal y listo. specrails detecta automáticamente qué providers están presentes.
+
+> Si en algún momento ves una herramienta marcada como ausente, la app muestra un enlace de **Más información** con comandos de instalación listos para copiar y pegar, adaptados a tu sistema operativo (Homebrew en macOS, winget en Windows, apt/dnf en Linux). Puedes volver a comprobarlo en cualquier momento sin reiniciar.
+
+## 3. Primer arranque — la pantalla de bienvenida
+
+La primera vez que abras specrails, llegarás a una **pantalla de bienvenida** limpia. Todavía no hay proyectos, así que la app te invita a añadir el primero.
+
+Verás:
+
+- Una breve descripción de lo que hace specrails.
+- Un único botón **Añadir tu primer proyecto**.
+
+Eso es toda la puesta en marcha: ninguna cuenta que crear, ningún registro. specrails funciona por completo en tu máquina.
+
+Haz clic en **Añadir tu primer proyecto** y continúa con [Añadir tu primer proyecto](adding-your-first-project).

package/docs/guide/es/getting-started/3-adding-your-first-project.md

@@ -0,0 +1,58 @@
+# Añadir tu primer proyecto
+
+Un proyecto no es más que una carpeta de tu ordenador que contiene una base de código. Vamos a conectar una.
+
+## Abre el diálogo de Añadir proyecto
+
+Haz clic en **Añadir tu primer proyecto** en la pantalla de bienvenida (o, más adelante, en el botón **Añadir proyecto** de la barra lateral izquierda). Aparece un pequeño diálogo.
+
+## Rellena los datos
+
+**Carpeta del proyecto** *(obligatorio)*
+
+Apunta specrails a la carpeta que contiene tu código. En la app de escritorio puedes hacer clic en el icono de carpeta para explorar y seleccionarla visualmente, o pegar la ruta completa. Debería ser la raíz de tu repositorio: la carpeta que contiene tu código y (normalmente) un directorio `.git`.
+
+**Nombre del proyecto** *(opcional)*
+
+Una etiqueta amigable que se muestra en la barra lateral. Si lo dejas en blanco, specrails usa el nombre de la carpeta.
+
+**Providers**
+
+Elige qué provider(s) de IA debería usar este proyecto. specrails te muestra los que ha detectado en tu máquina:
+
+- 🤖 **Claude**
+- ⚡ **Codex**
+- ✨ **Gemini**
+
+Los providers que no ha encontrado aparecen en gris y marcados como *no encontrado*: instala uno e inicia sesión, y luego vuelve a abrir el diálogo. Por defecto, todos los providers disponibles vienen preseleccionados, pero puedes deseleccionar hasta quedarte solo con el que quieras. Si eliges más de uno, el **primero** se convierte en el predeterminado del proyecto; más adelante podrás escoger según la tarea.
+
+> Una comprobación rápida se ejecuta en segundo plano para confirmar que las herramientas necesarias están presentes. Si falta algo esencial, el botón **Añadir** permanece deshabilitado y un enlace de **Más información** te da los comandos exactos de instalación.
+
+Haz clic en **Añadir** para continuar.
+
+## Una configuración que se hace en segundos
+
+Si la carpeta ya tiene specrails configurado, has terminado: el proyecto aparece en tu barra lateral al instante.
+
+Si es un proyecto nuevo, se ejecuta un breve **asistente de configuración**. Tiene tres pasos:
+
+1. **Configurar** — confirma lo básico para cada provider que hayas elegido.
+2. **Instalar** — specrails configura el proyecto automáticamente. Es la instalación *rápida*: agentes de plantilla listos para usar que quedan en su sitio en segundos. Verás un log en directo mientras se ejecuta.
+3. **Hecho** — un resumen que confirma que todo está listo.
+
+En un proyecto con varios providers, la instalación se ejecuta una vez por provider, uno tras otro, y el paso Hecho muestra una tarjeta para cada uno.
+
+## Qué se instala
+
+La configuración es deliberadamente ligera y **no invasiva**. specrails añade una pequeña cantidad de configuración a tu proyecto para que el pipeline sepa cómo ejecutarse:
+
+- Una carpeta `.specrails/` que guarda los perfiles de agente y los ajustes locales de tu proyecto.
+- Definiciones de agentes en `.claude/agents/` que dan vida al pipeline Architect → Developer → Reviewer → Ship.
+
+Eso es todo: specrails no reescribe tu código fuente durante la configuración, y estos archivos se pueden hacer commit sin problema si quieres compartir la configuración con tu equipo.
+
+> **¿Prefieres la configuración a fondo?** La app incluye a propósito la instalación rápida desde plantillas. Si prefieres el flujo enriquecido con IA (análisis de la base de código y personas de agente personalizadas), puedes ejecutar `npx specrails-core@latest init` desde la carpeta de tu proyecto en una terminal.
+
+## Ya estás dentro
+
+Cuando termine la configuración, specrails te lleva directamente al dashboard de tu proyecto. Es hora del recorrido: consulta [El recorrido por el dashboard](the-dashboard-tour).

package/docs/guide/es/getting-started/4-the-dashboard-tour.md

@@ -0,0 +1,53 @@
+# El recorrido por el dashboard
+
+Con un proyecto ya añadido, estás viendo el **dashboard de tu proyecto**: tu base de operaciones para convertir specs en código publicado. Vamos a ver cómo orientarte.
+
+## El panorama general
+
+La ventana tiene tres zonas:
+
+- **Barra lateral izquierda** — tu lista de proyectos. Haz clic en cualquier proyecto para cambiar a él al instante; todo lo demás en la ventana se actualiza para reflejarlo. El botón **Añadir proyecto** también vive aquí.
+- **Área principal** — el dashboard del proyecto activo: tus specs y el pipeline que las ejecuta.
+- **Barra lateral derecha** — la navegación entre las secciones del proyecto actual.
+
+## El dashboard principal
+
+Aquí es donde ocurre el trabajo. El dashboard muestra:
+
+- **Tus specs** — los tickets que has creado, organizados por estado (de Backlog/Por hacer hasta Hecho). Puedes verlos como lista, como cuadrícula o como tarjetas tipo nota adhesiva, lo que prefieras.
+- **Una forma de añadir una spec** — empieza un nuevo trabajo. Puedes escribir una spec rápida directamente, o abrir un chat guiado de **Explore** que te ayuda a darle forma a través de la conversación y redacta el ticket por ti.
+- **Rails** — son los carriles donde se construyen las specs. Suelta una spec en un rail y lánzala para enviarla a través del pipeline Architect → Developer → Reviewer → Ship. Pueden ejecutarse varios rails a la vez, así que puedes trabajar en varias cosas en paralelo.
+
+Cuando una spec está en ejecución, verás el progreso de su pipeline y sus logs en directo: la salida en tiempo real de la IA mientras diseña, programa y revisa tu cambio.
+
+## La barra lateral derecha: las secciones del proyecto
+
+La barra lateral derecha es tu cuadro de mandos para el proyecto actual. Pasa el ratón por encima para expandirla, o ánclala abierta. Las secciones que verás:
+
+- **Dashboard** — el tablero de specs y los rails (donde acabas de estar).
+- **Jobs** — todas las ejecuciones de pipeline de este proyecto, pasadas y presentes, con su estado, su duración y la posibilidad de profundizar en el detalle y los logs de cualquier ejecución.
+- **Analíticas** — cuánto te está costando tu uso de IA. El gasto desglosado por día, por actividad, por modelo y por ticket, para que no haya sorpresas.
+- **Agentes** — los perfiles de agente de tu proyecto: qué agentes se ejecutan en el pipeline y qué modelos de IA usan. *(Solo en proyectos basados en Claude.)*
+- **Código** — un explorador de archivos de solo lectura con resúmenes de IA en lenguaje sencillo, y chips que muestran qué archivos ha tocado la IA. Ideal para quienes no programan pero quieren seguir el proceso.
+- **Integraciones** — complementos opcionales, como conectar tus specs a un tablero de **Jira** o habilitar herramientas adicionales para la IA.
+- **Ajustes** — opciones por proyecto (telemetría, presupuestos, configuración de providers y más).
+
+> Algunas secciones solo aparecen cuando tienen sentido para los providers que elegiste; por ejemplo, **Agentes** es específica de Claude. Si no ves una sección, simplemente es que no aplica a la configuración de este proyecto.
+
+## La barra de estado
+
+Una fina franja recorre la parte inferior de la ventana. Es pequeña, pero útil:
+
+- **Indicador de conexión** (izquierda) — un punto de color y una etiqueta que muestran que la app está activa: verde para *conectado*, ámbar mientras *reconecta*, azul mientras *sincroniza* justo después de una reconexión. Rara vez lo necesitarás, pero tranquiliza tenerlo.
+- **Gasto total** (derecha) — un total acumulado de lo que has gastado, para que el coste esté siempre a un solo vistazo.
+- **Botón de terminal** (extremo derecho) — abre el panel de terminal integrado. Pulsa **Cmd+J** (macOS) o **Ctrl+J** (Windows/Linux) para alternarlo en cualquier momento. Es una shell completa, abierta directamente en la carpeta de tu proyecto.
+
+## Algunos atajos prácticos
+
+- **Cmd/Ctrl+B** — ancla o contrae las barras laterales.
+- **Cmd/Ctrl+J** — alterna el panel de terminal.
+- **Cmd/Ctrl+K** — abre la búsqueda.
+
+## A dónde ir después
+
+Ya conoces el terreno. Desde aquí, el primer paso natural es **añadir una spec** y lanzarla en un rail: observa cómo el pipeline se ejecuta de principio a fin y luego revisa las **Analíticas** para ver cuánto costó. Bienvenido a bordo.

package/docs/guide/es/insights/1-analytics-and-cost-tracking.md

@@ -0,0 +1,78 @@
+# Analíticas y seguimiento de costes
+
+Cada vez que Specrails ejecuta una CLI de IA en tu nombre —un job del pipeline, una spec rápida, una sesión de Explore, un refinado con IA, un resumen de archivo— deja constancia de lo que ocurrió: qué modelo se ejecutó, cuántos tokens entraron y salieron, cuánto tardó y cuánto costó. La sección **Analíticas** convierte todo eso en un único panel para que siempre sepas adónde va tu gasto en IA.
+
+Ábrela desde la barra lateral derecha (está etiquetada como **Analíticas**). Todo lo que ves está acotado al proyecto en el que estés ahora mismo: cambia de proyecto y los números te siguen.
+
+## Qué cuenta como gasto
+
+Specrails registra cinco tipos de actividad de IA, llamados *superficies*. Cada uno tiene un color asignado de forma consistente en todas las gráficas, para que lo identifiques de un vistazo:
+
+- **Job** — un rail del pipeline ejecutando Architect → Developer → Reviewer → Ship.
+- **Quick spec** — una spec generada por la vía rápida de Add Spec.
+- **Explore spec** — una conversación de Explore en la que das forma a una spec charlando.
+- **AI edit** — un refinado asistido por IA sobre un agente o un archivo.
+- **File summary** — los resúmenes en lenguaje sencillo que alimentan el Code explorer.
+
+Hay un par de cosas que, a propósito, *no* se registran: el panel de chat lateral y el asistente de configuración también lanzan CLIs de IA, pero nunca aparecen en tu gasto. Así el panel refleja trabajo real y repetible, en lugar de conversaciones puntuales.
+
+## Cómo leer el panel
+
+La página se compone de unos cuantos bloques, de arriba abajo:
+
+### El medidor de consumo (Hero)
+
+El número grande de la parte superior es tu gasto total del periodo seleccionado, con un delta **vs anterior** para que veas de un vistazo si tu tendencia sube o baja respecto a la ventana previa. Si acabas de empezar a usar un proyecto, el estado vacío te indica cuándo empezó el seguimiento ("Seguimiento iniciado el YYYY-MM-DD"): no hay relleno retroactivo de datos históricos, así que el medidor solo conoce las ejecuciones que ocurrieron mientras usabas esta versión.
+
+### Cronología diaria
+
+Un gráfico de barras apiladas con el gasto por día, desglosado por superficie. Los días sin actividad se muestran como cero en lugar de omitirse, para que la forma de tu semana sea honesta. Es la forma más rápida de ver *cuándo* se ejecutó un lote costoso.
+
+### Quick vs Explore
+
+Una tarjeta que compara codo con codo tus dos estilos de creación de specs. Si has hecho menos de cinco sesiones de Explore, muestra una invitación amable en lugar de medias engañosas: las muestras pequeñas no sirven para comparaciones fiables.
+
+### Por modelo
+
+Tus modelos con más gasto (hasta diez). Haz clic en cualquier modelo para filtrar todo el panel y dejar solo ese modelo: muy útil cuando quieres saber cuánto te está costando de verdad un modelo de gama alta concreto.
+
+### Dispersión de coste vs turnos
+
+Cada punto es una invocación, situando el coste frente al número de turnos. Los valores atípicos —las ejecuciones caras y con muchos turnos— saltan a la vista enseguida. (La dispersión muestra tus 500 puntos más recientes para seguir siendo ágil.)
+
+### Tickets principales
+
+Tus diez tickets más caros sumando *todas* las superficies a la vez, de modo que un ticket que costó poco en Explore y mucho en un job muestra su total real. Los tickets eliminados y las ejecuciones sin atribuir tienen su propio grupo, así que nada desaparece en silencio de los totales.
+
+### Tabla de invocaciones en bruto
+
+La verdad sobre el terreno: una fila por invocación. Este bloque tiene sus propios filtros secundarios que solo afectan a la tabla, así que puedes profundizar sin alterar las gráficas de arriba.
+
+## Filtrado
+
+La cabecera fija de la parte superior lleva los dos filtros principales —**periodo** y **superficie**— y ambos se guardan en la URL de la página. Eso significa que puedes marcar como favorita o compartir una vista filtrada ("últimos 30 días, solo jobs") y se reabrirá exactamente como la dejaste. Los filtros de la tabla en bruto son aparte y se mantienen locales a ese bloque.
+
+Una nota sobre la precisión: las ejecuciones fallidas y abortadas se dejan fuera de las *medias de coste* (distorsionarían los números por ejecución), pero siguen contando para tu número total de ejecuciones y tu tasa de fallos. Así las medias se mantienen limpias mientras la imagen de fiabilidad queda completa.
+
+## Coste por ticket
+
+No hace falta ir a la página de Analíticas para ver cuánto costó una spec. Abre cualquier ticket y, si tiene gasto asociado, verás un resumen de una línea justo debajo del título:
+
+> $0.42 · 6 turns · 1m 12s active · breakdown
+
+Haz clic y aterrizas en la página de Analíticas ya filtrada por ese ticket. Es el camino más rápido entre "¿cuánto me costó esta funcionalidad?" y el desglose completo.
+
+## Exportar tus datos
+
+Cuando necesites los números fuera de la aplicación —una hoja de cálculo, un informe de finanzas, tu propio análisis— usa el desplegable **Exportar**. Ofrece cuatro formatos:
+
+- **CSV resumen** — un archivo con varias secciones que incluye totales, la cronología diaria, por superficie, por modelo y tickets principales.
+- **JSON resumen** — el mismo resumen, estructurado.
+- **CSV en bruto** — cada fila de invocación (hasta 10 000; indica si tuvo que truncar).
+- **JSON en bruto** — las mismas filas en bruto, estructuradas.
+
+Las exportaciones respetan los filtros de periodo y superficie que tengas aplicados en ese momento, y los archivos se nombran de forma que se ordenen con sentido: `<project>-analytics-<period>-<date>.csv`. El botón se deshabilita cuando no hay nada que exportar, y recibirás un aviso de error claro si una descarga falla.
+
+## Siempre al día
+
+No necesitas refrescar. Cuando se registra una nueva invocación en cualquier parte del proyecto, el panel abierto se vuelve a cargar discretamente un instante después, de modo que el medidor de consumo va al ritmo del trabajo a medida que termina.

package/docs/guide/es/insights/2-the-integrated-terminal.md

@@ -0,0 +1,46 @@
+# El terminal integrado
+
+Specrails tiene un terminal de verdad integrado: el panel que sube desde la parte inferior de la ventana, igual que el de VS Code o Cursor. Ejecuta tu shell real, en el directorio real de tu proyecto, así que puedes usar `git`, `npm`, tests o cualquier otra cosa sin salir de la aplicación.
+
+## Abrirlo y cerrarlo
+
+La forma más rápida es el teclado: **Cmd+J** (macOS) o **Ctrl+J** (Windows/Linux) abre y cierra el panel, y enfoca el terminal en cuanto aparece para que puedas empezar a escribir de inmediato. También puedes usar el chevron de la barra de estado.
+
+El panel tiene tres estados:
+
+- **Oculto** — guardado a un lado.
+- **Restaurado** — el panel normal, a media altura.
+- **Maximizado** — ocupando el área de trabajo cuando necesitas espacio para leer la salida.
+
+Minimizar el panel (el chevron) **no** detiene nada: tus shells siguen ejecutándose en segundo plano. Lo único que termina de verdad una sesión es cerrarla (el icono de la papelera, o la ✕ de cada pestaña).
+
+## Varias sesiones
+
+Puedes tener varios terminales a la vez en el mismo proyecto: hasta diez. Cada uno tiene su propia pestaña; puedes renombrarlos para no confundir "dev server" con "tests". Todos arrancan en la carpeta de tu proyecto y cargan tu perfil de shell (`.zshrc`, `.bashrc`, etc.), así que tus alias y tu PATH son exactamente los que esperarías.
+
+Y aquí viene lo importante: tus terminales **sobreviven a los cambios de proyecto y de pestaña**. Specrails mantiene cada sesión viva e intacta entre bambalinas —scrollback, procesos en ejecución, todo— de modo que saltar a Analíticas y volver no reinicia tu shell ni interrumpe un comando que esté tardando. Las sesiones solo terminan cuando las cierras explícitamente (o cuando eliminas todo el proyecto).
+
+## Por proyecto, recordado
+
+Si el panel está abierto, cuánto lo has arrastrado de alto, qué pestañas existen: todo eso se recuerda **por proyecto**. Vuelve a un proyecto y lo encontrarás tal como lo dejaste.
+
+## Las funciones premium
+
+Esto no es una consola pelada. El terminal viene con los detalles que querrías de uno de primera:
+
+- **Renderizado rápido y nítido** mediante WebGL (con un repliegue automático para que nunca se rompa), gestión completa del ancho Unicode y ligaduras de fuente.
+- **Busca en tu scrollback** con **Cmd+F** — genial para encontrar ese error enterrado 500 líneas más arriba.
+- **Zoom de fuente** con **Cmd+=**, **Cmd+-** y **Cmd+0** para restablecer.
+- **Atajos de portapapeles** — Cmd+C / Cmd+V para copiar y pegar, Cmd+K para limpiar — más un menú contextual con clic derecho.
+- **Arrastrar y soltar rutas de archivo** (en la aplicación de escritorio): suelta un archivo sobre el terminal y su ruta se inserta, correctamente entrecomillada para tu shell.
+- **Redimensionado suave** — arrastrar la altura del panel o plegar la barra lateral no provocará saltos en la salida.
+- **Imágenes en línea** — los terminales que emiten imágenes tipo Sixel o iTerm2 las renderizan ahí mismo.
+- **Integración con el shell** — Specrails sabe dónde empieza y termina cada comando, así que puede llevar tu historial de comandos y avisarte cuando un comando largo termina (una notificación de escritorio, con repliegue al navegador). Si tu shell no puede instrumentarse por algún motivo, degrada en silencio y te lo dice una vez.
+
+## Ajustes
+
+Las preferencias del terminal viven en dos capas: un valor por defecto para toda la aplicación y una anulación opcional por proyecto. El ajuste por proyecto gana cuando existe, así que puedes mantener un aspecto global mientras retocas un proyecto que necesite algo distinto.
+
+## Desactivarlo
+
+El terminal está activado por defecto. Si prefieres no tenerlo, puede desactivarse mediante los flags `VITE_FEATURE_TERMINAL_PANEL` (cliente) o `SPECRAILS_TERMINAL_PANEL` (servidor) — pon cualquiera de los dos a `false`. La mayoría de la gente simplemente lo dejará activado.

package/docs/guide/es/insights/3-code-explorer.md

@@ -0,0 +1,50 @@
+# Code explorer
+
+La sección **Code** te da una ventana amigable y de solo lectura a tu repositorio, pensada especialmente para quienes quieren entender lo que la IA ha estado construyendo sin vivir dentro de un editor. Tienes un árbol de archivos a la izquierda, un visor de código a la derecha y, encima del código, un resumen en lenguaje sencillo de lo que hace realmente cada archivo.
+
+En esta versión es estrictamente de solo lectura: nada de lo que hagas aquí cambia tus archivos. Piensa en ello como una sala de lectura, no como un taller.
+
+Ábrela desde la barra lateral derecha (**Code**) y, como todo lo demás, está acotada a tu proyecto actual.
+
+## El árbol de archivos
+
+El panel izquierdo es un árbol virtualizado de los archivos de tu proyecto: rápido incluso en repositorios grandes. Respeta tu `.gitignore` y una lista de exclusión integrada, así que ves los archivos que importan, no un mar de artefactos de compilación y `node_modules`.
+
+Junto a los archivos verás **chips de procedencia**: pequeñas marcas que te indican que un archivo fue *tocado por IA*. Esto es el corazón del Code explorer: Specrails registra qué archivos creó o modificó cada job del pipeline y los vincula al ticket que originó el trabajo. Así puedes responder, de un vistazo, "¿esto lo escribió la IA o lo escribí yo?".
+
+En la parte superior del árbol hay un filtro:
+
+- **Tocado por IA / Touched by AI** (el valor por defecto) — solo los archivos que la IA ha cambiado.
+- **Todos los archivos** — el árbol completo.
+
+Tu elección se recuerda por proyecto, así que si te interesan sobre todo los cambios hechos por IA los verás primero cada vez.
+
+## El visor de código
+
+Haz clic en un archivo y se abre en un visor completo (impulsado por Monaco, el mismo motor que VS Code) con resaltado de sintaxis adecuado que coincide con el tema que hayas elegido en la aplicación. Unos límites razonables mantienen todo fluido: los archivos binarios se rechazan con educación, y los archivos muy grandes (más de 2 MB) no se cargan.
+
+Tu archivo actual se guarda en la URL de la página, así que puedes marcar como favorito o compartir un enlace directo a un archivo concreto.
+
+Como en esta versión la edición no forma parte del paquete, el visor ofrece un botón **Editar en un editor externo** que copia la ruta absoluta del archivo: pégala en tu editor favorito y continúa allí.
+
+## Resúmenes con IA
+
+Encima del código verás un **resumen en lenguaje sencillo** del archivo —para qué sirve, qué hace— escrito de forma que cualquiera sin perfil técnico pueda seguirlo. Se generan por ti y se guardan en caché, así que abrir un archivo que ya has mirado antes es instantáneo.
+
+Los resúmenes son listos a la hora de mantenerse al día: están vinculados al contenido del archivo, de modo que cuando un archivo cambia de verdad el resumen se regenera, pero los archivos sin cambios no se vuelven a resumir sin necesidad. Si editas un archivo tú mismo, su resumen se marca como obsoleto en vez de regenerarse en silencio: tú mantienes el control de cuándo se refresca. Hay una acción de **regenerar** para cuando quieras una versión fresca al momento.
+
+Un par de salvaguardas mantienen los costes a raya: la generación de resúmenes se ejecuta dentro de un **presupuesto mensual** (unos pocos dólares por defecto, configurable en Ajustes), y hay topes de cuántos resúmenes lanzará un mismo job. Si se omite un resumen, la aplicación te dice por qué: presupuesto alcanzado, un tope por job, o que el archivo simplemente no se encuentra.
+
+También puedes elegir el **idioma del resumen** (inglés o español) en los ajustes globales, dentro del área *Code section*.
+
+## Conectar el código con las specs
+
+El vínculo de procedencia funciona en ambos sentidos. Dentro del Code explorer, hacer clic en el chip de un ticket sobre un archivo abre el detalle de ese ticket. Y en sentido inverso, la vista de **detalle del ticket** tiene una sección *Archivos tocados por este ticket*: haz clic en un archivo ahí y saltas directo al Code explorer con él abierto. Cierra el círculo entre "esta es la spec que escribimos" y "este es el código que salió de ella".
+
+## Lo que (todavía) no hace
+
+Para dejar las expectativas claras, esta primera versión deja fuera a propósito algunas cosas: la edición dentro de la aplicación, los resúmenes por símbolo o por directorio, una vista de diff narrativa y el "pregúntale a la IA sobre este archivo" conversacional. La procedencia atribuye un archivo solo a su ticket principal. Son el tipo de cosas que podrían crecer con el tiempo.
+
+## Desactivarlo
+
+El Code explorer está activado por defecto. Puede desactivarse con los flags `VITE_FEATURE_CODE_EXPLORER` (cliente) o `SPECRAILS_CODE_EXPLORER` (servidor) — pon cualquiera de los dos a `false`. Desactivarlo deja todos tus datos registrados y resúmenes a salvo en el disco, intactos, por si vuelves a activarlo.

package/docs/guide/es/integrations/1-ai-providers.md

@@ -0,0 +1,64 @@
+# Proveedores de IA (Claude, Codex, Gemini)
+
+Specrails no está atado a una única IA. Cada parte de la app que habla con una IA —Explore Spec, la spec rápida (Quick), los rails, el chat, AI Edit, el botón «Open AI CLI» del terminal— puede funcionar con cualquiera de los tres proveedores de primera clase. Tú eliges cuáles usa un proyecto, e incluso puedes cambiar de proveedor según la tarea.
+
+## Los tres proveedores
+
+| Proveedor | CLI | Creado por | Notas |
+|---|---|---|---|
+| **Claude** | `claude` | Anthropic | El más completo. El único proveedor para Agents (perfiles) y los rails Ultracode, y para Contract Refine. |
+| **Codex** | `codex` | OpenAI | Necesita codex `0.128.0+`. Lee sus servidores MCP desde tu `~/.codex/config.toml` global. |
+| **Gemini** | `gemini` | Google | Necesita gemini `0.11.0+`. Usa telemetría nativa y un archivo de instrucciones `GEMINI.md`. |
+
+Los tres están **activados por defecto**. Un proveedor aparece en **Añadir proyecto** siempre que su CLI esté instalado y en tu `PATH`. Así que el primer paso es siempre el mismo: instala la CLI que quieras y haz login con ella, exactamente como indica la documentación de esa herramienta. En cuanto `claude --version` (o `codex`, o `gemini`) funcione en tu terminal, Specrails podrá usarlo.
+
+## Instalar un proveedor para un proyecto
+
+Cuando añades un proyecto, el asistente de configuración te pregunta qué proveedor(es) instalar. Elige uno, completa el paso de instalación y listo. A partir de ahí el proyecto simplemente *tiene* ese proveedor: ya no tendrás que pensar en ello. Las specs, los rails, el chat y las analíticas funcionan igual independientemente del que hayas elegido.
+
+Si una CLI que quieres no aparece en Añadir proyecto, casi siempre es porque la CLI no está instalada o no está en tu `PATH`. Instálala y vuelve a abrir Añadir proyecto.
+
+## Instalar varios proveedores para un mismo proyecto
+
+Puedes instalar **más de un** proveedor en el mismo proyecto; por ejemplo, Claude *y* Gemini. En **Añadir proyecto**, la lista de proveedores se convierte en un conjunto de casillas; marca todas las que quieras. El primero que selecciones se convierte en el proveedor **principal** (por defecto) del proyecto; el resto quedan disponibles como alternativas.
+
+Algunas cosas que conviene saber sobre los proyectos multiproveedor:
+
+- **Con un solo proveedor todo se comporta exactamente igual que antes.** Si un proyecto tiene un único proveedor, no verás ningún selector de proveedor en ninguna parte: la app se mantiene limpia y sencilla.
+- **La barra lateral derecha solo muestra las secciones que admiten todos los proveedores instalados.** Como Agents (perfiles) es un concepto exclusivo de Claude, la sección **Agents** desaparece en cuanto un proyecto incluye algún proveedor que no sea Claude. Todo lo demás (Specs, Code, Analytics, Integraciones, Terminal, Chat) se mantiene.
+- **La elección de proveedor queda bloqueada tras la creación.** En esta versión eliges tus proveedores al añadir el proyecto y no se pueden cambiar después desde Ajustes. Si necesitas una combinación distinta, crea un proyecto nuevo.
+
+## Elegir un proveedor por cada invocación
+
+La verdadera ventaja de un proyecto multiproveedor es poder elegir la IA adecuada para cada tarea, sin tocar ningún ajuste global. Allí donde se ejecuta una IA aparece un pequeño selector de proveedor (solo cuando el proyecto tiene más de uno):
+
+- **Añadir spec** — un selector de motor te deja explorar o generar una spec en modo rápido (Quick) con el proveedor que prefieras.
+- **Cabecera del rail** — elige el motor para ese rail concreto antes de lanzarlo.
+- **Terminal** — el botón «Open AI CLI» (el icono de chispas) abre un menú de proveedores para que puedas entrar en cualquier CLI instalada en el directorio de ese proyecto.
+
+Tu elección se recuerda por proyecto y toma el proveedor principal por defecto, así que no tienes que volver a elegirla cada vez.
+
+## Lo que solo Claude puede hacer
+
+Un puñado de funciones son específicas de Claude por naturaleza, así que se ocultan o se omiten cuando hay otro proveedor en juego:
+
+- **Agents (perfiles)** — el catálogo de agentes por proyecto y el enrutado de modelos. Se oculta en cualquier proyecto que incluya un proveedor que no sea Claude.
+- **Rails Ultracode** — siempre se ejecutan con Claude.
+- **Contract Refine** — la pasada adicional de «Contract Layer» sobre una spec confirmada solo se ejecuta cuando el proveedor de la conversación es Claude.
+- **Modos avanzados de Añadir spec** (SMASH / Contract Layer) — se ocultan para los motores que no sean Claude.
+
+Todo lo demás —Explore, la spec rápida (Quick), el pipeline completo de rails, AI Edit, el chat y las analíticas de coste— funciona con los tres.
+
+## Seguimiento de costes entre proveedores
+
+La página de **Analytics** registra cada invocación facturable independientemente del proveedor. En los proyectos multiproveedor añade chips de filtro por motor para que puedas comparar el gasto por proveedor. Claude informa de su coste exacto; para Codex y Gemini, Specrails estima el coste a partir de una tarifa interna, así que las cifras son aproximaciones cercanas y no importes facturados.
+
+## Resolución de problemas
+
+- **No aparece un proveedor que instalé.** Confirma que la CLI está en tu `PATH` (prueba `claude --version` / `codex --version` / `gemini --version` en un terminal nuevo). La app detecta las CLI de los proveedores a través del `PATH` de tu sistema.
+- **Los servidores MCP de Codex no se cargan en el chat.** Codex lee los servidores MCP desde tu `~/.codex/config.toml` global; regístralos ahí con `codex mcp add`.
+- **Desactivación de emergencia.** Un proveedor se puede desactivar en toda la app mediante una variable de entorno (`SPECRAILS_CODEX_BETA=0` o `SPECRAILS_GEMINI_BETA=0`). Esto solo oculta el proveedor de la *selección*; rara vez es necesario.
+
+## Véase también
+
+Las guías dedicadas a cada proveedor profundizan en cada CLI: la guía de Codex y la guía de Gemini cubren la configuración, lo que funciona y las peculiaridades de cada proveedor.

package/docs/guide/es/integrations/2-plugins.md

@@ -0,0 +1,44 @@
+# Plugins (Integraciones)
+
+La sección **Integraciones** es un marketplace por proyecto de complementos opcionales que amplían lo que la IA puede hacer. Cada proyecto decide de forma independiente qué plugins quiere: instalar un plugin en un proyecto nunca afecta a otro.
+
+Los plugins funcionan registrando discretamente un **servidor MCP** (Model Context Protocol) en tu proyecto, lo que da a la IA nuevas herramientas para usar durante los rails y el chat. No necesitas entender MCP para usarlos: instálalos y estarán disponibles la próxima vez que se ejecute un rail.
+
+## Qué hay disponible hoy
+
+Esta versión se distribuye **solo con plugins incluidos**: los plugins que puedes instalar son los que vienen integrados en la app. No hay registro remoto, ni plugins subidos por usuarios, ni carga de código de terceros, así que todo lo del catálogo está revisado y se distribuye con Specrails.
+
+El plugin estrella es:
+
+- **Serena** — navegación semántica de código. Le da a la IA una comprensión de tu código respaldada por un language server (saltar a la definición, buscar referencias, búsqueda consciente de símbolos) en lugar de simple coincidencia de texto. Ideal para repos grandes o desconocidos en los que quieres que el agente razone sobre símbolos reales.
+
+  Serena requiere la herramienta `uv` en tu `PATH` (se ejecuta a través de `uvx`). La app detecta automáticamente si `uv` está presente y te avisa si falta.
+
+## Instalar un plugin
+
+1. Abre **Integraciones** desde la barra lateral derecha.
+2. Encuentra el plugin en el catálogo. Cada tarjeta muestra un estado: **No instalado**, **Instalado**, **Degradado** u **Huérfano**.
+3. Entra en el plugin para **previsualizar la instalación**: esto te muestra exactamente qué archivos cambiarán antes de que ocurra nada.
+4. Haz clic en **Instalar**. Verás el progreso en directo mientras se configura.
+
+Por debajo, la instalación es *quirúrgica y aditiva*: solo añade sus propias entradas al `.mcp.json` de tu proyecto (y, para algunos plugins, un archivo de fragmento en el espacio protegido `.claude/agents/`). Nunca reescribe tu configuración por completo, y añadir un segundo plugin nunca puede alterar el primero. Si la instalación no puede verificarse como saludable, se revierte de forma limpia.
+
+## Gestionar los plugins instalados
+
+- **Salud.** Cada plugin tiene una comprobación de salud bajo demanda. Un plugin que se instala bien pero que más tarde no puede arrancar se marca como **Degradado**: no bloqueará tus rails, simplemente verás la insignia y un motivo.
+- **Desinstalar.** Quitar un plugin elimina quirúrgicamente solo las entradas que le pertenecen, dejando intacto el resto de tu configuración.
+- **Huérfanos.** Si los archivos de un plugin quedan abandonados sin un estado correcto (por ejemplo, tras un cambio interrumpido), aparece como **Huérfano** y puedes limpiarlo con un clic.
+
+## Cómo aparecen los plugins en tu trabajo
+
+- **Rails.** Antes de que un rail se ejecute, Specrails comprueba qué plugins están instalados y saludables, y pone esas herramientas a disposición del agente para ese trabajo. Un plugin degradado simplemente se omite para esa ejecución: el rail se lanza igualmente con normalidad. Cada trabajo registra una instantánea de qué plugins estaban activos, que puedes ver en la exportación de diagnóstico del trabajo.
+- **Chat.** El chat recoge automáticamente la configuración MCP de tu proyecto, así que los plugins instalados también están disponibles ahí.
+- **Configuración.** Los plugins se ignoran mientras un proyecto todavía se está configurando; entran en juego una vez que el proyecto está listo.
+
+## Notas sobre proveedores
+
+Los plugins son conscientes del proveedor. Serena y otros plugins MCP similares se resuelven para los proveedores que registran MCP a través del `.mcp.json` del proyecto (Claude y Gemini). Para los proyectos con Codex, los servidores MCP se gestionan en cambio a través de la propia configuración global de Codex, así que las entradas de plugins en **Integraciones** se filtran en consecuencia. La tarjeta de Jira en Integraciones es independiente del proveedor y se muestra para todos: consulta la guía de Jira.
+
+## Archivos reservados
+
+Los plugins gestionan un conjunto pequeño y bien definido de archivos en tu proyecto: tu `.mcp.json` (mezclado quirúrgicamente), algo de estado bajo `.specrails/plugins/` y fragmentos de agente por plugin en `.claude/agents/custom-<plugin>.md`. Estos son activos de equipo que puedes commitear si quieres compartir una integración con tus compañeros: la app nunca los sobrescribe a ciegas.

package/docs/guide/es/integrations/3-jira-integration.md

@@ -0,0 +1,71 @@
+# Integración con Jira
+
+¿Quieres que tus specs vivan en un **tablero de Jira** real en lugar de dentro de Specrails? La integración con Jira respalda las specs de un proyecto con issues de Jira, mantiene los estados sincronizados a medida que se ejecutan los rails y no estorba el resto del tiempo. Cada proyecto se sincroniza con **su propio** tablero de Jira.
+
+## Cómo funciona (la versión corta)
+
+Specrails actúa como **capa de sincronización** entre Jira y tu proyecto. La idea central: tu almacén local de specs sigue siendo lo canónico que lee el pipeline, y Specrails se encarga de mantenerlo de acuerdo con Jira.
+
+- Cuando lanzas un rail, Specrails mueve el issue de Jira vinculado a **En progreso**.
+- Cuando un trabajo termina, Specrails transiciona el issue (a **Hecho**, o de vuelta a **Por hacer** si falló) y publica un comentario de finalización con el id del trabajo, el coste y la duración.
+- Periódicamente, Specrails **sondea** Jira en busca de cambios que cualquiera haya hecho en el tablero y los refleja de vuelta en tus specs.
+
+Todas las escrituras pasan por un outbox duradero y a prueba de fallos, así que un tropiezo puntual de Jira nunca rompe un trabajo: la actualización simplemente se reintenta.
+
+## Conectar un tablero
+
+Te conectas desde la página de **Ajustes** de un proyecto (también hay un paso opcional «Configurar Jira» al final del asistente de Añadir proyecto). El asistente de conexión te guía paso a paso:
+
+1. **Probar** — introduce la URL de tu Jira y tus credenciales, y Specrails verifica la conexión.
+2. **Elegir un proyecto** — elige con qué proyecto de Jira sincronizar.
+3. **Mapa de estados (opcional)** — asigna los estados de tu flujo de Jira a los estados de Specrails si la detección automática necesita una ayuda (más abajo).
+4. **Conectar** — listo. Tus specs ahora reflejan ese tablero.
+
+### Autenticación
+
+Esta versión usa autenticación por **pegado de token**: rápida, en el dispositivo y sin ningún backend de por medio:
+
+- **Jira Cloud:** el email de tu cuenta más un token de API.
+- **Jira Data Center / Server:** un Personal Access Token (PAT).
+
+Tu token se guarda **cifrado en tu propia máquina** y nunca sale de ella. La app solo muestra si hay un token presente, nunca el token en sí.
+
+## Mapeo de estados
+
+La parte más delicada de cualquier sincronización con Jira es hacer coincidir *tu* flujo de trabajo con los estados sencillos de Specrails (Por hacer / En progreso / Hecho, más las variantes de cancelar/entregar). Specrails lo resuelve en dos niveles:
+
+1. **Tu mapa de estados explícito**, si configuras uno en el asistente: siempre gana.
+2. **Detección automática** a partir de la categoría de cada estado (nuevo / en progreso / hecho) más una coincidencia inteligente para los estados de tipo cancelar y entregar.
+
+Cuando necesita mover un issue a través de un flujo con transiciones condicionadas, encuentra un camino válido paso a paso y rellena por el camino cualquier campo obligatorio (como una resolución). Si un estado realmente no se puede alcanzar, la operación se aparca como carta muerta (dead-letter) y se te muestra en lugar de fallar en silencio: verás un indicador **degradado** y podrás reintentar.
+
+## Hot-swap: actívalo y desactívalo con seguridad
+
+El vínculo con Jira es **por spec**, capturado en el momento en que lanzas un rail, no un interruptor global de todo-o-nada sobre el tablero. Eso hace que sea seguro alternarlo:
+
+- **Activar o desactivar** la integración nunca recoloca tus specs existentes.
+- **Desconectar** devuelve tu proyecto al comportamiento normal de specs locales.
+- Las specs que ya tienen un vínculo con Jira conservan su escritura; las que no, se quedan como están.
+
+Así que puedes experimentar con libertad —actívalo, ejecuta unos cuantos rails, desactívalo— sin desbaratar tu tablero ni tus specs locales.
+
+## El día a día
+
+Una vez conectado, la página de Ajustes del proyecto muestra una **tarjeta de conexión** donde puedes:
+
+- **Sincronizar ahora** — fuerza un sondeo inmediato en lugar de esperar al temporizador.
+- **Reintentar cartas muertas** — vuelve a ejecutar cualquier escritura que se haya quedado atascada.
+- **Interruptor de hot-swap** — pausa/reanuda la integración temporalmente.
+- **Desconectar** — separa el tablero de forma limpia.
+
+Las specs respaldadas por Jira muestran una **insignia con la clave de Jira** (como `PROJ-123`) en su tarjeta, y al hacer clic enlazan de vuelta al issue. También recibirás pequeñas notificaciones cuando una sincronización se complete, cuando un token de autenticación expire (para que lo refresques) o cuando la integración entre en estado degradado.
+
+## Cosas que tener en cuenta
+
+- **Sondeo, no webhooks.** Como Specrails se ejecuta en local, sondea Jira en busca de cambios entrantes en lugar de recibir notificaciones push. Los cambios aparecen dentro del intervalo de sondeo, no al instante.
+- **Un tablero por proyecto.** Distintos proyectos pueden sincronizar con distintos tableros; un único proyecto sincroniza con exactamente uno.
+- **Gana la última escritura** en los conflictos, para el caso poco frecuente en que dos pestañas editan el mismo borrador a la vez.
+
+## Desactivarlo
+
+Si en algún momento quieres dar marcha atrás del todo, simplemente **Desconecta** desde Ajustes. Tus specs vuelven al comportamiento solo-local y los metadatos de Jira simplemente quedan sin uso: no se destruye nada.