Enigma

Token oficial $ENIGMA (Solana Mainnet):
Dirección del contrato (CA): EknDj8VZUHL6FhV9pSk3m6xP2U2sDzwjRDVstKeQpump
Solscan Explorer • Pump.fun • Sitio web oficial

Enigma Memory es un pasaporte de memoria de IA local-first. Te ofrece una única bóveda de memoria local canónica, prueba respaldada por recibos para eventos controlados por Enigma y conexiones MCP a asistentes como Claude Desktop, Cursor, Kimi Code y clientes MCP genéricos.

Empieza con el bucle de Memory Drive que aparece a continuación: una instalación, una conexión y luego verificación de salud y estado. No necesitas entender relay, gateway, mesh, navegador, escritorio, infraestructura alojada ni la red de prueba antes de probar Enigma localmente.

La operación en la nube alojada y BYOC es solo para lista de espera/despliegue por operador; requiere credenciales de despliegue reales, dominios, TLS, almacenamiento duradero, KMS/secretos, monitorización, copias de seguridad y aceptación del operador. Los binarios relay y gateway incluidos en el paquete son sondas de arranque locales, no un servicio alojado en vivo.

Enigma no afirma que un proveedor cerrado haya eliminado datos internos, que los pesos del modelo hayan olvidado o que la memoria nativa del proveedor haya desaparecido. Prueba hechos sobre el estado de la bóveda controlada por Enigma, los recibos, los puntos de control y las operaciones de límite declaradas.

Instala una vez, úsalo en todas partes

Prerrequisitos:

• Node.js >=24

• No se necesita base de datos, cuenta de registro de paquetes, credencial de proveedor, credencial de nube, cuenta de Enigma alojado ni cuenta externa para la ruta de configuración local

• Git solo si eliges la ruta avanzada de checkout desde el código fuente

Usa Enigma como tu Memory Drive privado para IA: instala una vez, conecta los clientes de IA que ya tienes y luego inspecciona la salud de la unidad y el estado del pasaporte antes de recordar, recuperar, empaquetar y verificar contexto.

npm install -g enigma-memory
enigma setup --bundle "$HOME/.enigma/bundle.json" --client auto --connect-installed --overwrite
echo "Keep all Q3 planning notes in the project-context tag." > memory.txt
enigma remember --bundle "$HOME/.enigma/bundle.json" --text-file memory.txt
enigma search --bundle "$HOME/.enigma/bundle.json" --query "Q3 planning"
enigma context --bundle "$HOME/.enigma/bundle.json" --query "Q3 planning" --out "$HOME/.enigma/context-pack.json"
enigma verify --export "$HOME/.enigma/export.json"

Windows CMD:

npm install -g enigma-memory
enigma setup --bundle "%USERPROFILE%\.enigma\bundle.json" --client auto --connect-installed --overwrite
echo Keep all Q3 planning notes in the project-context tag.> memory.txt
enigma remember --bundle "%USERPROFILE%\.enigma\bundle.json" --text-file memory.txt
enigma search --bundle "%USERPROFILE%\.enigma\bundle.json" --query "Q3 planning"
enigma context --bundle "%USERPROFILE%\.enigma\bundle.json" --query "Q3 planning" --out "%USERPROFILE%\.enigma\context-pack.json"
enigma verify --export "%USERPROFILE%\.enigma\export.json"

enigma setup es la primera ejecución sin credenciales: crea el espacio de trabajo local .enigma, el bundle, los artefactos de prueba y una memoria de demostración, y luego conecta todos los clientes instalados o con configuración presente que detecta (Claude Desktop, Cursor, Kimi Code, VS Code/Cline, Roo, OpenCode, MCP genérico). enigma start es un alias del flujo de inicio rápido. Setup omite los clientes que no están instalados y nunca crea configuraciones desde cero; previsualiza con --dry-run primero si quieres ver qué clientes se escribirán.

Modos de seguridad del keyring y confidencialidad en reposo

