# Comandos

> Cada comando del binario sypnia, con sus opciones, ejemplos, salida y códigos de salida.

Aplica a: el motor de Sypnia (código abierto, en tu propia infraestructura) y Sypnia Cloud (servicio pago). Estado: al lanzar.  
Fuente: https://docs.sypnia.com/es/cli/commands/

Para agentes: Referencia de la CLI sypnia: serve, aggregate, migrate, doctor, project, key, token, sourcemaps upload, problems, problem, version; opciones, variables de entorno, salida de ejemplo y códigos de salida.

Cada comando de `sypnia`, en tres grupos. Cada uno dice dónde funciona: **\[Motor]** en un motor alojado por ti, **\[Nube]** contra Sypnia Cloud. Cómo instalar el binario, las variables que lee y qué significan sus códigos de salida está en el [resumen de la CLI](https://docs.sypnia.com/es/cli).

| Comando                                   | Qué hace                                               |
| ----------------------------------------- | ------------------------------------------------------ |
| `sypnia serve`                            | Corre el motor                                         |
| `sypnia aggregate`                        | Procesa lo que ha llegado, una vez                     |
| `sypnia migrate`                          | Crea o actualiza las tablas de la base de datos        |
| `sypnia doctor`                           | Comprueba que el motor está bien configurado           |
| `sypnia project create`, `list`, `delete` | Administra proyectos                                   |
| `sypnia key create`, `list`, `revoke`     | Administra llaves de ingesta                           |
| `sypnia token create`, `list`, `revoke`   | Administra tokens de API                               |
| `sypnia sourcemaps upload`                | Sube los source maps de un build y registra su versión |
| `sypnia problems`                         | Lista los problemas                                    |
| `sypnia problem`                          | Muestra un problema, o imprime su prompt listo         |
| `sypnia version`                          | Imprime la versión                                     |

Los nombres de los comandos y de las opciones, y lo que imprimen, están en inglés.

## Opciones de todos los comandos

**Opciones:**

- `--json` (boolean): Imprime el resultado en JSON, con la misma forma que la API HTTP. Las tablas y los colores son para personas; los scripts deben usar esto.
- `--quiet, -q` (boolean): Imprime solo los errores.
- `--no-color` (boolean): Sin colores. También cuando `NO_COLOR` está definida o la salida no es una terminal.
- `--config <file>` (path): Solo comandos del motor. Un archivo de configuración en TOML. Las variables de entorno ganan sobre el archivo. También `SYPNIA_CONFIG`.
- `--help, -h` (boolean): Explica el comando y sus opciones.

## Correr el motor

Estos comandos corren donde corre el motor. Leen la configuración del motor (mira la [referencia de configuración](https://docs.sypnia.com/es/self-hosting/configuration)) y necesitan la base de datos y el almacenamiento.

### `sypnia serve`

\[Motor]

**Corre el motor.**

Arranca todo en un solo proceso: la API HTTP, los endpoints de ingesta y de OTLP, el servidor MCP, la Consola y
el trabajador que procesa lo que llega (problemas, sesiones, números, comprobaciones de disponibilidad, alertas,
webhooks, retención). Es el motor completo para un despliegue con Docker.

El trabajador busca fallas nuevas cada `SYPNIA_PROCESSING_INTERVAL_SECONDS` (30 por defecto), y de inmediato
cuando la ingesta del mismo proceso escribió eventos nuevos, así un problema nuevo aparece en menos de 2
minutos. Todo lo demás lo cuenta cada 5 minutos.

Se detiene con orden al recibir `SIGTERM`: termina las peticiones en curso, hasta 20 segundos, y el trabajador
termina su paso actual. El procesamiento es idempotente, así que un trabajador que muere no pierde nada.

Para repartir la carga, corre varios procesos con roles distintos contra la misma base de datos y el mismo
bucket. La plantilla de AWS lo hace con funciones; cada función es este mismo binario con un rol.

**Opciones:**

- `--listen <address>` (string, por defecto `0.0.0.0:8080`): La dirección y el puerto donde escucha. También `SYPNIA_LISTEN`.
- `--role <role>` (all | ingest | api | worker, por defecto `all`): `ingest`: solo los endpoints de ingesta y de OTLP. `api`: solo la API, el servidor MCP y la Consola. `worker`: solo el procesamiento, sin HTTP salvo `/healthz`. `all`: todo. También `SYPNIA_ROLE`.

**Correr el motor completo:**

```bash
sypnia serve
```

`Salida`

```text
sypnia 1.0.0  role=all  listen=0.0.0.0:8080
database  ok  postgres 16.4, schema 12
storage   ok  s3://sypnia-shop (us-east-1)
ai        off (SYPNIA_AI_PROVIDER=none)
ready     https://sypnia.example.com
```

**Correr la ingesta y el trabajador por separado:**

```bash
sypnia serve --role ingest --listen 0.0.0.0:8081
sypnia serve --role worker
```

Códigos de salida: `0`, `3`, `4`.

### `sypnia aggregate`

\[Motor]

**Procesa lo que ha llegado, una vez.**

Corre una pasada del trabajador y termina: lee los eventos crudos que llegaron desde la pasada anterior, agrupa
las fallas en problemas, arma las sesiones, actualiza los números, corre las comprobaciones de disponibilidad
que tocan, crea alertas y envía webhooks. `sypnia serve` hace esto solo cada 30 segundos; este comando solo
hace falta para procesar desde tu propio programador de tareas (córrelo cada minuto), o para volver a procesar
un rango de tiempo con `--from` y `--to`.

Volver a procesar un rango es seguro, y nada se cuenta dos veces. Los números que se guardan por hora
(rendimiento de páginas y de la API) se reemplazan con lo que dan los eventos crudos de esa hora. Los
contadores que solo suman (los totales de una sesión, los clics por día, el uso, las ocurrencias de un
problema) no se reemplazan: el motor lleva un registro de los objetos crudos que ya sumó, y suma cada uno
una sola vez.

**Opciones:**

- `--project <id or slug>` (string): Solo este proyecto. Todos si se omite.
- `--from <time>` (string): Vuelve a procesar desde este momento: una fecha ISO 8601 o un valor relativo (`6h`, `2d`). Necesita `--to`, o toma ahora.
- `--to <time>` (string): Fin del rango que se vuelve a procesar.
- `--task <task>` (all | events | uptime | alerts | webhooks | retention | suggestions, por defecto `all`): Corre solo una parte de la pasada. `suggestions` corre ahora las sugerencias semanales, para la semana que terminó.
- `--watch` (boolean): Sigue corriendo y hace otra pasada cada `SYPNIA_PROCESSING_INTERVAL_SECONDS`. Igual que `serve --role worker` sin `/healthz`.

**Una pasada:**

```bash
sypnia aggregate
```

`Salida`

```text
shop  events 412 -> 2 sessions, 1 problem (0 new), 3 routes   0.8 s
shop  uptime 1 check, 0 down
shop  alerts 0 created, webhooks 0 sent
done in 1.1 s, data through 2026-03-12T10:34:10Z
```

**Volver a procesar ayer para un proyecto:**

```bash
sypnia aggregate --project shop --from 2026-03-11T00:00:00Z --to 2026-03-12T00:00:00Z
```

Códigos de salida: `0`, `1`, `3`, `4`.

### `sypnia migrate`

\[Motor]

**Crea o actualiza las tablas de la base de datos.**

Aplica las migraciones de base de datos que trae el binario, en orden, cada una en una transacción. Córrelo una
vez después de instalar y después de cada actualización, antes de arrancar la versión nueva. Las migraciones
solo agregan: un binario más viejo sigue funcionando contra un esquema más nuevo, así que puedes actualizar sin
detener nada.

`sypnia serve` se niega a arrancar contra un esquema más viejo que él (código de salida 3), salvo que
`SYPNIA_AUTO_MIGRATE` sea `true`.

**Opciones:**

- `--status` (boolean): Muestra qué migraciones están aplicadas y cuáles faltan, y no cambia nada.
- `--dry-run` (boolean): Imprime el SQL que correría, y no cambia nada.

**Aplicar las migraciones pendientes:**

```bash
sypnia migrate
```

`Salida`

```text
schema 11 -> 12
applied 0012_suggestions  (0.2 s)
database is up to date
```

Códigos de salida: `0`, `3`, `4`.

### `sypnia doctor`

\[Motor]

**Comprueba que el motor está bien configurado.**

Lee la configuración y prueba cada pieza de la que depende el motor, una línea por cada una: los ajustes
mismos, la base de datos (alcanzable, Postgres 15 o posterior, esquema al día), el almacenamiento (escribe, lee
y borra un objeto de prueba, y firma un enlace), la dirección pública, el proveedor de IA (una petición pequeña
al modelo que configuraste) y el webhook de alertas (envía un `ping` firmado). Cada falla dice qué está mal y
qué ajuste cambiar.

Córrelo después de instalar, después de cambiar un ajuste, y antes que nada cuando algo no funcione. La
comprobación de IA le envía unos 20 tokens a tu proveedor; sáltala con `--skip ai`.

**Opciones:**

- `--only <checks>` (string): Comprobaciones que correr, separadas por comas: `config`, `database`, `storage`, `address`, `ai`, `webhook`, `clock`.
- `--skip <checks>` (string): Comprobaciones que saltar, separadas por comas.

**Comprobar todo:**

```bash
sypnia doctor
```

`Salida`

```text
config    ok    14 settings read, 0 unknown
database  ok    postgres 16.4, schema 12 (up to date), 3 ms
storage   ok    s3://sypnia-shop: put, get, delete, presign
address   ok    https://sypnia.example.com/healthz answered 200
ai        ok    openrouter, model <model>: answered in 0.9 s
webhook   skip  SYPNIA_ALERT_WEBHOOK_URL is not set (alerts are recorded only)
clock     ok    0.2 s from the database's clock
all checks passed
```

**Cuando el nombre del modelo está mal:**

```bash
sypnia doctor --only ai
```

`Salida`

```text
ai        FAIL  openrouter answered 404: no model named "<model>"
                Set SYPNIA_AI_MODEL to a model your provider offers.
1 check failed
```

Códigos de salida: `0`, `1`, `3`.

## Proyectos, llaves y tokens

Estos comandos llaman a la API HTTP, así que funcionan desde cualquier máquina. En un motor alojado por ti usa el token raíz (`SYPNIA_ROOT_TOKEN`) y di cuál motor con `SYPNIA_BASE_URL`. En Sypnia Cloud, `key` y `token` funcionan con un token de API `admin`; los proyectos se crean en la app.

### `sypnia project create`

\[Motor]

**Crea un proyecto.**

Crea un proyecto e imprime su primera llave de ingesta. Solo en motores alojados por ti; necesita el token raíz. En Sypnia Cloud los proyectos se crean en la app.

Llama a: `POST /v1/projects`

**Opciones:**

- `--name <name>` (string, obligatorio): El nombre que ve la gente.
- `--slug <slug>` (string): Un nombre corto para URLs y comandos. Por defecto, el nombre en minúsculas con guiones.
- `--timezone <zone>` (string, por defecto `UTC`): Una zona horaria IANA, como `America/Bogota`. Los días se cortan en ella.

**Crear el proyecto de la tienda:**

```bash
sypnia project create --name Shop
```

`Salida`

```text
project     shop (prj_5k2m9x4q7w1z)
ingest key  spk_7d1f0c9e4b8a2f6d3c5e1a9b0f4d8c2e

Put the ingest key in your app. It is public: it can only send.
Next: sypnia token create --project shop --name "My laptop" --scopes read,replay
```

Códigos de salida: `0`, `1`, `4`, `5`.

### `sypnia project list`

\[Motor, Nube]

**Lista los proyectos.**

Con el token raíz, todos los proyectos del motor. Con un token de API, el único proyecto al que pertenece.

Llama a: `GET /v1/projects`

**Opciones:**

Ninguno.

**Listar proyectos:**

```bash
sypnia project list
```

`Salida`

```text
SLUG  ID                NAME  CREATED     ENVIRONMENTS
shop  prj_5k2m9x4q7w1z  Shop  2026-02-02  production, development
```

Códigos de salida: `0`, `4`, `5`.

### `sypnia project delete`

\[Motor]

**Borra un proyecto y todos sus datos.**

Borra el proyecto para siempre. Te pide escribir otra vez el slug, salvo que pases `--yes`. Solo en motores alojados por ti; necesita el token raíz.

Llama a: `DELETE /v1/projects/{project_ref}`

**Argumentos:**

- `<slug>` (string, obligatorio): El slug o el id del proyecto.

**Opciones:**

- `--yes` (boolean): No preguntar. Para scripts.

**Borrar un proyecto de prueba:**

```bash
sypnia project delete playground --yes
```

Códigos de salida: `0`, `4`, `5`, `6`.

### `sypnia key create`

\[Motor, Nube]

**Crea una llave de ingesta.**

Crea otra llave de ingesta para un proyecto. Dale a cada app o plataforma la suya.

Llama a: `POST /v1/keys`

**Opciones:**

- `--project <id or slug>` (string): El proyecto. Hace falta con el token raíz. También `SYPNIA_PROJECT`.
- `--name <name>` (string, obligatorio): Para qué es la llave.
- `--rate-limit <n>` (integer, por defecto `600`): Peticiones por minuto que se aceptan desde una misma dirección con esta llave. De 10 a 6000.

**Una llave para el servidor de la API:**

```bash
sypnia key create --project shop --name "Checkout API"
```

`Salida`

```text
key_8b5n2m7v4c1x  spk_a3c9e1f7b5d2084c6e0a9f3b7d1c5e82  Checkout API
```

Códigos de salida: `0`, `1`, `4`, `5`, `6`.

### `sypnia key list`

\[Motor, Nube]

**Lista las llaves de ingesta de un proyecto.**

Muestra todas las llaves, incluidas las revocadas. Las llaves de ingesta son públicas, así que se imprimen completas.

Llama a: `GET /v1/keys`

**Opciones:**

- `--project <id or slug>` (string): El proyecto. Hace falta con el token raíz. También `SYPNIA_PROJECT`.

**Listar llaves:**

```bash
sypnia key list --project shop
```

`Salida`

```text
ID                KEY                                   NAME     LAST USED         STATUS
key_3n8v2c6b1m4x  spk_7d1f0c9e4b8a2f6d3c5e1a9b0f4d8c2e  Web app  2026-03-12 10:00  active
```

Códigos de salida: `0`, `4`, `5`, `6`.

### `sypnia key revoke`

\[Motor, Nube]

**Revoca una llave de ingesta.**

Revoca una llave. Las apps que todavía la usan dejan de enviar en menos de un minuto. La última llave activa de un proyecto no se puede revocar.

Llama a: `DELETE /v1/keys/{key_id}`

**Argumentos:**

- `<key_id>` (string, obligatorio): El id del registro de la llave (`key_…`), de `key list`.

**Opciones:**

- `--project <id or slug>` (string): El proyecto. Hace falta con el token raíz. También `SYPNIA_PROJECT`.

**Revocar una llave:**

```bash
sypnia key revoke key_8b5n2m7v4c1x --project shop
```

Códigos de salida: `0`, `1`, `4`, `5`, `6`.

### `sypnia token create`

\[Motor, Nube]

**Crea un token de API.**

Crea un token de API e imprime su secreto una sola vez. Cópialo ahora; no se puede volver a mostrar.

Llama a: `POST /v1/tokens`

**Opciones:**

- `--project <id or slug>` (string): El proyecto. Hace falta con el token raíz. También `SYPNIA_PROJECT`.
- `--name <name>` (string, obligatorio): Quién o qué va a usar el token.
- `--scopes <list>` (string, obligatorio): Separados por comas: `read`, `replay`, `admin`. Da los mínimos que alcancen para el trabajo.
- `--expires <time>` (string): Cuándo deja de funcionar el token: un valor relativo (`90d`) o una fecha ISO 8601. Si se omite, no vence.

**Un token para tu agente de código:**

```bash
sypnia token create --project shop --name Cursor --scopes read
```

`Salida`

```text
tok_9r4t6y2u8i1o  Cursor  read
sps_4Kq9Zt2MxV7bN1cR5wY8pL3dF6hJ0sA2gE4uT9iO

This is the only time the token is shown.
```

**Un token para CI, para subir source maps:**

```bash
sypnia token create --project shop --name "CI source maps" --scopes admin --expires 365d
```

Códigos de salida: `0`, `1`, `4`, `5`, `6`.

### `sypnia token list`

\[Motor, Nube]

**Lista los tokens de API de un proyecto.**

Muestra cada token con sus permisos y cuándo se usó por última vez. Los secretos nunca se muestran; el prefijo basta para reconocer uno.

Llama a: `GET /v1/tokens`

**Opciones:**

- `--project <id or slug>` (string): El proyecto. Hace falta con el token raíz. También `SYPNIA_PROJECT`.

**Listar tokens:**

```bash
sypnia token list --project shop
```

`Salida`

```text
ID                NAME    PREFIX        SCOPES        LAST USED         EXPIRES  STATUS
tok_9r4t6y2u8i1o  Cursor  sps_4Kq9Zt2M  read, replay  2026-03-12 10:00  never    active
```

Códigos de salida: `0`, `4`, `5`, `6`.

### `sypnia token revoke`

\[Motor, Nube]

**Revoca un token de API.**

Revoca un token. Las peticiones con él se rechazan en menos de un minuto.

Llama a: `DELETE /v1/tokens/{token_id}`

**Argumentos:**

- `<token_id>` (string, obligatorio): El id del registro del token (`tok_…`), de `token list`.

**Opciones:**

- `--project <id or slug>` (string): El proyecto. Hace falta con el token raíz. También `SYPNIA_PROJECT`.

**Revocar un token:**

```bash
sypnia token revoke tok_9r4t6y2u8i1o --project shop
```

Códigos de salida: `0`, `4`, `5`, `6`.

## Trabajar con un proyecto

Estos comandos llaman a la API HTTP con un token de API en `SYPNIA_API_TOKEN`. Funcionan igual contra Sypnia Cloud y contra un motor alojado por ti.

### `sypnia sourcemaps upload`

\[Motor, Nube]

**Sube los source maps de un build y registra su versión.**

Córrelo en tu build, después de empaquetar y antes de desplegar. Hace cuatro cosas:

1. Encuentra cada archivo JavaScript dentro del directorio y el mapa al que apunta (su comentario
   `sourceMappingURL`, o el archivo de al lado que termina en `.map`).
2. Registra la versión, con lo que sabe git: el commit, los commits desde la versión anterior y los archivos
   que cambiaron. Esto es lo que le permite a Sypnia decir «desde el cambio de ayer».
3. Sube los mapas que Sypnia todavía no tiene, directo al almacenamiento.
4. Con `--delete-after`, borra los archivos `.map` del directorio, para que nunca se publiquen.

Correrlo dos veces cuesta poco: los mapas que ya están se saltan. Necesita un token de API con el permiso
`admin` en `SYPNIA_API_TOKEN`; guárdalo en los secretos de tu CI.

Por defecto una falla detiene tu build (código de salida 1 o 4). Pasa `--allow-failure` si un despliegue nunca
debe esperar a Sypnia: el comando imprime el error y termina con 0, y las pilas de esa versión quedan
minificadas.

Llama a: `POST /v1/releases, POST /v1/releases/{version}/sourcemaps`

**Argumentos:**

- `<directory>` (string, obligatorio): La salida del build que tiene los archivos JavaScript y sus mapas, por ejemplo `dist` o `.next/static`.

**Opciones:**

- `--release <version>` (string, obligatorio): El nombre de la versión: la misma cadena que tu app le pasa a `init` como `release`. Usa el commit corto de git.
- `--url-prefix <path>` (string, por defecto `/`): La ruta desde la que tu sitio sirve el directorio. Con `dist/assets/a.js` servido como `/assets/a.js`, sube `dist` con `/`, o `dist/assets` con `/assets`.
- `--environment <name>` (string, por defecto `production`): El entorno donde se despliega la versión.
- `--changes <mode>` (git | none, por defecto `git`): `git` envía el commit, los commits desde la versión anterior y los archivos cambiados, leídos del repositorio del directorio actual. `none` envía solo el nombre de la versión.
- `--patches` (boolean): Envía además el diff de cada archivo cambiado. Hace más preciso el análisis. Los diffs son tu código: se guardan en tu motor, o en Sypnia Cloud, y se envían al proveedor de IA con el análisis.
- `--previous <version>` (string): La versión a la que esta reemplaza. Por defecto, la última versión del proyecto en el entorno.
- `--delete-after` (boolean): Borra los archivos `.map` del directorio después de una subida exitosa.
- `--allow-failure` (boolean): Termina con 0 aunque la subida falle.
- `--dry-run` (boolean): Muestra qué se registraría y qué se subiría, y no envía nada.
- `--concurrency <n>` (integer, por defecto `8`): Subidas al mismo tiempo. De 1 a 32.

**En un script de build:**

```bash
sypnia sourcemaps upload dist --release "$(git rev-parse --short HEAD)" --delete-after
```

`Salida`

```text
release   4f2a91c (production), previous 9c1e7b2: 1 commit, 2 files changed
found     42 JavaScript files with a source map
uploaded  41 maps (6.2 MB), skipped 1 already there
deleted   42 .map files from dist
done in 3.4 s
```

Códigos de salida: `0`, `1`, `2`, `4`, `5`.

### `sypnia problems`

\[Motor, Nube]

**Lista los problemas.**

Imprime los problemas del proyecto en una tabla, con la actividad más reciente primero. Los mismos filtros que la API. Con `--json` imprime lo que devuelve `GET /v1/problems`.

Llama a: `GET /v1/problems`

**Opciones:**

- `--status <status>` (open | resolved | ignored | all, por defecto `open`): Qué problemas listar.
- `--since <time>` (string, por defecto `30d`): Solo problemas vistos después de este momento.
- `--environment <name>` (string, por defecto `production`): El entorno que se lee.
- `--query <text>` (string): Texto que buscar en la frase, el título o el archivo.
- `--sort <field>` (last_seen | first_seen | people | occurrences, por defecto `last_seen`): El orden.
- `--limit <n>` (integer, por defecto `20`): Cuántos imprimir. De 1 a 200.
- `--project <id or slug>` (string): El proyecto. Hace falta con el token raíz. También `SYPNIA_PROJECT`.

**Qué está abierto:**

```bash
sypnia problems
```

`Salida`

```text
1 open problem in shop (production)

pay-button-does-nothing   3 people   since today 09:12   release 4f2a91c
  3 people tried to pay today and could not. The Pay button does nothing
  since yesterday's change.
  src/checkout/checkout.tsx:142  confidence high
```

Códigos de salida: `0`, `4`, `5`.

### `sypnia problem`

\[Motor, Nube]

**Muestra un problema.**

Imprime un problema: la frase, a quién afectó, desde cuándo, la causa con su evidencia, qué hacer y dónde
mirar. Con `--context` agrega la pila con líneas de código, lo que hizo la persona antes y la traza. Con
`--prompt` imprime solo el prompt listo, en texto plano, para que lo puedas pasar a un archivo o a un agente de
código.

Llama a: `GET /v1/problems/{problem}, /context, /prompt`

**Argumentos:**

- `<problem>` (string, obligatorio): El slug o el id del problema.

**Opciones:**

- `--context` (boolean): Imprime además la pila, los pasos previos, la traza y los cambios de la versión.
- `--prompt` (boolean): Imprime solo el prompt listo.
- `--project <id or slug>` (string): El proyecto. Hace falta con el token raíz. También `SYPNIA_PROJECT`.

**Leer un problema:**

```bash
sypnia problem pay-button-does-nothing
```

`Salida`

```text
pay-button-does-nothing   open   prb_8f3k2m9x4q7w

3 people tried to pay today and could not. The Pay button does nothing
since yesterday's change.

Who         3 people. Two of them tried again and gave up.
Doing       Paying for an order, at the last step of checkout.
Since       Yesterday's change, deployed at 18:40. It worked before.
Cause       Release 4f2a91c renamed the cart's total from cart.total to
            cart.totalCents. The checkout still reads cart.total, so the
            payment goes out without an amount and the API answers 400.
            (confidence: high)
Evidence    4f2a91c:src/cart/cart.ts        renames total to totalCents
            src/checkout/checkout.tsx:142   still passes cart.total
            trace 7c2e9a4b…                 POST /api/checkout answered 400 amount_required
What to do  Read cart.totalCents in confirmPayment(), and show the customer
            a message when a payment is rejected.
Where       src/checkout/checkout.tsx:142  confirmPayment()
Open        https://app.sypnia.com/shop/problems/pay-button-does-nothing
```

**Copiar el prompt para tu agente de código:**

```bash
sypnia problem pay-button-does-nothing --prompt > fix.md
```

Códigos de salida: `0`, `4`, `5`, `6`.

### `sypnia version`

\[Motor, Nube]

**Imprime la versión.**

Imprime la versión del binario, su commit y el esquema de base de datos más nuevo que conoce. Con `--json`, como objeto.

**Opciones:**

Ninguno.

**Versión:**

```bash
sypnia version
```

`Salida`

```text
sypnia 1.0.0 (a1c9e3f, 2026-03-01) schema 12
```

Códigos de salida: `0`.
