taskswarm

TaskSwarm

Instalación • Inicio rápido • Qué hace • Referencia de CLI • Servidor MCP • Cómo se compara • Preguntas frecuentes

Servidor de eventos autohospedado y CLI que dispara una notificación local del sistema operativo y actualiza una página de estado en vivo en el instante en que una sesión de agente de codificación en paralelo se bloquea, necesita revisión, falla o termina.

Estás ejecutando tres sesiones de Claude Code en dos repositorios. Una de ellas encontró un aviso de permiso hace cuatro minutos y ha estado esperando desde entonces, esperándote a ti. No lo sabías, porque nada te lo dijo. Simplemente volviste a la pestaña para comprobarlo.

TaskSwarm es un servidor de eventos autohospedado que soluciona eso. Cada sesión de agente informa su estado, y en el instante en que una se bloquea, necesita revisión, falla o termina, TaskSwarm dispara una notificación local del sistema operativo y actualiza una página de estado en vivo. Sin necesidad de sondear terminales. Sin cuenta. Sin dependencia de la nube.

Instalación

TaskSwarm se distribuye como dos distribuciones independientes e igualmente de primera clase del mismo servidor de eventos: un paquete npm (este código base, TypeScript) y un paquete PyPI (taskswarm-cli, Python, python/). Elige el que se ajuste a tu cadena de herramientas; el servidor y la CLI no necesitan ser de la misma distribución que el agente desde el que informas.

npm (JS/TS): disponible en npm como taskswarm-cli:

npm install -g taskswarm-cli
taskswarm start

¿Prefieres no instalar globalmente? npx taskswarm-cli start ejecuta el mismo binario sin paso de instalación.

pip (Python): disponible en PyPI como taskswarm-cli (renombrado desde el paquete original taskswarm, que ha dejado de recibir actualizaciones y apunta aquí):

pip install taskswarm-cli
taskswarm start

Consulta python/README.md para la guía específica de Python. Ambas distribuciones hablan el mismo protocolo de cable (el mismo esquema de eventos, la misma regla de deduplicación de notificaciones), por lo que un servidor iniciado en Python y una CLI de npm que informe hacia él (o viceversa) funcionan juntos sin problemas.

Inicio rápido

# Terminal 1: start the server
node dist/cli.js start
# TaskSwarm server listening on http://127.0.0.1:4173
# Live status page: http://127.0.0.1:4173/?token=<your-token>

# Terminal 2: report a session's status as it works
node dist/cli.js agent report-status --task my-fix --repo ./api --state running
node dist/cli.js agent report-status --task my-fix --repo ./api --state done

Abre la URL de la página de estado en vivo impresa por start. La fila para my-fix se actualiza en el instante en que cada llamada a report-status llega, sin necesidad de actualizar. Esta es la salida real de ese flujo, capturada mientras se escribía este README:

{
  "sessions": [
    {
      "session_id": "my-fix",
      "latest": { "repo": "./api", "agent_type": "generic", "status": "done", "...": "..." },
      "history": [
        { "status": "running", "timestamp": "2026-07-15T23:46:41.376Z" },
        { "status": "done", "timestamp": "2026-07-15T23:46:41.436Z" }
      ]
    }
  ]
}

Conéctalo directamente a Claude Code en lugar de llamar a report-status manualmente:

node dist/cli.js hooks install claude-code

Esto escribe hooks de Stop/Notification en .claude/settings.json para el proyecto actual. Cada turno que Claude Code termina, y cada aviso de permiso o espera inactiva que presenta, ahora se informa automáticamente a TaskSwarm.

Sigue tareas localmente independientes del estado de sesión en vivo (una lista de tareas ligera, no el flujo de eventos):

node dist/cli.js task add --title "Fix flaky test" --repo ./api
node dist/cli.js task list

Qué hace