• Modo predeterminado de desarrollador (local_secret): Ejecutar enigma setup o enigma quickstart sin parámetros de credenciales inicializa un keyring de desarrollador sin cifrar (unencrypted: true). Este modo no proporciona ninguna confidencialidad en reposo frente al acceso local a archivos y está pensado únicamente para la evaluación local sin configuración.

• Modo cifrado soberano (local_secret_encrypted): Establece ENIGMA_PASSPHRASE en tu entorno o pasa --passphrase-file <path> para cifrar las claves de la bóveda en reposo usando AES-256-GCM AEAD con derivación de clave scrypt y autenticación de metadatos GCM AAD.

Flujo local cifrado y conectado a Solana:

npm install -g enigma-memory
printf "choose-a-long-local-passphrase\n" > ~/.enigma-passphrase
enigma quickstart --bundle "$HOME/.enigma/bundle.json" --passphrase-file ~/.enigma-passphrase --overwrite
enigma remember --bundle "$HOME/.enigma/bundle.json" --passphrase-file ~/.enigma-passphrase --text-file memory.txt
enigma-terminal --exec "solana status --cluster devnet"
enigma chain anchor-bundle --bundle "$HOME/.enigma/bundle.json" --cluster devnet --out "$HOME/.enigma/anchor-batch.json"
enigma chain submit-solana --file "$HOME/.enigma/anchor-batch.json" --cluster devnet
# Actual on-chain write, when you provide a funded Solana CLI keypair:
# enigma chain submit-solana --file "$HOME/.enigma/anchor-batch.json" --cluster devnet --execute --keypair ~/.config/solana/id.json

chain anchor-bundle ancla solo raíces de compromiso públicas (active_set_root, receipt_log_root) y referencias públicas. Nunca coloca memoria sin procesar, prompts en texto plano, claves de bóveda, frases de contraseña, claves privadas ni cuerpos de bundle cifrados en la cadena. chain submit-solana usa dry-run por defecto; --execute escribe una referencia de prueba compacta SPL Memo en Solana usando el keypair financiado que proporciones explícitamente.

La base de investigación cypherpunk está documentada en docs/research/sovereign-cypherpunk-memory.md: uso compartido por umbral de Shamir 1979, acumuladores de Merkle 1979, patrones de almacenamiento con negación plausible de Rubberhose/TrueCrypt, trinquetes de OTR/Signal y restricciones de bloqueo de memoria en Unix/Windows. El documento es explícitamente exploratorio; el Enigma de producción solo incluye las primitivas de bóveda local revisadas y el anclaje de compromiso seguro para Solana descrito anteriormente.

Ejecuta setup o quickstart antes de tratar enigma doctor como una comprobación de instalación completamente en verde. Doctor comprueba tanto el entorno local del paquete/tiempo de ejecución como las configuraciones de conectores existentes; en una instalación nueva puede aparecer en rojo cuando una configuración de cliente MCP ya menciona un bundle de Enigma que aún no se ha inicializado, o cuando los clientes todavía apuntan a otro lugar. Ese es el estado esperado de la primera ejecución, no una prueba de que el paquete npm no se instaló. La ruta sin fricción es enigma quickstart --bundle ./.enigma/bundle.json --overwrite o enigma setup --bundle ./.enigma/bundle.json --overwrite, y luego enigma doctor --bundle ./.enigma/bundle.json. Si no hay clientes instalados, setup igualmente tiene éxito y la ruta CLI local funciona; usa los fragmentos MCP de copiar y pegar que aparecen más abajo para conectar un cliente más tarde.

Para la ruta sin instalación global, ejecuta npx --yes --package enigma-memory enigma quickstart --bundle ./.enigma/bundle.json --overwrite antes de npx --yes --package enigma-memory enigma doctor --bundle ./.enigma/bundle.json; ejecutar npx doctor primero puede mostrar el mismo estado rojo esperado de MCP genérico con bundle faltante.

Related MCP server: Sovereign Universal Memory MCP

Enigma Proof Network

