Sparda

SPARDA

🇫🇷 Français — L'IA écrit. SPARDA prouve. Un gate déterministe et hors-ligne qui détecte quand une modif d'IA retire une garde, expose une route ou casse un invariant — sans clé API, directement dans la boucle d'édition de l'agent. Pour tout comprendre en 10 minutes (douleur, architecture, vision) : SPARDA-EXPLIQUE.md.

---

La IA escribe. SPARDA demuestra.

La IA escribe. SPARDA demuestra.

La capa de confianza para backends escritos por IA. SPARDA compila tu backend — rutas, consultas de base de datos, mutaciones de estado, guardas, efectos secundarios — en un único grafo de comportamiento determinista, y luego demuestra estáticamente qué puede y qué no puede romperse antes de que despliegues: ninguna mutación sin guarda, ningún invariante roto, ninguna escritura agregada no atómica.

100% local · determinista · cero claves API · sin cuenta en la nube. Falla de forma ruidosa ante un riesgo real, y cuando solo puede ver parte de tu aplicación dice PROVEN (PARTIAL) — nunca un verde falso. Y cuando puede demostrar que ni siquiera estaba mirando toda tu aplicación, dice PREMISE NOT VERIFIED y no afirma nada en absoluto.

Demostración en 60 segundos

Desde tu aplicación Express, FastAPI, Flask, Next.js, NestJS o Medusa — sin nada que configurar:

npx sparda-mcp apocalypse   # prove the tree is safe to deploy — exit 1 on any real risk, or on an unverified premise
npx sparda-mcp prove        # the whole verdict: proof + coverage + shareable seal
npx sparda-mcp badge        # a README badge: proven · coverage% · routes

Bajo el capó, compila tu backend en un único grafo independiente del lenguaje — el Unified Behavior Graph (UBG), serializado como .sparda/ubg.json bajo la especificación SBIR (SPARDA Behavior IR) — y cada comando es una pasada sobre ese grafo.

La cuña — detecta una edición de IA que elimina una guarda, en el bucle

Lo único que una revisión de diff de texto y un escáner de patrones estructuralmente no pueden hacer: demostrar que esta edición específica eliminó una protección que la versión anterior tenía. sparda gate compara el grafo de comportamiento antes/después de una edición y bloquea una regresión — determinista, offline, en menos de un segundo, salida 2 (el contrato PostToolUse de Claude Code que detiene el bucle de edición del agente). Véalo de extremo a extremo en un solo comando, sin configuración:

npm run wedge     # (from a clone)  — or drive it on your own app with `sparda gate --arm` then `sparda gate --hook`

  1. baseline armed on the guarded code   (POST /admin/delete-user · requireAdmin)
  2. an AI edit "simplifies" requireAdmin → a pass-through (still compiles, still 200s)
  3. sparda gate on the edit:
       ✗ [critical] GUARD_REMOVED — POST /admin/delete-user was guarded in the baseline
                    and is now reachable without any guard (src/app.js:11)
     ⏱  ~40 ms · deterministic · offline · no API key
     ⛔ exit 2 on --hook — Claude Code PostToolUse blocks the edit

Conéctalo a Claude Code en una línea — el plugin registra un hook PostToolUse que ejecuta npx -y sparda-mcp gate --hook después de cada Edit/Write, de modo que una edición que elimine una guarda se detecta antes de que se aplique.

[!IMPORTANT]
La Prueba de Compilación de Rutas — reprodúcela tú mismo. SPARDA compila monstruos reales de código abierto a su grafo de comportamiento con cero fallos, cada uno en ≈1–2 segundos: Next.js Dub (579 rutas), NestJS Immich (281), MedusaJS (477). Resuelve de forma nativa inyección de dependencias profunda, controladores externos y manejadores de Next.js. Un comando los clona y los vuelve a medir en tu máquina:

node bench/repro.mjs        # → bench/route-proof.json

Honestidad primero: compilar una ruta es un resultado del parser (el número anterior); demostrar que es segura es un veredicto separado por repositorio — y la mayoría de las aplicaciones reales devuelven NOT_PROVEN, que es el estado real, no un fallo. (Nuestro corpus completo de 25 repositorios compila bajo estrés 3,565 rutas a ~150 rutas/s; eso requiere que el corpus esté descargado.)

Lo que el grafo desbloquea — 100% local, determinista, 4 dependencias fijadas exactamente, cero claves API:

Comando	Qué hace
prove	El veredicto de confianza completo en un solo gesto — prueba + cobertura + verificación de premisa + un sello compartible (--json / --markdown)
apocalypse	Demuestra el despliegue — ninguna guarda, invariante, transacción o límite de agregado puede romperse (SARIF + puerta de CI)
heal	Autocuración, demostrada — la puerta que Copilot Autofix no tiene: una corrección se envía solo si la reproducción coincide, verify sigue pasando, y apocalypse no encuentra ningún riesgo nuevo / ninguna guarda eliminada. Quienquiera que haya escrito la corrección, la máquina la juzga.
badge	El artefacto compartible — una insignia SVG autocontenida + fragmento de README (veredicto · cobertura · rutas)
dossier	El informe público — una página HTML autocontenida: veredicto, riesgos y los propios puntos ciegos de SPARDA
ubg	Compila el código base a su grafo de comportamiento (Express · FastAPI · Flask · Next.js · NestJS · Medusa de forma nativa; cualquier stack vía OpenAPI)
timeless	Viaje en el tiempo — registra una solicitud de producción, reprodúcela byte a byte idéntica, exporta el error como prueba
mirror	Ejecuta el grafo — sirve el comportamiento compilado sobre HTTP sin framework y sin código fuente
init / dev	Runtime, opcional — expone el grafo a clientes de IA como un servidor MCP en vivo (+ Twin, Immune, Evolution)

El demostrador es el producto. El servidor MCP es una salida del grafo, no el punto — SPARDA compila el comportamiento de todo el sistema, luego demuestra, reproduce, cura y (opcionalmente) lo sirve.

Nomenclatura: SBIR es la especificación (el formato, como "JSON"); UBG es el grafo compilado en sí (el artefacto, ubg.json). El servidor MCP es una salida del grafo, no el producto.

Opcional: expón el grafo a clientes de IA (runtime MCP)

Más allá de demostrar, SPARDA puede convertir tu aplicación en ejecución en un servidor MCP en vivo — el grafo, ejecutable, con seguridad de escritura y una capa inmune. Esto es opcional y separado del demostrador anterior.

1. Escanea + inyecta — ejecuta una vez, desde el directorio de tu aplicación:

   npx sparda-mcp init
   

   SPARDA analiza tus rutas (AST), genera un router /mcp marcado, lo inyecta en tu aplicación (con una copia de seguridad) y escribe sparda.json. Cada paso es reversible.

2. Inicia tu aplicación, luego inicia el puente:

   npx sparda-mcp dev
   

3. Conecta tu cliente. init imprime un bloque listo para pegar para claude_desktop_config.json, prellenado con el nombre y la ruta de tu aplicación:

   {
     "mcpServers": {
       "your-app": {
         "command": "npx",
         "args": ["sparda-mcp", "dev"],
         "cwd": "/absolute/path/to/your-app"
       }
     }
   }
   

   Claude Code se conecta al mismo puente. Eso es todo — tu aplicación en ejecución ahora es un conjunto de herramientas MCP que tu IA puede llamar.

Prueba la Demo Independiente

Para ver SPARDA en acción al instante sin modificar tu código base:

npx sparda-mcp demo

Esto ejecuta todo el ciclo de vida de MCP (detectar → analizar → generar → inyectar → eliminar) en una aplicación de demostración incluida en una carpeta temporal, en unos 10 segundos. Para el compilador en sí, ejecuta npx sparda-mcp ubg y luego apocalypse en cualquier aplicación Express/FastAPI.

Informe de Caja Negra

SPARDA está diseñado como un organismo local. Para ver qué recuerda y cuánto cómputo ha reciclado:

npx sparda-mcp report

Esto imprime un panel de terminal que agrega tus herramientas expuestas, opt-ins de escritura, decisiones del diario de demostración y herramientas compuestas cristalizadas.

Para escribir un panel HTML autocontenido y offline en .sparda/report.html, añade la bandera --html:

npx sparda-mcp report --html

Para generar JSON crudo para integración:

npx sparda-mcp report --json

Prueba de Despliegue: Apocalypse

El Grafo de Comportamiento de SPARDA es un modelo formal de tu sistema. En lugar de esperar fallos en tiempo de ejecución o depender de vibraciones de análisis estático, puedes demostrar estáticamente la seguridad de tu backend antes de cualquier despliegue:

npx sparda-mcp apocalypse

Este comando lee el .sparda/ubg.json compilado (con cero análisis de código fuente en tiempo de ejecución) y resuelve cinco obligaciones estáticas de corrección:

• Mutación sin Guarda (Crítico): Señala cualquier ruta de mutación que no cruce un guard de seguridad.
• Escritura Agregada No Atómica (Alto): Señala cuando una API escribe en múltiples tablas del mismo Dominio de Consistencia (Agregado) fuera de un único ámbito de transacción.
• Escritura Restringida No Validada (Medio): Señala escrituras en columnas con invariantes declarados (CHECK, NOT NULL, UNIQUE — analizados desde tu DDL de .sql o schema.prisma, incluidos los enums de Prisma) sin validación previa (Zod/Pydantic).
• Efecto Observable Irreversible (Alto): Señala acciones fuera de proceso (como cargos de Stripe) que ocurren junto con escrituras de estado sin una ruta de compensación estructural (como un catch-reembolso).
• Omisión de Miembro de Agregado (Info): Señala la mutación directa de una tabla miembro sin pasar por la raíz del agregado.

Para guardar tu grafo actual como una línea base segura:

npx sparda-mcp apocalypse --save-baseline

Las ejecuciones posteriores compararán el grafo candidato contra esta línea base para detectar vectores de regresión:

• Eliminación de cualquier guard de seguridad (Crítico).
• Eliminación de un invariante SQL de base de datos (Alto).
• Expansión del radio de impacto de la API (Medio).

Si se encuentra cualquier hallazgo Crítico o Alto, apocalypse sale con un código no cero para bloquear tu pipeline de CI.

Un paso en tu flujo de trabajo — los hallazgos llegan a la pestaña de Seguridad de GitHub (SARIF):

- uses: zakariagharzouli/sparda@main
  with:
    sarif: 'true'

Viaje en el Tiempo: Timeless

Cada solicitud de producción es determinista entre sus efectos — el compilador sabe exactamente dónde vive la no determinismo (db, http, reloj, aleatorio, uuid: los nodos de efecto del grafo). Timeless registra solo esos puntos (unos pocos KB por solicitud) y reproduce la solicitud byte a byte idéntica contra tu código actual, con la base de datos, los webhooks y el reloj virtualizados desde la grabación:

npx sparda-mcp timeless                # list recorded flights
npx sparda-mcp timeless replay <id>    # re-fly it — byte-identical or loud divergence
npx sparda-mcp timeless export <id>    # the production bug is now a vitest test

La grabación son dos líneas en tu aplicación (ESM), con muestreo determinista y redacción GDPR integrados:

import { getFlightBox } from 'sparda-mcp/src/flight/box.js';
const box = getFlightBox(); box.arm();
app.use(box.middleware({ sample: 100 }));   // 1 request in 100; passwords/tokens redacted by default
const db = box.wrapClient(pgPool);           // your query client, tapped

El bucle cerrado que nadie más tiene: error de producción → vuelo grabado → prueba fallida → la IA escribe la corrección → apocalypse demuestra que la corrección no rompe ninguna guarda, invariante o transacción → despliegue. La reproducción es por solicitud (la captura de carreras concurrentes está fuera del alcance de v1 — declarado, no oculto).

Autocuración, Demostrada: sparda heal

El bucle anterior, como un solo gesto — y la máquina juzga la corrección, quienquiera que la haya escrito:

npx sparda-mcp heal <flightId>                       # diagnose + write the fix brief
# ...apply the fix (a human, or --agent "your-ai-cli")...
npx sparda-mcp heal <flightId> --check --expect '{"status":404}'

El brief se construye desde el propio grafo — le entrega al corrector el file:line del manejador, las capacidades que la corrección no debe aumentar y las guardas que no debe eliminar. Luego la puerta — el producto real — demuestra la corrección en tres ejes a la vez:

1. Comportamiento — la reproducción indulgente del vuelo grabado (mismos insumos deterministas) ahora produce la respuesta esperada, no el error grabado. La corrección puede reformular una consulta (la toma se reetiqueta, se permite); no puede cambiar el orden o los tipos de efectos.
2. Leyes del compilador — verify sigue pasando: el grafo sigue siendo sólido y determinista.
3. Sin regresión — diff de apocalypse contra el grafo previo a la corrección congelado: cero hallazgos nuevos críticos/altos, ninguna guarda eliminada, ningún radio de impacto aumentado.

✓ HEALED & PROVEN — same recorded inputs, correct output, zero law broken, zero protection lost. Ship it.