• Notificaciones push, desde un tablero que no tienes que mantener abierto. En el momento en que una sesión transiciona a blocked, needs-review, failed o done, TaskSwarm dispara una notificación nativa del sistema operativo (osascript en macOS, un fallback de campana de terminal en otros lugares). Latencia de envío medida más abajo. Ni paperclip, Vibe Kanban ni Multica (ver comparación más abajo) hacen esto; los tres son tableros que tienes que estar mirando.
• Una página de estado en vivo que se actualiza mediante eventos enviados por el servidor, no mediante sondeo. Una tabla plana: sesión, repositorio, tipo de agente, estado, marca de tiempo del último evento. Sin botón de actualizar.
• Integración real de hooks de Claude Code, verificada contra la referencia publicada de hooks. taskswarm hooks install claude-code escribe entradas de hook Stop y Notification en .claude/settings.json, apuntando al binario exacto de Node y al script de CLI ya en disco. Evita deliberadamente npx; consulta el comentario de código en src/adapters/claude-code-adapter.ts para saber por qué la resolución flotante de registro en cada disparo de hook es un riesgo de la cadena de suministro. Una advertencia expresada claramente: el hook Stop de Claude Code se dispara por turno, no por tarea, por lo que una sesión larga de múltiples turnos actualmente informa done después de cada turno, no solo el final.
• Un fallback de script envoltorio para Codex, Cursor o cualquier otra cosa. taskswarm agent report-status --task <id> --repo <path> --state <state> es la misma primitiva que el adaptador de Claude Code llama internamente. Cualquier script que envuelva cualquier agente CLI puede llamarlo directamente.
• Una API local protegida por token portador, vinculada a loopback por defecto. POST /events y la página en vivo requieren el token que TaskSwarm genera en el primer arranque (~/.taskswarm/config.json, escrito 0600). Rótalo con taskswarm token rotate.
• Diseñado para agentes por naturaleza. Cada subcomando incluye una bandera --json con un esquema estable, incluida la salida de errores, para que un script que llame a esta CLI nunca tenga que extraer texto con formato humano.
• ntfy.sh es opcional, nunca por defecto. El único canal de notificación que sale de tu máquina, y está desactivado a menos que lo actives. La afirmación de autohospedado se mantiene de principio a fin sin él.

[!NOTA] La notificación push nativa del sistema operativo solo se dispara en macOS, mediante osascript. En Linux y Windows, TaskSwarm recurre a una línea de consola más una campana de terminal en lugar de una notificación del sistema, aún local, aún sin ntfy.sh a menos que lo actives.

Referencia de CLI

Capturada directamente de la salida de --help en la CLI compilada (node dist/cli.js <command> --help):

Comando	Descripción	Opciones clave
taskswarm start	Inicia el servidor TaskSwarm e imprime la URL de la página de estado en vivo	--json
taskswarm task add	Registra una nueva tarea	--title <title> (obligatorio), --repo <path> (obligatorio), --json
taskswarm task list	Lista tareas rastreadas, enriquecidas con estado en vivo cuando el servidor es accesible	--json
taskswarm agent report-status	Informa una transición de estado para una tarea/sesión al servidor local	--task <id> (obligatorio), --repo <path> (obligatorio), --state <state> (obligatorio, uno de queued|running|blocked|needs-review|done|failed), --blocked-reason <text>, --agent-type <type> (claude-code|codex|cursor|generic, por defecto generic), --json
taskswarm token rotate	Genera un nuevo token portador, invalidando el anterior	--json
taskswarm hooks install <adapter>	Instala hooks para una integración de agente (actualmente claude-code)	--scope <project|local|user> (por defecto project), --project-dir <path>, --json
taskswarm hooks claude-code-relay	Interno: lee una carga útil de hook desde stdin y la retransmite. Se instala automáticamente; no está pensado para ejecutarse manualmente.	ninguna

Cada subcomando también acepta -h, --help. taskswarm --version imprime el número de versión del paquete instalado, leído en vivo desde package.json (para que siempre coincida con la versión que realmente tienes instalada, en lugar de un número fijo que quedaría obsoleto aquí).

Un fallo real, como referencia

$ node dist/cli.js agent report-status --task foo --repo /tmp/x --state bogus
error: option '--state <state>' argument 'bogus' is invalid. Allowed choices are queued, running, blocked, needs-review, done, failed.

$ node dist/cli.js agent report-status --task foo --repo /tmp/x --state blocked
Error: could not reach TaskSwarm server at http://127.0.0.1:4173 -- is it running? (`taskswarm start`)

Ambos salen con código de salida distinto de cero con un mensaje en inglés sencillo y sin rastro de pila, incluso bajo --json.

Referencia de la API de biblioteca

El paquete npm también es importable, no solo ejecutable como CLI: main/types apuntan a dist/index.js/dist/index.d.ts, y src/index.ts exporta una superficie pública real para cualquier cosa que quiera incrustar el almacén de eventos, el servidor o los adaptadores directamente en lugar de invocar procesos externos.