Enigma Proof Network es la capa de prueba pública para la memoria de IA: las herramientas locales pueden empaquetar raíces, referencias, recuentos, firmas, concesiones de capacidad con ámbito, revocaciones y atestaciones de referencia sin exponer memoria sin procesar, prompts, transcripciones, completions, embeddings, nombres de tenant, claves privadas, respuestas de proveedor ni credenciales de proveedor.

Los comandos enigma chain anchor|grant|revoke|attest|verify son comandos locales de planificación y verificación. Emiten JSON seguro para el público con transaction_submitted:false y raw_memory_on_chain:false; no envían transacciones a Solana, no despliegan SaaS alojado, no crean cuentas ni llaman a proveedores externos.

Empieza con la narrativa de categoría en docs/market-category-narrative.md, luego lee la visión técnica en docs/proof-network.md, usa su sección rol de Solana para el límite de anclaje listo para Solana, y lee docs/proof-network-faq.md para los límites de las afirmaciones.

Ruta avanzada/solo desde el código fuente

Usa un checkout del código fuente solo cuando necesites documentación solo-fuente, activos de Docker, andamiaje de extensión de navegador, desarrollo de paquetes o scripts de publicación:

git clone https://github.com/Enigma-Memory/enigma-memory.git
cd enigma-memory
npm run install:local -- --execute --init-vault --bundle ./.enigma/bundle.json
enigma doctor --bundle ./.enigma/bundle.json
enigma-relay demo
enigma-gateway demo

install:local es dry-run salvo que --execute esté presente. El comando anterior instala el paquete del checkout globalmente y crea un bundle de bóveda local. No requiere Cloudflare, OpenAI, Anthropic, credenciales de publicación npm, una base de datos ni infraestructura alojada.

Alternativa manual: inspecciona los pasos de bajo nivel de la bóveda local que enigma setup prepara para ti. Usa un archivo smoke aprobado por el tenant; no expandas memoria privada en argv del shell.

Shell POSIX:

mkdir -p .enigma
ENIGMA_DEMO_MEMORY_FILE=/absolute/path/to/tenant-approved-smoke-memory.txt
test -f "$ENIGMA_DEMO_MEMORY_FILE"
enigma init --bundle ./.enigma/bundle.json --subject local-user --display-name "Local user"
enigma remember --bundle ./.enigma/bundle.json --text-file "$ENIGMA_DEMO_MEMORY_FILE" --purpose user_memory --tags local
enigma context --bundle ./.enigma/bundle.json --query "local context" --purpose local_answer --out ./.enigma/context-pack.json
enigma export --bundle ./.enigma/bundle.json --out ./.enigma/export.json
enigma verify --export ./.enigma/export.json

Windows PowerShell:

New-Item -ItemType Directory -Force .enigma | Out-Null
$env:ENIGMA_DEMO_MEMORY_FILE = "C:\path\to\tenant-approved-smoke-memory.txt"
if (-not (Test-Path -LiteralPath $env:ENIGMA_DEMO_MEMORY_FILE)) { throw "Missing ENIGMA_DEMO_MEMORY_FILE" }
enigma init --bundle .\.enigma\bundle.json --subject local-user --display-name "Local user"
enigma remember --bundle .\.enigma\bundle.json --text-file $env:ENIGMA_DEMO_MEMORY_FILE --purpose user_memory --tags local
enigma context --bundle .\.enigma\bundle.json --query "local context" --purpose local_answer --out .\.enigma\context-pack.json
enigma export --bundle .\.enigma\bundle.json --out .\.enigma\export.json
enigma verify --export .\.enigma\export.json

El bundle es local. Los artefactos de prueba exportados contienen estado de bóveda cifrado/comprometido y metadatos de recibos; no pegues memoria sin procesar en texto plano en registros relay, puntos de control de testigos, eventos SIEM, artefactos de prueba públicos ni líneas de comandos del shell.

Configuración de MCP

Ejecuta el servidor MCP de Enigma sobre stdio:

Shell POSIX:

ENIGMA_BUNDLE="$HOME/.enigma/bundle.json" enigma-mcp

Windows PowerShell:

$env:ENIGMA_BUNDLE = "$HOME\.enigma\bundle.json"
enigma-mcp.cmd