La puerta es honesta en ambas direcciones: un error sin corregir, o una "corrección" que silenciosamente elimina una protección, la mantiene cerrada (código de salida 1). Esta es la diferencia entre una IA que escribe código plausible y un sistema que prueba que el código es correcto — la capa de confianza que le falta a la era de los agentes.

Cualquier Backend en la Tierra: Reducción a OpenAPI

SPARDA analiza Express, FastAPI y Next.js de forma nativa — y cualquier otro stack mediante el formato que la industria ya acordó. Go, Java, Rails, Laravel, .NET: si tiene una especificación OpenAPI, se compila.

npx sparda-mcp ubg --openapi openapi.json

Los esquemas de seguridad se convierten en nodos de compuerta guard, los esquemas de respuesta se convierten en retornos tipados, los cuerpos de solicitud declarados cuentan como entrada validada. Combina la especificación con tus archivos .sql o schema.prisma y la capa de estado completa — invariantes, agregados, máquinas de estado — se completa a partir de la verdad declarada. (Especificaciones JSON en v1; nos negamos a analizar YAML a medias con cero dependencias).

La VM Espejo: elimina el framework, la aplicación sigue respondiendo

El grafo no es un diagrama — se ejecuta:

npx sparda-mcp mirror

MIRROR — the graph is serving. 3 entrypoint(s) on http://127.0.0.1:4477
  GET    /orders/{orderId}  → {amount, id, status}
  POST   /orders  🔒 bearerAuth  → {amount, id, status}

Sin Express. Sin FastAPI. Sin código fuente — solo ubg.json respondiendo HTTP: las protecciones realmente deniegan (401), las respuestas renderizan los esquemas de retorno compilados, las rutas desconocidas devuelven 404 con la tabla de rutas completa. Los equipos de frontend desarrollan contra backends que aún no están desplegados — o que aún no están escritos (apunta mirror a una especificación OpenAPI). Cada respuesta lleva x-sparda-mirror: true; el espejo sirve comportamiento declarado, nunca inventa valores de negocio.

Para deshacer todo: npx sparda-mcp remove restaura tu código byte por byte.

La promesa — cada palabra está respaldada por una prueba en CI

1. Tres minutos, un comando. Escaneo AST, generación de enrutador, inyección reversible — sin configuración.
2. Pruébalo gratis, vete gratis. npx sparda-mcp remove restaura tu código byte por byte (probado en JS, TS, Python, incluso archivos CRLF de Windows). Sin rastro, sin bloqueo.
3. La IA no puede escribir hasta que tú lo digas. Cada POST/PUT/DELETE está deshabilitado por defecto; los habilitas por herramienta, y tu elección sobrevive a cada re-ejecución.
4. Tu aplicación se defiende sola. Una ruta que falla 3 veces seguidas es puesta en cuarentena — la IA no puede golpear tu producción rota. Las anomalías de latencia se marcan. No se necesita LLM.
5. Nada sale de tu máquina. Sin telemetría hacia nosotros, sin nube, autenticación local por clave, 4 dependencias con versión exacta fijada.
6. Lo que aprende nunca se pierde. Diagnósticos, descripciones, configuraciones — versionados con tu git, sobreviviendo a cada re-inicialización.

Lo que no prometemos: los límites honestos en docs/SECURITY.md.

Cómo funciona

1. npx sparda-mcp init analiza tu código (AST), extrae cada ruta e inyecta un pequeño enrutador marcado (/mcp) en tu aplicación — totalmente reversible con npx sparda-mcp remove.
2. Las llamadas a herramientas se ejecutan dentro de tu proceso de aplicación en vivo — pools de BD cálidos, cadena de autenticación real, datos reales. SPARDA no añade infraestructura: el cómputo proviene de tu proceso anfitrión, la inteligencia del modelo propio de tu cliente de IA (muestreo MCP), el almacenamiento de sparda.json + git.
3. Las herramientas de escritura (POST/PUT/DELETE) están deshabilitadas por defecto. Optas por cada herramienta en sparda.json — tus elecciones sobreviven a re-ejecuciones.
4. Los docstrings sospechosos se sanitizan antes de llegar a la IA (defensa contra inyección de prompts).
5. npx sparda-mcp doctor --app audita tu código en busca de desviaciones: detecta herramientas obsoletas (IA viendo fantasmas), rutas no sincronizadas, desviación de esquemas mediante huellas digitales y configuraciones zombi. Los problemas de alta gravedad generan un código de salida distinto de cero para tu pipeline de CI.
6. npx sparda-mcp seed export/import te permite empaquetar y compartir el "genoma" de tu aplicación (memoria semántica, flujos de trabajo, anticuerpos) de forma segura, transfiriendo memoria inmune entre entornos o entre stacks similares con cero fuga de datos.
7. npx sparda-mcp twin inicia un servidor simulado seguro de tu backend en el puerto original. Sirve llamadas GET a partir de ejemplares aprendidos (formas de respuesta observadas y datos simulados) y devuelve escrituras 202 simuladas sin tocar nunca tu base de datos real o tus APIs de producción. Aprende ejemplares ejecutando npx sparda-mcp twin --learn.
8. npx sparda-mcp grammar mapea el grafo de secuencias válidas de llamadas a herramientas (circuitos observados e hipótesis candidatas) para prevenir la alucinación de rutas por parte del LLM.
9. npx sparda-mcp evolve muta cadenas candidatas y las prueba contra el gemelo en memoria, promoviendo cadenas exitosas a sugerencias de flujos de trabajo evolucionados.