Esquema (src/schema/events.ts)

• agentEventSchema, agentEventInputSchema -- esquemas Zod para el sobre de eventos
• toAgentEvent(input: AgentEventInput): AgentEvent -- completa los valores por defecto de event_id/timestamp/schema_version
• AGENT_TYPES, AGENT_STATUSES -- los arrays constantes que respaldan los tipos de unión AgentType/AgentStatus
• NOTIFY_ON_STATUSES: ReadonlySet<AgentStatus> -- los cuatro estados que disparan una notificación: blocked, needs-review, failed, done
• CURRENT_SCHEMA_VERSION -- el número de versión actual del sobre

Servidor (src/server/)

• class EventStore extends EventEmitter -- almacén de sesiones en memoria respaldado por un registro JSONL de solo añadidura. constructor(logPath?: string, options?: EventStoreOptions). Métodos: append(event): { previousStatus, previousBlockedReason }, getSession(sessionId): SessionState | undefined, listSessions(): SessionState[], size(): number. Emite 'event' en cada añadidura.
• startServer(options?: StartServerOptions): Promise<RunningServer> -- arranca el almacén de eventos y el servidor HTTP/SSE. RunningServer es { server, store, config, url, close }.
• loadOrCreateConfig(): TaskSwarmConfig, saveConfig(config): void, rotateToken(): string, generateToken(): string, getTaskSwarmHome(): string

Notificaciones (src/notify/index.ts)

• shouldNotify(status, previousStatus, blockedReason?, previousBlockedReason?): boolean -- la regla de deduplicación. Clave en el par (status, blocked_reason), no solo en el estado, para que dos avisos de permiso diferentes seguidos notifiquen ambos.
• notify(event, previousStatus, previousBlockedReason, options?: NotifyOptions): void -- dispara los canales habilitados. La notificación local del sistema operativo siempre está activa; ntfy.sh solo se dispara cuando options.ntfy.enabled es verdadero.

Adaptadores (src/adapters/)

• interface AgentAdapter { agentType: AgentType; name: string; toEventInput(raw): AgentEventInput } -- el punto de plugin que implementa cada integración
• class GenericAdapter implements AgentAdapter -- la ruta de fallback del script envoltorio
• class ClaudeCodeAdapter implements AgentAdapter, installClaudeCodeHooks(options: InstallHooksOptions): InstallHooksResult -- la integración real de hooks de Claude Code

Incrustar el servidor directamente en lugar de ejecutar taskswarm start, verificado funcionando contra el paquete compilado:

import { startServer, EventStore } from 'taskswarm-cli';

const running = await startServer({ logPath: null }); // in-memory only, no JSONL log
console.log(running.url); // http://127.0.0.1:4173/?token=...
console.log(running.store instanceof EventStore); // true
await running.close();

Tipos exportados junto con cada función: AgentEvent, AgentEventInput, AgentType, AgentStatus, SessionState, TaskSwarmConfig, NotifyOptions, RunningServer, StartServerOptions, HookInstallScope, InstallHooksOptions, InstallHooksResult.

La distribución de Python refleja la misma superficie (snake_case en lugar de camelCase, py.typed para verificadores de tipos), también verificada funcionando contra el paquete compilado:

from taskswarm import start_server, EventStore, TaskSwarmConfig

cfg = TaskSwarmConfig(token="local-dev", port=4175, host="127.0.0.1", ntfy={"enabled": False})
running = start_server(config=cfg, log_path=None)  # in-memory only, no JSONL log
print(running.url)  # http://127.0.0.1:4175/?token=local-dev
running.close()

Servidor MCP

La distribución Python de TaskSwarm incluye un servidor Model Context Protocol, de modo que un agente compatible con MCP (Claude Desktop, Claude Code, un orquestador) puede llamar a TaskSwarm directamente como herramienta en lugar de invocar la CLI y analizar texto.

pip install "taskswarm-cli[mcp]"

Expone una única herramienta, run, un envoltorio genérico de subprocesos: pásale la misma lista de argumentos que usarías en la línea de comandos, y ejecutará el binario taskswarm instalado, analizará el JSON resultante y lo devolverá. Cada modo de fallo (binario ausente, error de lanzamiento, tiempo de espera agotado, salida distinta de cero, salida no analizable) regresa como un dict {"error": ...} simple en lugar de lanzar una excepción, de modo que una llamada incorrecta no puede bloquear el servidor.

