---
title: "Una CLI que pone un gate al trabajo de los agentes"
description: "cycle es la mitad de terminal de CommitCycle: registra la task, pasa el gate, emite el grant atado a una rama y escribe el registro al cerrar."
url: https://commitcycle.com/es/cli/
language: es
---

# El gate, el grant y el cierre, desde tu terminal

> cycle es la mitad de terminal de CommitCycle: registra la task, pasa el gate, emite el grant atado a una rama y escribe el registro al cerrar.

CommitCycle CLI Shipped

Un comando lleva una task de una frase a una rama con acceso adjunto, y otro la saca de vuelta con un registro. Lo de en medio es trabajo normal, hecho por el agente que prefieras.

Desde una terminal, cycle hace cada paso con un comando: start trae el grant a la máquina, submit lo devuelve.

## Instalación

```
npm i -g commitcycle
```

El paquete es `commitcycle` y el comando es `cycle`. Esa separación es deliberada: en cualquier máquina Unix `cc` ya es el compilador de C del sistema, así que un `cc` global rompería `node-gyp` y cualquier Makefile que nunca sobrescribiera `$(CC)`. Una herramienta de gobierno que ensombrece un compilador es una que la gente desinstala.

## El bucle diario

```
cycle start "la cosa" \
  --goal "…" --non-goals "…" --criteria "…" \
  --topics backend,frontend        # intake → scope → rama → gate → grant → contexto
# ... trabajo ...
cycle submit                       # In Progress → In Review, zones cerradas
cycle verify --close --evidence <url>   # el manifest, los checks, el registro
```

Los cuatro campos no son adorno en esa primera línea: el gate rechaza una task que no los trae y la deja en Todo, así que un `start` escrito sin ellos se detiene antes de abrir nada.

Toda vía de entrada a In Progress — `cycle start`, el botón Start de la consola, el `cc_start` del connector — es el mismo gate. No hay comando que abra una zone por su cuenta, y ése es justo el punto: en cuanto existe una segunda vía, es la que todo el mundo usa con prisa.

## Qué sabe hacer

| Comando              | Qué hace                                                                                                                                                                                            |
| -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `init`               | Prepara el repositorio y escribe el contexto del agente — en modo memory por defecto (sin zones; cada edición necesita una task), o con `--mode governance` para proponer zones a partir del código |
| `start`              | Intake, scope, rama, gate, grant y contexto, en una sola llamada                                                                                                                                    |
| `status`             | Qué task está activa, y exactamente qué tiene abierto ahora mismo                                                                                                                                   |
| `sync`               | Envía el mapa de zones y los eventos, trae el grant de esta rama                                                                                                                                    |
| `request-access`     | Pide al owner de una zone que la abra — con un motivo y una alternativa                                                                                                                             |
| `approve` · `deny`   | Responde desde la terminal a una petición para una zone de la que eres owner — desde una máquina emparejada, sólo en un board de un solo miembro. La consola es la vía más fuerte                   |
| `submit` · `pause`   | Entrega el trabajo, o déjalo sin abandonarlo                                                                                                                                                        |
| `verify --close`     | Contrasta la rama con lo que declaró la task, y escribe el registro                                                                                                                                 |
| `seed` · `challenge` | Redacta playbooks desde el código, y después discútelos                                                                                                                                             |
| `doctor`             | ¿Por qué se está comportando así CommitCycle?                                                                                                                                                       |

Treinta y siete en `cycle --help`, a fecha de la versión 0.1.25 (2026-10-12). La lista completa, flag por flag, está en [la referencia de la CLI](https://commitcycle.com/docs/reference/cli/) (en inglés).

## Dónde se detiene

- **No ejecuta tus agentes.** CommitCycle registra, pone el gate y deja constancia; quien escribe el código es lo que ya uses.
- **No puede cerrar saltándose las comprobaciones.** `verify --close` comprueba y registra; si falta la evidencia que nombra el quality gate, se niega y dice cuál.
- **El enforcement no vive en la CLI.** Bloquear una escritura mientras ocurre es cosa del hook, y el hook llega con [el plugin del editor](https://commitcycle.com/es/claude-code/). La CLI es el flujo; el plugin es el muro.
- **`discard` no pregunta.** Saca un spike de vuelta a su base con un solo comando e informa de la prueba; `promote`, que conserva lo que encontró el spike, pregunta una vez.

La referencia de comandos está en [la documentación](https://commitcycle.com/docs/reference/cli/) (en inglés), y el modelo sobre el que actúa es [el mapa de zones](https://commitcycle.com/es/zones/).

## Preguntas que responde esta página

### ¿Por qué el comando se llama cycle y no cc?

En cualquier máquina Unix cc ya es el compilador de C del sistema. Un cc global rompería node-gyp y cualquier Makefile que nunca sobrescribiera $(CC), y una herramienta de gobierno que ensombrece un compilador es una herramienta que la gente desinstala. El paquete npm es commitcycle; el comando es cycle.