Lo que SPARDA le da a tu IA

Operar, no solo leer

Cada ruta se convierte en una herramienta que se ejecuta contra tu proceso en vivo — autenticación real, datos reales, conexiones cálidas. Una llamada a sparda_get_context le entrega a la IA toda la imagen viva: herramientas habilitadas, flujos de trabajo sugeridos, telemetría en tiempo de ejecución, estado de cuarentena y memoria inmune — para que cada sesión se reanude donde terminó la anterior.

Seguridad de escritura: la IA no puede escribir hasta que tú lo digas

• Las escrituras (POST/PUT/DELETE) se entregan deshabilitadas. Habilítalas por herramienta en sparda.json; tu elección sobrevive a cada re-inicialización.
• Una escritura habilitada nunca se ejecuta en la primera llamada. SPARDA devuelve un sobre awaiting_confirmation — un token de un solo uso más una vista previa de la acción — y confirma solo después de un paso de confirmación explícito.
• Cuando tu cliente soporta elicitación MCP, esa solicitud de confirmación aparece en la propia interfaz de la IA.
• Prueba después de escribir: cada escritura exitosa va seguida de una relectura del mismo recurso, para que la IA — y tú — vean el efecto real, no una suposición esperanzadora.

Tu aplicación se defiende sola — cero LLM en la ruta crítica

• Cuarentena. Una herramienta que devuelve 3 errores 5xx consecutivos es puesta en cuarentena: las llamadas posteriores reciben un 503 con una razón y un retraso de reintento en lugar de golpear tu ruta rota. Después de un período de enfriamiento, se abre a medias para una sola sonda.
• Marcas de latencia y anomalías. El enrutador aprende la línea base de cada ruta y marca desviaciones localmente, en unas pocas líneas de matemáticas.
• Diagnóstico adaptativo, solo ante sorpresas. Un fallo genuinamente nuevo despierta el modelo propio de tu cliente de IA para diagnosticarlo una vez; el diagnóstico se almacena en caché como un "anticuerpo" en sparda.json, de modo que el mismo fallo posterior cuesta cero tokens. Clonar tu código no clona su memoria inmune.

Una capa de inteligencia gratuita, cero clave API

En la primera conexión, el modelo propio de tu cliente de IA (mediante muestreo MCP) reescribe las rutas crudas en descripciones de herramientas en lenguaje de negocio y propone flujos de trabajo de varios pasos — almacenados en caché en sparda.json y expuestos como prompts MCP. Nada que configurar, nada que pagar.

Se vuelve más barato cuanto más lo usas

• Reciclaje de respuestas. Cuando una lectura devuelve la misma respuesta repetidamente, SPARDA sirve la siguiente llamada idéntica directamente desde la memoria — sin tocar tu aplicación anfitriona. Solo lecturas; las escrituras siempre llegan al anfitrión.
• Un indicador de reciclaje. GET /mcp/stats cuenta cuántas llamadas fueron respondidas desde el conocimiento propio de SPARDA frente a cuántas pagaron la ruta del anfitrión. Muestra 0% el primer día y se llena con el uso — una medida, nunca una promesa.

Herramientas que nadie escribió — Labs, opcional, DESACTIVADO por defecto