run(args=["task", "list", "--json"])
# -> {"result": [{"id": "84c94aca-...", "title": "Fix flaky test", "repo": "/tmp/x", "created_at": "2026-08-09T17:37:00.949Z", "status": "unknown"}]}

Para registrarlo con un cliente compatible con MCP, como Claude Desktop, agrégalo a la configuración de servidores del cliente:

{
  "mcpServers": {
    "taskswarm": {
      "command": "taskswarm-mcp"
    }
  }
}

Esto asume que taskswarm-mcp ya está en PATH (instalado mediante el extra mcp anterior). Si lo instalaste en otro lugar, reemplaza "command" con la ruta completa al script de consola. Este servidor es actualmente solo para Python; la distribución npm aún no incluye un servidor MCP.

Cómo se compara

Verificado en vivo contra los metadatos de la API de GitHub y el README de cada proyecto, 2026-08-03. Las cifras de TaskSwarm se miden, no se estiman. Metodología debajo de la tabla.

	TaskSwarm	paperclip	Vibe Kanban	Multica
Estrellas	pre-lanzamiento	75,547	27,656	43,690
Licencia	MIT	MIT	Apache-2.0	Código disponible (Apache-2.0 modificado; restringe uso comercial alojado)
Estado de mantenimiento	activo	activo (confirmaciones hoy)	en retirada: la empresa cerró, el README lleva un aviso de cierre, última confirmación 2026-04-24, más de 3 meses sin actividad al momento de escribir esto	activo (confirmaciones hoy)
Notificación push/escritorio al cambiar de estado	sí: notificación local del SO por defecto, ntfy.sh opcional	no encontrado en el README	no encontrado en el README	no encontrado en el README
Interfaz principal	tabla de estado en vivo (SSE)	tablero Kanban completo + organigrama	tablero Kanban completo	tablero Kanban completo
Autohospedado, sin cuenta	sí	sí	sí (guía de autohospedaje, Docker)	sí (Docker)
Huella de memoria en reposo	~39 MB (medido)	no medido (fuera de alcance)	no medido (fuera de alcance)	no medido (fuera de alcance)
Arranque en frío (inicio del servidor hasta accesible)	~0.19 s (medido)	no medido	no medido	no medido

TaskSwarm no intenta superar a ninguno de estos tres en tableros. paperclip y Multica están diseñados para gestionar una lista completa de agentes como un organigrama, y Vibe Kanban (mientras existió) era un espacio completo de planificación y revisión. TaskSwarm se mantiene enfocado: lo único que ninguno de los tres ofrece es una señal push cuando una sesión te necesita, y ese es todo el producto aquí.

Metodología de referencia (para que puedas reproducirla): medida en macOS 26.5.1, Apple Silicon (arm64), Node v24.4.0, npm 11.15.0, 2026-07-15.

• Arranque en frío: desde el lanzamiento del proceso hasta que curl recibe HTTP 200 desde la URL de la página de estado en vivo, cronometrado con time.perf_counter(), promediado en ejecuciones repetidas (158 a 188 ms observados).
• Memoria en reposo: ps -o rss en el proceso node dist/cli.js start en ejecución, unos segundos después del arranque sin sesiones activas (38.4 a 39.4 MB observados entre ejecuciones).
• Latencia de ingesta de eventos a despacho de notificación: tiempo de pared para que una solicitud POST /events devuelva 201, en 20 solicitudes con status: blocked (la ruta de código que llama sincrónicamente a notify(), que genera el proceso de notificación del SO, antes de enviar la respuesta HTTP). Mediana 3.1 ms, media 5.8 ms, p95 24.1 ms, n=20.
• Tiempo total hasta el primer tablero (un usuario real por primera vez, git clone nuevo): npm install (2.05 s) más npm run build (0.78 s) más start hasta que la página en vivo es accesible (0.15 s), totalizando 2.99 s, en una máquina con caché npm local cálida. El objetivo era menos de 60 segundos; el resultado medido real es aproximadamente 20 veces menor.

Los números no listados para las otras tres herramientas no son marcadores estimados. Simplemente no se midieron, porque ejecutar sus pilas completas (Rust, PostgreSQL, Docker Compose) no estaba en el alcance de esta pasada. Sus conteos de estrellas, términos de licencia y estado de mantenimiento anteriores son hechos verificados en vivo, no referencias.

