# Referencia de las reglas de política

> Escribe reglas de política del espacio de trabajo para las sesiones de IA: las siete acciones, allow, ask y deny, los globs de recursos, los ajustes de confianza, el modo log-only y un ejemplo.

Fuente: https://aicodeops.dev/es/docs/policy-engine · Última actualización: 2026-11-15

Una política del espacio de trabajo decide qué pueden hacer las sesiones de IA por su cuenta, qué necesita la aprobación de una persona y qué no pueden hacer nunca. Esta página es la referencia para escribir reglas. Para saber cómo funcionan las aprobaciones una vez que una regla pide una, consulta [Aprobaciones y políticas](https://aicodeops.dev/es/docs/approvals-and-policies).

Las políticas solo rigen las sesiones. Lo que puede hacer una persona lo fija su [rol](https://aicodeops.dev/es/docs/roles-and-permissions).

## Abrir la política

Abre **Secure → Policies**. La página muestra:

- **Enforcement**: **Enforced** o **Log only**.
- **Rules in effect**, **Trust posture** y **Version**.
- **Rules**: el ID, la acción, el recurso y la decisión de cada regla.
- **What changed between versions**: las reglas añadidas, eliminadas y cambiadas entre dos versiones guardadas.
- **How rules apply**: las acciones y con qué coincide cada una.
- **Recent decisions**: las últimas denegaciones, retenciones y resultados en modo log-only, con **View session**.

La página se muestra a los roles con el permiso policy-manage: por defecto, Owner, Admin y Security Admin.

## Formato de las reglas

Las reglas se editan en un formulario, con una tarjeta por regla, o como un array JSON en la pestaña **Advanced (JSON)**. Cada regla tiene estos campos:

| Campo         | Obligatorio | Qué es                                                                         |
| ------------- | ----------- | ------------------------------------------------------------------------------ |
| `id`          | Sí          | De 1 a 64 caracteres: letras, dígitos, `.`, `_`, `:` o `-`. Único.             |
| `action`      | Sí          | Una de las acciones de más abajo, o `*` para todas las acciones.               |
| `decision`    | Sí          | `allow`, `ask` (necesita una aprobación) o `deny`.                             |
| `resource`    | No          | Un glob que se compara con lo que toca la acción. Si se omite, significa todo. |
| `description` | No          | Hasta 500 caracteres; se muestra bajo el ID de la regla.                       |
| `enabled`     | No          | `false` conserva la regla pero impide que se aplique.                          |

En el formulario son **Rule ID**, **Action**, **Decision**, **Resource**, **Description** y la casilla **On**. Una política puede contener hasta 200 reglas.

## Acciones

| Acción              | Etiqueta             | Recurso con el que coincide         | Cuándo se comprueba                                             | Decisiones       |
| ------------------- | -------------------- | ----------------------------------- | --------------------------------------------------------------- | ---------------- |
| `workflow.dispatch` | Start a session      | ID del flujo de trabajo             | Cuando se lanza una sesión                                      | allow, ask, deny |
| `agent.dispatch`    | Run an agent step    | ID del agente, p. ej. `builder`     | Cuando se lanza una sesión, para cada agente que va a ejecutar  | allow, ask, deny |
| `mcp.invoke`        | Call an MCP tool     | `server/tool`                       | Cuando se lanza una sesión, para cada herramienta MCP conectada | allow, deny      |
| `shell.command`     | Run the test command | el comando                          | Antes de que la sesión ejecute tus pruebas                      | allow, deny      |
| `diff.apply`        | Change a file        | ruta del archivo, p. ej. `infra/**` | Cuando se abre el pull request, para cada archivo               | allow, ask, deny |
| `github.push`       | Open a pull request  | `owner/repo`                        | Cuando se abre el pull request                                  | allow, ask, deny |
| `release.deploy`    | Deploy automatically | nombre del entorno                  | Antes de un despliegue automático tras una fusión               | allow, deny      |

Algunas acciones no pueden esperar a una persona, así que no pueden usar `ask`. El editor rechaza un `ask` en ellas. Un `ask` ya guardado en una de ellas se aplica como `deny`.

Qué hace cada decisión:

- **Inicio de la sesión** (`workflow.dispatch`, `agent.dispatch`): `deny` rechaza la sesión. `ask` la retiene hasta que alguien la aprueba en **Review & Gate → Approvals**; si se rechaza o se deja caducar, se cancela.
- **Herramientas MCP**: una herramienta que no está permitida nunca se ofrece a los agentes.
- **Pull request** (`github.push`, `diff.apply`): `deny` rechaza el pull request. `ask` exige una revisión aprobada del cambio. La sesión se ejecuta igualmente y propone su cambio; la regla decide si puede llegar a aplicarse.
- **Despliegue automático**: cualquier cosa que no sea `allow` detiene el despliegue. Se registra como un despliegue bloqueado para que puedas ver que no salió.

## Cómo se evalúan las reglas

1. Se considera toda regla habilitada cuya `action` coincide (o es `*`) y cuyo `resource` coincide.
2. Gana la decisión más estricta: `deny` gana a `ask`, y `ask` gana a `allow`. El orden de las reglas no importa.
3. Si ninguna regla coincide, decide el ajuste de confianza.

### Globs de recursos

- `**` coincide con cualquier cosa, incluida `/`.
- `*` coincide con cualquier secuencia de caracteres. En las rutas de archivos, `server/tool` y `owner/repo`, se detiene en `/`.
- `?` coincide con un carácter.
- Sin `resource`, `*` o `**` coinciden con todo.

Así, `src/*.ts` coincide con `src/app.ts` pero no con `src/lib/app.ts`; usa `src/**` para toda la carpeta.

## Ajuste de confianza

El ajuste se aplica cuando ninguna regla coincide.

| Ajuste                  | Decisiones por defecto                                                                                                                                    |
| ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `trusted`               | Todo está permitido.                                                                                                                                      |
| `limited` (por defecto) | Como trusted, pero abrir un pull request es `ask`.                                                                                                        |
| `none`                  | `deny` para las herramientas MCP, el comando de pruebas, los cambios de archivos, los pull requests y los despliegues automáticos, salvo que se permitan. |

Toda sesión que cambia código recibe además una solicitud de revisión en **Review & Gate → Approvals**. El ajuste se suma a eso; no lo elimina.

## Ejemplo

Esta política retiene las actualizaciones de dependencias a la espera de aprobación, pide una revisión de cualquier cambio en los archivos de infraestructura, bloquea los despliegues automáticos a producción y mantiene una herramienta MCP lejos de los agentes. Se muestra como el JSON que verías en la pestaña **Advanced (JSON)**:

```json
[
  {
    "id": "approve-dependency-refresh",
    "action": "workflow.dispatch",
    "resource": "dependency-refresh",
    "decision": "ask",
    "description": "A person approves before a dependency upgrade session starts"
  },
  { "id": "review-infra-changes", "action": "diff.apply", "resource": "infra/**", "decision": "ask" },
  { "id": "no-production-deploys", "action": "release.deploy", "resource": "production", "decision": "deny" },
  { "id": "no-repo-deletes", "action": "mcp.invoke", "resource": "github/delete_*", "decision": "deny" }
]
```

## Editar la política

1. Abre **Secure → Policies** y elige **Edit rules**.
2. Elige un **Trust posture**.
3. En la pestaña **Form**, cambia los campos de una regla, elige **Add rule** para una nueva o **Remove** para eliminar una. Desmarca la casilla **On** para conservar una regla sin aplicarla. El orden de las reglas no importa.
4. Elige **Save (version → N)**.

Para editar las reglas como texto, abre la pestaña **Advanced (JSON)**. Las dos pestañas editan las mismas reglas, así que un cambio hecho en una está ahí cuando cambias a la otra. Si el JSON no se puede leer, o tiene algo para lo que el formulario no tiene campo, la página se queda en la pestaña Advanced y dice qué hay que corregir.

Si una regla tiene un problema, no se guarda nada y cada problema se lista con su regla y su campo, por ejemplo `Rule 2 (no-repo-deletes), Decision: "Call an MCP tool" (mcp.invoke) can't wait for an approval, so it can't use ask. Choose allow or deny.` En el formulario, cada mensaje aparece también bajo su campo. Si otra persona guardó mientras editabas, ves "Policy conflict" y tus cambios no se guardan. Tus ediciones se quedan en el editor para que puedas copiarlas; elige **Cancel** para cargar su versión y después haz tu cambio de nuevo.

Cada guardado crea una versión nueva y una entrada `policy.updated` en el [registro de auditoría](https://aicodeops.dev/es/docs/audit-logs).

## Comparar versiones

**What changed between versions** muestra la diferencia entre dos versiones guardadas de la política. Se abre con la versión anterior frente a la actual; elige otras dos cualesquiera en **From** y **To**. Ves:

- las reglas en **Added**, **Removed** o **Changed**, con cada campo cambiado antes y después;
- el **Trust posture**, cuando cambió.

Las reglas se emparejan por ID, y su orden se ignora. Las versiones se conservan desde el primer guardado hecho después de que se añadiera esta comparación. Una política guardada por última vez antes de eso tiene una sola versión que mostrar hasta que se guarde de nuevo.

## Modo log-only

Elige **Switch to log only** para dejar de aplicar la política sin eliminar reglas. Cada decisión se sigue calculando y registrando, y se muestra como "logged" en **Recent decisions**, pero nada se bloquea ni se retiene. Elige **Enforce** para volver a activarla. Usa el modo log-only mientras ajustas una política nueva.

Solo se registran las decisiones distintas de un simple allow.

## Siguientes pasos

- [Aprobaciones y políticas](https://aicodeops.dev/es/docs/approvals-and-policies)
- [Roles y permisos](https://aicodeops.dev/es/docs/roles-and-permissions)
- [Servidores MCP](https://aicodeops.dev/es/docs/mcp-servers)

## Preguntas frecuentes

### ¿Importa el orden de mis reglas?

No. Se consideran todas las reglas que coinciden y gana la decisión más estricta, de modo que añadir una regla nunca puede relajar una anterior.

### ¿Las políticas limitan lo que pueden hacer las personas?

No. Las políticas rigen lo que pueden hacer las sesiones de IA. Lo que puede hacer una persona lo fija su rol.

### ¿Puedo probar una política sin bloquear a nadie?

Sí. Elige Switch to log only. Las reglas se siguen evaluando y cada decisión se registra, pero nada se bloquea ni se retiene.