Actívalo con "labs": { "recordSequences": true } en sparda.json. SPARDA entonces nota cuando la salida de una herramienta alimenta la entrada de la siguiente y registra el circuito — solo estructura (nombres de herramientas, nombres de argumentos, conteos), nunca tus datos. Un circuito de solo lectura visto suficientes veces se cristaliza en una herramienta compuesta, anunciada a mitad de sesión: una llamada ejecuta toda la cadena, alimentando automáticamente cada paso desde la respuesta real del paso anterior. Las rutas de escritura nunca se absorben — su confirmación por llamada siempre se mantiene.

Contexto vivo y telemetría

GET /mcp/stats (llamadas/errores por herramienta, "pureza" de la herramienta, estado de cuarentena) y GET /mcp/events (errores, anomalías de latencia, diagnósticos en caché) exponen exactamente lo que tu aplicación está haciendo — presentado a la IA como notificaciones en vivo.

Diseñado para clientes de IA: la Skill incluida

SPARDA incluye una Skill de Agente (SKILL.md) que enseña a cualquier cliente de IA compatible cómo manejar un servidor SPARDA a su máximo potencial — llama a sparda_get_context primero, aprovecha el reciclaje de respuestas, respeta la cuarentena, prefiere circuitos cristalizados sobre re-recorrer una cadena, y sigue el protocolo de dos fases de escritura-confirmación. La lista de herramientas en vivo y por proyecto siempre proviene de sparda_get_context en tiempo de ejecución, por lo que la guía nunca queda obsoleta.

Frameworks soportados

• Next.js App Router (13/14/15) — inyección basada en archivos. SPARDA crea un manejador de ruta catch-all. Resuelve de forma nativa manejadores envueltos (export const POST = withAuth(h)) y cadenas de efectos profundas.
• NestJS — inyección de enrutador basada en AST. Resuelve profundamente la Inyección de Dependencias de múltiples saltos (Controlador → Servicio → Repositorio), DI heredada e imports de baseUrl/paths. Soporta Prisma, TypeORM y Kysely.
• Express 4/5 (JS/TS, ESM/CJS) — inyección de enrutador basada en AST. Resuelve profundamente controladores externos, esquemas Mongoose y re-exportaciones de barril. Usa escaneo dinámico de árbol para encontrar puntos de entrada no estándar (bootstrap.ts, etc.).
• MedusaJS — ingesta AST nativa de enrutamiento complejo de comercio electrónico.
• Cualquier Backend en la Tierra (Go, Java, Rails, Laravel) — compila perfectamente desde especificaciones OpenAPI 3.x.
• FastAPI (Python >= 3.9) — inyección de enrutador basada en AST.

Postura de seguridad (honesta)

• 4 dependencias en tiempo de ejecución, con versión exacta fijada.
• Resolución dinámica de clave local. El enrutador generado no contiene secretos incrustados. Resuelve las claves de autorización en tiempo de ejecución desde la variable de entorno SPARDA_LOCAL_KEY o el archivo local ignorado por git .sparda/key, y falla cerrado (503) cuando no se encuentra ninguno. Para configuraciones personalizadas de producción o staging, puedes anular este comportamiento exponiendo SPARDA_LOCAL_KEY en tu entorno.
• Clave local en cada llamada al enrutador; protección contra bucles de auto-referencia; tiempos de espera de 30s; truncamiento de salida de 8 KB.
• Inyección posicionada por AST con respaldo y re-análisis posterior a la inyección; npx sparda-mcp remove deja un diff de git limpio.
• La persistencia no contiene valores: SPARDA registra estructura (nombres de herramientas, nombres de campos, huellas digitales), nunca tus cargas útiles.

Modelo de amenazas completo y brechas conocidas: docs/SECURITY.md.

Documentación

• docs/ARCHITECTURE.md — cómo encajan init, el enrutador inyectado y el puente, además del esquema sparda.json.
• docs/SECURITY.md — modelo de amenazas, defensas y brechas conocidas honestas.
• docs/TESTING.md — cómo las promesas anteriores se mantienen honestas en CI.
• docs/ERRORS.md — la base de conocimiento de errores.

Más allá del núcleo abierto

SPARDA es gratuito, incluso en producción (ver Licencia). Capacidades a nivel de equipo — políticas de acceso granular por persona y un registro de auditoría firmado y a prueba de manipulaciones — están planificadas para un futuro nivel de pago. El núcleo abierto se sostiene por sí solo; nada aquí está limitado para venderte una actualización.

Licencia

Business Source License 1.1 — libre de usar, incluso en producción. No puedes revender SPARDA ni ofrecerlo como un servicio comercial competidor. Cada versión se convierte a Apache 2.0 cuatro años después de su publicación.

Por Residual Labs