O a través de la CLI:

ENIGMA_BUNDLE="$HOME/.enigma/bundle.json" enigma mcp serve

Forma CLI de Windows PowerShell:

$env:ENIGMA_BUNDLE = "$HOME\.enigma\bundle.json"
enigma.cmd mcp serve

Entrada de cliente MCP genérico:

{
  "mcpServers": {
    "enigma": {
      "command": "enigma-mcp",
      "args": [],
      "env": {
        "ENIGMA_BUNDLE": "/absolute/path/to/.enigma/bundle.json"
      }
    }
  }
}

El servidor MCP expone enigma_init, enigma_remember, enigma_search, enigma_context_pack, enigma_delete y enigma_verify_receipts, además de un recurso de resumen del pasaporte Enigma y un prompt de uso de memoria. La memoria nativa del proveedor debe tratarse solo como caché; el estado de la bóveda de Enigma sigue siendo canónico.

Conectar clientes

Los perfiles de conector compatibles son:

• claude-desktop

• cursor

• kimi-code

• vscode-cline

• roo

• opencode

• generic-mcp

La ruta de un solo comando anterior (enigma setup --client auto --connect-installed --overwrite) ya conecta todos los clientes instalados o con configuración presente. Para conectar o previsualizar un solo cliente en su lugar:

enigma connect claude-desktop --dry-run
enigma connect cursor --dry-run
enigma connect kimi-code --dry-run
enigma connect generic-mcp --dry-run

Elimina --dry-run de enigma connect <client> solo cuando estés listo para que Enigma fusione la entrada mcpServers.enigma en la configuración de ese cliente concreto. Un enigma setup sin --connect-installed ni --write-connectors nunca escribe configuraciones de aplicaciones de terceros.

Fragmentos MCP de copiar y pegar:

Claude Desktop:

{
  "mcpServers": {
    "enigma": {
      "command": "enigma-mcp",
      "args": [],
      "env": {
        "ENIGMA_BUNDLE": "/absolute/path/to/.enigma/bundle.json"
      }
    }
  }
}

Cursor:

{
  "mcpServers": {
    "enigma": {
      "command": "enigma-mcp",
      "args": [],
      "env": {
        "ENIGMA_BUNDLE": "/absolute/path/to/.enigma/bundle.json"
      }
    }
  }
}

Kimi Code:

{
  "mcpServers": {
    "enigma": {
      "command": "enigma-mcp",
      "args": [],
      "env": {
        "ENIGMA_BUNDLE": "/absolute/path/to/.enigma/bundle.json"
      }
    }
  }
}

MCP genérico:

{
  "mcpServers": {
    "enigma": {
      "command": "enigma-mcp",
      "args": [],
      "env": {
        "ENIGMA_BUNDLE": "/absolute/path/to/.enigma/bundle.json"
      }
    }
  }
}

Usa --mcp-command (alias --command) cuando una aplicación GUI no pueda encontrar binarios instalados en el shell o necesite una ruta .cmd en Windows.

Extensión de navegador y host nativo

La extensión de navegador es un andamiaje Manifest V3 sin empaquetar en:

apps/browser-extension

Los activos de instalación del host local de mensajería nativa están en:

apps/native-host

Registra el nombre de host com.enigma.native_host generando un manifiesto específico para el navegador:

enigma native-host manifest --browser chrome --host-path "/absolute/path/to/enigma-native-host" --extension-id "REPLACE_WITH_EXTENSION_ID" --out ./com.enigma.native_host.json

Usa --browser edge o --browser firefox para esos navegadores. Encuentra los IDs de Chrome sin empaquetar en chrome://extensions > Modo de desarrollador > Enigma > Detalles, los IDs de Edge en edge://extensions > Modo de desarrollador > Enigma > Detalles, y los IDs de Firefox en about:debugging#/runtime/this-firefox o desde un browser_specific_settings.gecko.id estable / ID de complemento firmado. La ruta del host debe ser absoluta y apuntar a enigma-native-host o a un wrapper que establezca ENIGMA_BUNDLE antes de lanzarlo. Sin --out, el generador imprime el JSON del manifiesto en stdout; con --out, escribe el archivo e informa { ok, path }. Copia el com.enigma.native_host.json resultante en la ubicación de host nativo del navegador/SO, o crea tú mismo la clave de registro de Windows documentada. Las plantillas manuales permanecen en apps/native-host/manifests/. Los comandos exactos de copia y registro están en apps/native-host/README.md.