Dónde se sitúa TaskSwarm en el panorama más amplio de 2026

paperclip, Vibe Kanban y Multica son los comparables de tablero completo más cercanos, pero no son el panorama completo. Ejecutar varios agentes de codificación en paralelo se convirtió en uno de los rincones más activos del código abierto en 2026: el propio Informe de Tendencias de Codificación Agéntica 2026 de Anthropic nombra la coordinación multiagente como una de las ocho tendencias que remodelan cómo se construye software, y OpenAI informó que solo Codex superó los 5 millones de usuarios semanales para junio de 2026. Toda una ola de interfaces de orquestación llegó junto con ese crecimiento. Aquí es donde TaskSwarm se sitúa junto a las herramientas más nuevas de agentes paralelos que cubren un flujo de trabajo similar con una forma diferente, verificado en vivo el 2026-08-03:

Herramienta	Estrellas	Licencia	Qué es realmente
TaskSwarm	pre-lanzamiento	MIT	Servidor de eventos solo de notificación; sin interfaz que debas mantener abierta
Claude Squad	8,231	AGPL-3.0	Gestor de terminal basado en tmux para sesiones de agentes paralelos, sin función de notificación encontrada en su README
Superset	12,763	Licencia Elastic 2.0 (código disponible)	Editor de código completo construido alrededor de agentes paralelos; "recibe notificaciones cuando necesitan atención" según su propio README
Nimbalyst	1,394	MIT	Espacio de trabajo visual de escritorio con una aplicación móvil complementaria que envía notificaciones; sincroniza mediante un servidor de colaboración alojado
Paneflow	48	GPL-3.0	Espacio de paneles nativo en Rust con una cola de atención y notificaciones de escritorio
Conductor (Melty Labs)	código cerrado, sin repositorio público	propietario	Panel de worktrees solo para macOS; no instalable desde npm o PyPI

Cada una de estas te da un lugar para observar a tus agentes trabajar. TaskSwarm se basa en la suposición opuesta: no estás mirando, por eso te empuja la información. Adyacente a esto, el protocolo estandarizado de integración de agentes MCP creció hasta convertirse en su propia categoría principal durante el mismo período, más de 10,000 servidores MCP públicos activos y más de 97 millones de descargas mensuales de SDK según la actualización del ecosistema de Anthropic de diciembre de 2025 — el mismo cambio subyacente hacia agentes que se conectan a puntos de integración estándar, que es la misma razón por la que el adaptador de script envoltorio de TaskSwarm (taskswarm agent report-status) es deliberadamente agnóstico al protocolo en lugar de estar atado al formato de enganche de un solo agente.

Qué es TaskSwarm y por qué existe

Ejecutar un agente de codificación es una conversación. Ejecutar tres o cuatro en paralelo se convierte en un problema de cambio de pestañas: nada te empuja el estado, así que terminas revisando terminales a simple vista solo para descubrir que uno lleva diez minutos esperando un aviso de permiso. TaskSwarm existe para cerrar esa brecha: una señal push para el momento en que una sesión realmente necesita a un humano.

El núcleo (servidor de eventos, CLI, página de estado en vivo, integración de enganche de Claude Code) tiene licencia MIT y es gratuito para autohospedar, para uso individual, para un equipo, para lo que sea. No hay nivel alojado ni nivel de pago actualmente. El núcleo autohospedado es todo el producto en este momento.

Preguntas frecuentes

¿Esto reemplaza mi tablero Kanban / Linear / GitHub Projects? No. Esos rastrean elementos de trabajo que un humano planifica. TaskSwarm rastrea el estado en vivo de las sesiones de agentes y te avisa al instante cuando cambia. Trabajo diferente.

¿Necesito Claude Code específicamente? No. taskswarm hooks install claude-code es la única integración nativa verificada que se envía actualmente. Codex, Cursor o cualquier otra cosa funciona a través de la misma primitiva que ese adaptador llama internamente: taskswarm agent report-status, invocable desde cualquier script envoltorio alrededor de cualquier agente CLI.

¿A dónde van mis datos? A ningún lado, por defecto. El servidor se vincula a 127.0.0.1, requiere un token de portador para cada solicitud y escribe el estado en ~/.taskswarm/ (o donde apunte TASKSWARM_HOME) en tu propio disco. El único canal opcional que sale de tu máquina es ntfy.sh, y está desactivado a menos que lo habilites explícitamente.

