# Pull requests

> Solo en Sypnia Cloud: cómo abre Sypnia un pull request con el arreglo, qué trae, qué puede hacer la GitHub App, qué nunca hace y los límites por plan.

Aplica a: Sypnia Cloud (servicio pago). Estado: al lanzar.  
Fuente: https://docs.sypnia.com/es/agent/pull-requests/

Para agentes: Pull requests de Sypnia Cloud: cuándo se puede abrir uno (confianza high o medium, repositorio conectado), rama sypnia/<slug del problema>, contenido del PR (cambio, prueba, descripción), permisos de la GitHub App (Contents RW, Pull requests RW, Metadata R), qué nunca hace (sin merge, sin push a la rama principal), modos de falla y arreglos por mes según el plan.

**\[Nube]** En Sypnia Cloud, un problema puede llegar con su arreglo como pull request. Sypnia escribe el cambio y una prueba en una rama de tu repositorio y abre el pull request. Una persona lo lee y hace el merge. **Sypnia nunca hace merge.**

El motor de código abierto no abre pull requests. Ahí, pásale el arreglo a tu propio agente de código con [el prompt](https://docs.sypnia.com/es/agent/the-prompt) o el [servidor MCP](https://docs.sypnia.com/es/mcp/connect). Es la misma información.

## Antes de empezar

- El proyecto está conectado a un repositorio por la GitHub App de Sypnia. Mira [La GitHub App](https://docs.sypnia.com/es/cloud/github-app) para instalarla y elegir repositorios.
- Tu app envía su `release` como el commit de git, así Sypnia sabe qué código estaba corriendo. Mira [Versiones y source maps](https://docs.sypnia.com/es/concepts/releases-and-source-maps).

## Cuándo se puede abrir un pull request

| Condición                                                   | Por qué                                                                                                                        |
| ----------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| El análisis está en `ready` con confianza `high` o `medium` | Sypnia no escribe un arreglo que no puede justificar. Con `low`, o `not_enough_evidence`, el botón está apagado y dice por qué |
| El problema está abierto                                    | Un problema resuelto o ignorado no necesita arreglo                                                                            |
| El problema no tiene un pull request abierto de Sypnia      | Uno a la vez por problema                                                                                                      |
| A la organización le quedan arreglos este mes               | Mira los límites abajo                                                                                                         |

Entonces se abre de una de dos formas:

- **Tú lo pides.** El botón «Abrir pull request» en el problema, o [`POST /v1/problems/{problem}/pull-request`](https://docs.sypnia.com/es/api/problems).
- **Solo**, si lo enciendes: el ajuste del proyecto `agent.auto_pull_requests` en `high_confidence` abre uno por cada análisis con confianza `high`. Viene apagado.

## Qué pasa

### 1. Sypnia lee el repositorio

Por la GitHub App, en el commit de la versión donde ocurre el problema. Lee los archivos que nombra el análisis y los que están alrededor. Tu código se usa para este pull request y no se guarda después.

### 2. Escribe el cambio y una prueba

El cambio más pequeño que quita la causa, y una prueba que falla sin él, en el framework de pruebas de tu proyecto. Si el proyecto no tiene pruebas, el pull request trae solo el cambio y lo dice.

### 3. Abre el pull request

En una rama nueva llamada `sypnia/<slug del problema>`, por ejemplo `sypnia/pay-button-does-nothing`, contra tu rama principal.

**Deberías ver:**En pocos minutos el problema muestra el pull request, y se envía el webhook `problem.pull_request_opened`.

### 4. Corren tus comprobaciones, una persona revisa

Sypnia no corre tu código. Tu propio CI corre sobre el pull request, como en cualquier otro. Tú lo lees, pides cambios o lo cambias tú, y haces el merge.

### 5. Después del merge

Cuando el arreglo esté desplegado, marca el problema como resuelto, o deja que lo haga tu agente de código. Si la falla vuelve, el problema se reabre solo.

## Qué trae el pull request

| Parte       | Contenido                                                                                                                                                                                         |
| ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Título      | Lo que hace el cambio, en imperativo: «Read the cart total from its new field»                                                                                                                    |
| Descripción | La frase del problema, a quién afectó y desde cuándo; la causa con su evidencia; qué se cambió y por qué; cómo lo cubre la prueba; enlaces al problema y a una sesión con grabación; la confianza |
| Commits     | Uno para el cambio, uno para la prueba, con autor `sypnia[bot]`                                                                                                                                   |
| Archivos    | Solo los que necesita el arreglo. Nunca archivos de workflows, archivos de bloqueo ni configuración de tu CI                                                                                      |

La descripción nunca trae nombres, correos ni ids de las personas afectadas.

## Qué puede hacer la GitHub App

La app pide tres permisos, en los repositorios que tú eliges y en ningún otro.

| Permiso       | Acceso              | Para qué                                                                          |
| ------------- | ------------------- | --------------------------------------------------------------------------------- |
| Contents      | Lectura y escritura | Leer el código; subir la rama `sypnia/<slug del problema>`                        |
| Pull requests | Lectura y escritura | Abrir el pull request y actualizar su descripción                                 |
| Metadata      | Lectura             | Lo exige GitHub para cualquier app: el nombre del repositorio y su rama principal |

## Qué nunca hace

- Nunca hace merge de un pull request, y nunca aprueba uno.
- Nunca sube cambios a tu rama principal ni a una rama que no creó. Nunca fuerza un push sobre commits de otra persona.
- Nunca cambia workflows, secretos, ajustes, colaboradores ni la protección de ramas. No tiene permiso para hacerlo.
- Nunca abre más de un pull request a la vez para un problema, y nunca reabre uno que cerraste.
- Nunca corre tu código ni tus pruebas.

Protege tu rama principal en GitHub para que todo pull request necesite una revisión. Los de Sypnia siguen entonces la misma regla que los de cualquiera.

## Cuando no puede

| Qué ves                                                                  | Por qué                                                                                                                                                                                                       |
| ------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| El botón apagado: «No hay evidencia suficiente para escribir un arreglo» | El análisis no tiene causa, o su confianza es `low`                                                                                                                                                           |
| El botón apagado: «Conecta un repositorio»                               | El proyecto no tiene repositorio por la GitHub App                                                                                                                                                            |
| `failed`, con una razón, en el problema                                  | Sypnia leyó el código y no pudo escribir un cambio en el que confíe: el código de ese commit no coincide con el análisis, o el arreglo tocaría más de lo debido. No se abrió nada y no contó contra tu límite |
| El pull request está abierto y tus comprobaciones fallan                 | Sypnia no reintenta por su cuenta. Arréglalo en la rama, o ciérralo y pide otro                                                                                                                               |

## Límites por plan

Un pull request cuenta cuando se abre. Pedir otro para el mismo problema cuenta otra vez. La cuenta es por organización, por mes calendario en UTC.

| Plan    | Pull requests que Sypnia abre al mes |
| ------- | ------------------------------------ |
| Free    | 5                                    |
| Builder | 50                                   |
| Team    | 300                                  |

Estos números salen de los [planes](https://docs.sypnia.com/es/cloud/plans-and-limits) y los muestra, con lo que llevas usado, [`GET /v1/usage`](https://docs.sypnia.com/es/api/projects-keys-and-tokens). En el límite, el botón dice cuándo se reinicia la cuenta; el análisis y el prompt siguen funcionando.