El host nativo está dentro del límite de confianza local: protege el manifiesto, el wrapper, el ejecutable y la ruta ENIGMA_BUNDLE de modificaciones locales. La extensión no usa almacenamiento de sincronización del navegador (chrome.storage.sync) en absoluto y requiere un clic explícito del usuario antes de insertar contexto de Enigma en ChatGPT, Claude, Kimi, Perplexity u otra página de proveedor compatible. La memoria nativa del proveedor sigue siendo solo caché; los recibos de Enigma no prueban la eliminación por parte del proveedor ni el olvido del modelo. Consulta apps/browser-extension/README.md, apps/native-host/README.md y docs/install-anywhere.md en el checkout del código fuente.

Andamiaje de escritorio

La superficie de escritorio es un andamiaje local estático en:

apps/desktop/src/index.html

Ábrelo directamente en un navegador o empaquétalo dentro de un shell de escritorio. Modela pantallas de bóveda, MCP, clientes, importación/exportación, verificador, eliminación, mesh y empresariales. El estado de la UI de escritorio es solo evidencia operativa; la prueba criptográfica sigue viniendo de los recibos de Enigma y la salida del verificador.

Modos relay, gateway, Docker y empresariales

Los servidores locales relay y gateway son módulos HTTP de Node:

• apps/relay/src/server.mjs almacena registros relay cifrados opacos, firma puntos de control de testigos y gestiona el emparejamiento. Rechaza campos de memoria que parezcan texto plano.

• apps/gateway/src/server.mjs evalúa la política empresarial, emite decisiones firmadas y exporta eventos SIEM con texto plano minimizado. No llama a proveedores de modelos.

Los binarios directos están disponibles después de una instalación desde el código fuente o desde el paquete. Añade --state-file <path> cuando una demo local deba sobrevivir a un reinicio:

mkdir -p .enigma/state
enigma-relay demo
enigma-relay serve --host 127.0.0.1 --port 8787 --state-file ./.enigma/state/relay-state.json
enigma-gateway demo
enigma-gateway serve --host 127.0.0.1 --port 8797 --state-file ./.enigma/state/gateway-state.json

El mismo comportamiento también está disponible a través de la CLI principal:

enigma relay demo
enigma relay serve --host 127.0.0.1 --port 8787 --state-file ./.enigma/state/relay-state.json
enigma gateway demo
enigma gateway serve --host 127.0.0.1 --port 8797 --state-file ./.enigma/state/gateway-state.json

El --state-file es durabilidad de demostración local, no una base de datos de producción. Los archivos de estado del relay pueden contener metadatos de nodo relay/confianza, material de firma de la demo local, registros relay de solo hash u opacos, puntos de control de testigos, emparejamientos completados y modo de autorización; no deben contener memoria cruda en texto plano, prompts, transcripciones, contenido de cápsulas descifrado, cuerpos de solicitud en bruto ni desafíos pendientes. Los datos de negocio del estado del gateway se limitan a metadatos de política activa/minimizada, hash de política y evidencia de SIEM/decisión minimizada en texto plano, pero la instantánea también puede incluir identidad local de demostración y material de clave de firma Ed25519 necesario para verificar las decisiones; no debe contener memoria cruda, prompts, completions, transcripciones, respuestas de proveedor, embeddings, secretos del tenant, material KMS ni afirmaciones de estado oculto del proveedor. El estado desconocido, malformado o con apariencia de texto plano falla en modo seguro en lugar de restablecerse silenciosamente.