¿Esto empezará a cobrarme más adelante? El núcleo con licencia MIT sigue siendo gratuito. Todo lo descrito en este README es el producto completo tal como existe hoy, no una prueba ni un nivel limitado de algo más grande. ¿Por qué no usar simplemente tmux y observar los paneles? Ese es el statu quo al que este proyecto responde. Funciona hasta que ejecutas más de dos o tres sesiones a la vez, momento en el que pasas más tiempo consultando paneles que escribiendo código.

¿Qué sucede si el servidor no está en ejecución cuando llamo a un comando? Los comandos que lo necesitan fallan rápidamente con un mensaje específico (could not reach TaskSwarm server at http://127.0.0.1:4173 -- is it running? (taskswarm start)), no con un stack trace. task add y task list siguen funcionando sin el servidor; simplemente omiten el enriquecimiento de estado en vivo.

¿Qué es TaskSwarm, exactamente? Un servidor de eventos autoalojado más una CLI. Las sesiones de agentes, o un script envoltorio alrededor de cualquier agente, reportan estado a él (taskswarm agent report-status), y este envía una notificación local del sistema operativo y actualiza una página de estado SSE en vivo en el instante en que una sesión pasa a blocked, needs-review, failed o done. No lanza, programa ni ejecuta agentes por sí mismo; solo rastrea y envía el estado de sesiones que ya se están ejecutando en otro lugar.

¿Puedo usar TaskSwarm como biblioteca en lugar de la CLI? Sí. Ambas distribuciones exportan una superficie programática real, no solo un punto de entrada bin: import { startServer, EventStore } from 'taskswarm-cli' en npm, from taskswarm import start_server, EventStore en PyPI. Consulta la Referencia de la API de biblioteca más arriba para ver la lista completa de exportaciones y un ejemplo funcional de cada una.

¿Cuáles son los requisitos de plataforma e instalación? La compilación de npm (taskswarm-cli) necesita Node.js >=18.18.0, según el campo engines en package.json. La compilación de PyPI (también taskswarm-cli) necesita Python >=3.9, según pyproject.toml, que también declara Operating System :: OS Independent. Una advertencia que en la práctica es específica de plataforma: la notificación nativa del sistema operativo solo se activa en macOS, mediante osascript (ver src/notify/os-notify.ts). En Linux y Windows, TaskSwarm recurre a una línea de consola más una campanilla de terminal en lugar de una notificación del sistema; sigue siendo local, y sin ntfy.sh a menos que optes por ello.

¿Cómo se compara TaskSwarm con un competidor específico, como Vibe Kanban o paperclip? Consulta las tablas comparativas más arriba para el desglose completo, pero la versión breve: paperclip y Multica están diseñados para ejecutar y visualizar un conjunto completo de agentes como un organigrama, y Vibe Kanban era un espacio de trabajo completo de planificación y revisión antes de que la empresa detrás de él cerrara (su README lleva un aviso de cierre al momento de escribir esto). Ninguno de los tres lista una función de notificación push/de escritorio en su propio README. TaskSwarm omite el tablero por completo y solo hace una cosa: enviar una señal en el instante en que una sesión te necesita.

¿Puedo usar TaskSwarm en un producto comercial o de pago? Sí. El núcleo (servidor de eventos, CLI, página de estado en vivo, integración de hook de Claude Code) tiene licencia MIT sin restricción de campo de uso, por lo que autoalojarlo dentro de un producto comercial, un servicio de pago o una herramienta interna está bien. Ese es un punto de diferencia real con Multica en la tabla comparativa anterior, que se distribuye bajo una licencia Apache-2.0 modificada que restringe explícitamente el uso comercial alojado.

Contribuciones

Las incidencias y las solicitudes de extracción son bienvenidas. Antes de abrir una PR:

npm run lint
npm run typecheck
npm run test:coverage

Las tres deben pasar limpias. Para la distribución de Python, cd python && pip install -e ".[dev]" && pytest. Consulta CONTRIBUTING.md para la lista de verificación completa que cubre ambos códigos base.

Licencia

MIT. Consulta LICENSE. Libre de autoalojar, modificar y redistribuir, individualmente o como equipo. No existe un nivel alojado o de pago en esta versión.