Mantenga los archivos de estado fuera del control de versiones con permisos de archivo solo para el propietario. Las copias de seguridad solo son útiles para la restauración de la demo local; las implementaciones hosted y BYOC siguen necesitando almacenamiento duradero real, KMS/secretos, copias de seguridad monitorizadas, ensayos de restauración y un paquete de operador aceptado.

Para demos de Docker desde el checkout del código fuente:

cd enigma
docker compose up --build relay gateway

Consulte docs/install-anywhere.md y docs/deployment-runbook.md en el checkout del código fuente para ver los pasos concretos de servidor local, Docker, hosted y BYOC.

Modos empresariales:

• Hosted: el operador de Enigma ejecuta el relay/gateway para un tenant. Requiere credenciales de implementación, TLS, almacenamiento duradero de producción, KMS/secretos, monitoreo, copias de seguridad, respuesta a incidentes y política del tenant.

• BYOC: el cliente ejecuta el relay/gateway en su propia nube o red. El cliente controla el KMS, las políticas de red, los registros, la residencia de datos, las copias de seguridad y las credenciales de implementación.

En ambos modos, la memoria nativa del proveedor se trata solo como caché. Enigma puede demostrar su propio estado confirmado de clipboard y sus decisiones de política; no puede demostrar que un proveedor externo haya borrado estado oculto o haya cambiado los pesos del modelo.

Importación y migración

Las API de importadores normalizan la memoria y el contexto exportados de ChatGPT, Claude, Mem0, a Letta, LangGraph, Zep/Graphiti y cápsulas de Enigma en candidatos con referencias de origen, limitaciones, confianza y herramientas de completitud. Las conexiones importadas conservan las pasaderas del origen. Una exportación de origen se convierte en actual, canónica, solo después de que el candidato se escriba a través de un vault de Enigma y reciba recibos de Enigma.

Ejemplos de migración de CLI:

enigma import chatgpt --file ./chatgpt-export.json --out ./enigma-import-report.json
enigma capsule export --file ./enigma-import-report.json --out ./enigma-capsule.json
enigma capsule import --file ./enigma-capsule.json --bundle "$HOME/.enigma/bundle.json"

Comandos de verificación

Auditoría repetible de paquete y demo:

npm run release:audit

Esta es la ruta de evidencia de la versión local en un solo comando; añada -- --out <file> cuando otro comando de producción de Enigma necesite consumir el JSON de auditoría. El entorno de ejecución de Docker, la nube alojada, el npm publicación y la revisión del sitio en vivo siguen siendo verificaciones externas/requisitos del operador en lugar de requisitos previos para release:audit.

Evidencia local de sumas de comprobación de procedencia/SBOM:

npm run provenance:local -- --out ./.enigma/release-provenance.json

Utilice docs/release-provenance-and-sbom.md para interpretar el JSON generado. Los revisores pueden comparar las entradas (path, sha256) registradas con los valores SHA-256 recién calculados, o bien otra prueba puede comparar con otro archivo de procedencia. Ejecute npm pack --dry-run por separado al revisar el contenido del tarball del paquete, y compile el artefacto del sitio público antes de volver a ejecutar la procedencia cuando la suma public_site_manifest opcional esté en el alcance. El archivo de procedencia es solo evidencia local de suma y comprobación no firmados.

Paquete de revisión manual:

python scripts/build_public_site.py
npm run review:packet -- --out ./.enigma-review-packet --public-site ./_public_site

Use docs/reviewer-packet.md para inspeccionar REVIEW_PACKET_MANIFEST.json, evidence/release-audit.json, evidence/local-provenance.json, package/npm-pack-dry-run.json, los docs/ copiados, el site/ opcional y los valores SHA-256 registrados. Pase --public-site solo para un artifact del sitio público ya generado y compilado, como ./_public_site; el paquete copia pruebas locales para revisión y no demuestra la publicación en npm, el despliegue en Cloudflare en vivo, el comportamiento de imagen/runtime de Docker, la preparación hosted/BYOC, la aprobación legal, la procedencia firmada ni el estado de cumplimiento.

Ruta de prueba de humo local:

ENIGMA_DEMO_MEMORY_FILE=/absolute/path/to/tenant-approved-smoke-memory.txt
test -f "$ENIGMA_DEMO_MEMORY_FILE"
enigma init --bundle ./.enigma/bundle.json
enigma remember --bundle ./.enigma/bundle.json --text-file "$ENIGMA_DEMO_MEMORY_FILE" --purpose local_test
enigma export --bundle ./.enigma/bundle.json --out ./.enigma/export.json
enigma verify --export ./.enigma/export.json
enigma boundary run --scenario committed_crossing

Protocolo de enlace JSON-RPC de MCP:

printf '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"manual","version":"0"}}}\n{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}\n' | ENIGMA_BUNDLE="$PWD/.enigma/bundle.json" enigma-mcp

Demo de conector:

node --input-type=module -e "import { runConnectorDemo } from './packages/connectors/src/index.js'; console.log(JSON.stringify(runConnectorDemo({ clientId: 'generic-mcp' }), null, 2));"

Demo de importador:

node --input-type=module -e "import { runImporterDemo } from './packages/importers/src/index.js'; console.log(JSON.stringify(runImporterDemo(), null, 2));"

Demos de relay y gateway:

enigma-relay demo
enigma-gateway demo

Servidores de relay y gateway:

enigma-relay serve --host 127.0.0.1 --port 8787
enigma-gateway serve --host 127.0.0.1 --port 8797

Límite de las afirmaciones

Enigma puede afirmar honestamente lo siguiente:

• Unoun de Enigma local contiene o deja de servir direcciones de memoria confirmadas.

• Un evento de creación, recuperación, empaquetado de contexto, actualización o "tombstone" de memoria produjo un recibo que se verifica sin conexión.

• Un entorno de prueba de límites clasificó un evento límite observado como confirmado, bloqueado, fuera de alcance o fallido.

• Un relay almacenó un registro cifrado opaco o firmó un punto de control de testigo sin memoria cruda en texto plano.

• Una decisión del gateway siguió una política empresarial específica de Enigma en un hash de política concreto.

Enigma no puede afirmar honestamente que:

• Un operador neutral y cerró la totalidad de las copias internas.

• Un modelo olvidó el entrenamiento, el ajuste fino, la caché, la telemetría o el estado de personalización oculto.

• Enigma provocó un olvido semántico en las salidas del modelo, la personalización oculta, errores de conexión, ponderaciones, resúmenes, historiales o bases de datos de los proveedores o del estado de Enigma.

• Las memorias importadas del proveedor están completas a menos que la exportación fuente demuestre explícitamente la completitud.

• Una declaración de memoria firmada es verdadera en el mundo real; los recibos demuestran custodia y ciclo de vida, no la corrección factual.

• Rentabilidad del token: ROI, beneficio, capital, reparto de ingresos, devolución de la inversión o expectativa de precio del token.

• Proveedores hardware inalterables o superioridad de cómputo bruto.

• Liderazgo en evaluaciones benchmark sin evidencia de repositorio medida.

• Un servicio en la nube alojado o el cliente con BYOC está activo si no se cumplen las condiciones necesarias; el estado de demo local --state-file no representa la preparación para hosted/BYOC.

• Que un paquete de revisión local o el resultado de procedencia/SBOM local sea procedencia firmada, atestación de registro, evidencia de control de versiones de git, nivel SLSA, certificación de cumplimiento, resumen de imagen de Docker/runtime, publicación de npm, preparación hosted/BYOC o prueba de un despliegue alojado o en la nube.

Lea a continuación:

• docs/overnight-build-master-plan.md

• docs/release-evidence-2026-06-23.md

• docs/release-provenance-and-sbom.md

• docs/reviewer-packet.md

• SECURITY.md

• docs/security-threat-model.md

• docs/operator-acceptance-packet.md

• docs/cloudflare-token-and-domain-runbook.md

• docs/public-api-reference.md

• docs/install-anywhere.md

• docs/client-connectors.md

• docs/deployment-runbook.md

• docs/production-release-checklist.md