Documentación de SynaBun

Descripción general #

SynaBun es un sistema local de memoria persistente y un conjunto de herramientas de automatización para asistentes de IA. Cualquier herramienta de IA compatible con MCP —Claude Code, Codex, Gemini, OpenCode, Cursor, Windsurf o cualquier otra— puede conectarse y conservar conocimiento entre sesiones. Incluye paneles laterales dedicados para Claude Code, Codex y OpenCode, y el Asistente de SynaBun se ubica por encima de ellos como un orquestador con acceso a la memoria que reparte el trabajo entre esas tres CLI.

Las memorias se guardan en una única base de datos local SQLite, con índices de palabras clave y embeddings vectoriales generados localmente. recall usa recuperación híbrida —búsqueda por palabras clave con SQLite FTS5, embeddings de documentos y refinamiento por pasajes, combinados mediante fusión de rangos recíprocos—, así que encuentra la memoria correcta tanto si recuerdas un identificador exacto como si solo recuerdas la idea de fondo.

Funciones principales #

• 157 herramientas MCP — memoria (8), loop (1), perfil (1), elección (1), automatización del navegador (46: 21 herramientas generales, incl. browser_batch, browser_console y browser_cheatsheet, más 25 herramientas de plataformas), BlueSky (15), Google Search Console (30), YouTube (11), orquestación del Asistente de SynaBun (12 herramientas agent_*), uso del equipo (4), Leonardo AI (5), whiteboard (5), tarjetas (5), discord (8), git (1), imagen (1), guía de estilo (1), MoreLogin (1), tictactoe (1)
• Más de 500 endpoints de API REST — API HTTP completa para integraciones externas y para Neural Interface
• Asistente de SynaBun — un orquestador central que piensa con el cerebro que tú elijas (Claude Code, Codex u OpenCode), recupera memorias en cada turno y lanza agentes de trabajo autónomos con enrutamiento de modelos, instrucciones de tarea tras aclarar la solicitud, presupuestos y contabilidad de tokens. Consulta Asistente de SynaBun.
• Motor Memory v2 — recuperación híbrida (FTS5 + embeddings + refinamiento por pasajes), recuperación compacta con presupuesto, historial de revisiones con opción de deshacer, escrituras idempotentes y mantenimiento reversible. Consulta Motor Memory v2.
• Uso del equipo (macOS) — el Asistente puede manejar tu Mac mediante capturas de pantalla, ratón, teclado, aplicaciones y el árbol de accesibilidad, limitado por protecciones siempre activas y controles de detención
• 3 paneles laterales dedicados — Claude Code, Codex y OpenCode, con docks de actividad de herramientas, cancelación por agente, tarjetas de permisos, panel de TODO, indicador de contexto, menú de sesión, ventana de nueva sesión (selector de proyecto + branch) y Multi-CLI Resume con selector de proveedor
• Estudio de automatizaciones — carpetas plegables creadas por el usuario, valores de lanzamiento predeterminados por plantilla (CLI / modelo / esfuerzo / perfil MCP) y compatibilidad de primer nivel con 4 CLI (Claude Code, Codex, Gemini, OpenCode)
• Gestión universal de MCP — formulario de alta con pegado inteligente (detecta automáticamente 5 formatos de configuración), sincronización multiplataforma entre Claude Code / Codex / Gemini / OpenCode, bóveda centralizada de variables de entorno con enmascaramiento de valores sensibles, registro automático de perfiles e instalación con un clic desde GitHub
• Perfiles de recuperación predefinidos — Rápido / Equilibrado / Profundo / Personalizado, con 6 controles de ajuste fino y un indicador de impacto en vivo (tokens por recuperación, memorias alcanzables, contexto de la sesión)
• Hooks de Claude Code — 10 scripts de hook con 11 registros en 9 eventos del ciclo de vida para automatizar la recuperación, la captura de memorias, las instrucciones para subagentes y la gestión del contexto
• Reglas de SynaBun — un conjunto breve de reglas que se instala y se mantiene actualizado automáticamente para Claude Code, Codex, Gemini y OpenCode cuando conectas una herramienta
• Guía de estilo — un sistema de marca y diseño por proyecto, escrito como DESIGN.md más tokens de diseño, que llega a cada agente mediante la herramienta style_guide
• Embeddings locales — Transformers.js (all-MiniLM-L6-v2, 384 dimensiones) sin configuración; la inferencia de embeddings nunca envía el texto de tus memorias a un proveedor en la nube
• Decisiones con IA (opcional) — los juicios tipados de Jev (TypeSafe) reemplazan las heurísticas con regex para duplicados, relevancia, obsolescencia y más; cuando está desactivado, cada área recurre a una heurística local
• Vinculación con WhatsApp — conversa con el Asistente desde tu teléfono como dispositivo vinculado, con niveles de permiso que se aplican en tu equipo
• Neural Interface en 3D — un mapa de memorias de todo tu almacén en localhost:3344
• Compatibilidad con varios proyectos — las memorias se etiquetan por proyecto y puedes buscarlas en todos o filtrarlas por proyecto
• Categorías jerárquicas — sistema de categorías padre/hija con esquema dinámico
• Renderizado de código moderno — resaltado de sintaxis, rutas de archivo convertidas en enlaces, etiquetas de lenguaje, botones de copiar que solo aparecen al pasar el cursor, streaming limitado a 30 fps y streaming en tiempo real de los bloques de razonamiento
• Self-hosted y local-first — la base de datos, los embeddings y la recuperación se ejecutan en tu máquina

Cómo funciona #

Cuando tu asistente de IA llama a remember, SynaBun genera el embedding del contenido localmente con Transformers.js (all-MiniLM-L6-v2, 384 dimensiones) y lo escribe en SQLite junto con sus metadatos (categoría, proyecto, importancia, etiquetas, tipo, archivos relacionados) y una primera revisión. Los documentos largos también se dividen en pasajes de origen, para que la evidencia que aparece al final de un documento siga siendo localizable.

Cuando llama a recall, la búsqueda por palabras clave (SQLite FTS5) y los embeddings de documentos proponen candidatos cada uno por su lado, el refinamiento por pasajes los afina y la fusión de rangos recíprocos combina las clasificaciones. Las puntuaciones de clasificación son señales de relevancia, no probabilidades de confianza. Un filtro project explícito nunca se amplía a otros proyectos, y format: "compact" devuelve extractos con presupuesto en lugar de memorias completas. Consulta Motor Memory v2.

Inicio rápido #

Requisitos previos #

• Node.js 22.5+ — para el servidor MCP, la base de datos SQLite (mediante el módulo integrado node:sqlite) y Neural Interface
• Sin claves de API ni Docker — los embeddings se ejecutan localmente con Transformers.js y la base de datos es un único archivo
• Herramientas de compilación opcionales — la terminal integrada usa node-pty, un complemento nativo. Sin herramientas de compilación, npm install muestra una advertencia y continúa; todo lo demás funciona. Instálalas con xcode-select --install (macOS), sudo apt install build-essential python3 (Linux) o VS Build Tools 2022 con "Desktop development with C++" (Windows).

Instalación #

# Clone the repository
git clone --depth=1 https://github.com/danilokhury/Synabun.git
cd Synabun

# Start everything (installs deps, builds MCP, launches Neural Interface)
npm start

# Install globally via npm
npm install -g synabun

# Launch (installs deps, builds MCP, opens onboarding wizard)
synabun

Qué hace npm start #

npm start y el comando synabun ejecutan el mismo script de instalación:

1. Comprueba el directorio de datos (~/.synabun de forma predeterminada) y, en las instalaciones que guardaban su estado dentro del checkout, lo migra antes de iniciar cualquier otra cosa
2. Comprueba la versión de Node.js e instala las dependencias de Neural Interface y del servidor MCP
3. Instala el navegador Chromium de Playwright que se usa para la automatización del navegador
4. Compila el servidor MCP (transportes stdio y HTTP, compatible con todos los clientes MCP)
5. Repara los registros de SynaBun que ya existen en tus herramientas de IA para que apunten al build actual
6. Inicia la Neural Interface en el puerto 3344 y la abre en tu navegador; en la primera ejecución verás el asistente de configuración inicial

La base de datos SQLite se crea en ~/.synabun/mcp-data/memory.db, y el modelo de embedding local (Xenova/all-MiniLM-L6-v2, ONNX de ~23MB) se descarga una sola vez y queda en caché.

Conecta con Claude Code #

El asistente de configuración inicial y Ajustes → Conexiones de IA registran SynaBun en Claude Code, Codex, Gemini y OpenCode, e instalan las Reglas de SynaBun para cada herramienta que conectes. Para registrarlo a mano, agrega SynaBun al .mcp.json de tu proyecto:

// .mcp.json
{
  "mcpServers": {
    "SynaBun": {
      "command": "node",
      "args": ["/path/to/Synabun/mcp-server/run.mjs"]
    }
  }
}

O regístralo de forma global para todos los proyectos:

claude mcp add SynaBun node "/path/to/Synabun/mcp-server/run.mjs" -s user

Verifica la instalación #

# Check database exists
ls ~/.synabun/mcp-data/memory.db

# Inspect database, migration, client-registration, and backup health
synabun doctor

# Check Neural Interface API
curl http://localhost:3344/api/stats

# Open Neural Interface in browser
open http://localhost:3344

Reinicia Claude Code y ejecuta /mcp: el servidor SynaBun debería aparecer en la lista con sus herramientas. Si trabajas desde un checkout de git, ejecuta los subcomandos de la CLI así: npm start -- doctor. Consulta Comandos de la CLI.

Arquitectura #

SynaBun sigue una arquitectura por capas: tu asistente de IA se comunica mediante MCP, el servidor MCP se encarga de despachar las herramientas, los embeddings se generan en local y las memorias se guardan y se buscan en SQLite. Todo se ejecuta en tu máquina: sin servicios externos, sin Docker y sin claves de API.

┌─────────────────────────────────────────────────────────────┐
│                     AI ASSISTANT                            │
│    (Claude Code, Codex, Gemini, OpenCode, Cursor, ...)      │
└───────────────────────┬─────────────────────────────────────┘
                        │  Model Context Protocol (stdio or HTTP)
                        ▼
┌─────────────────────────────────────────────────────────────┐
│                  SYNABUN MCP SERVER                         │
│                                                             │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐     │
│  │ remember │  │  recall  │  │ reflect  │  │  forget  │     │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘     │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐     │
│  │ restore  │  │ memories │  │   sync   │  │ category │     │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘     │
│  + loop, profile, choice and 21 switchable tool groups      │
└─────────────┬───────────────────────┬───────────────────────┘
              │                       │
              ▼                       ▼
┌─────────────────────┐  ┌───────────────────────────────────┐
│  LOCAL EMBEDDINGS   │  │  SQLITE                           │
│                     │  │  ~/.synabun/mcp-data/memory.db    │
│  • Transformers.js  │  │                                   │
│  • all-MiniLM-L6-v2 │  │  Memories + revision history      │
│  • 384 dimensions   │  │  FTS5 keyword index               │
│  • Isolated worker  │  │  Vectors as Float32 BLOBs         │
│    process          │  │  Session evidence, trash          │
└─────────────────────┘  └───────────────────────────────────┘
                                        │
                                        ▼
                        ┌───────────────────────────────────┐
                        │    NEURAL INTERFACE               │
                        │    (Express REST API + 3D UI)     │
                        │    localhost:3344                 │
                        └───────────────────────────────────┘

Flujo de datos #

Escritura de una memoria: la IA llama a remember(content, category, project) → se ocultan las credenciales con formatos conocidos que aparezcan en el texto → se genera el embedding del contenido en local → la memoria, sus metadatos y su primera revisión se escriben en SQLite → se devuelve el UUID completo.

Lectura de memorias: la IA llama a recall(query) → la búsqueda por palabras clave de FTS5 y la búsqueda por embeddings proponen candidatos cada una → el refinamiento por pasajes compara los mejores documentos padre pasaje a pasaje → la fusión de rangos recíprocos combina las clasificaciones → los resultados llegan como memorias completas o como extractos compactos ajustados a un presupuesto de tokens.

Neural Interface: el navegador se conecta a la API REST de Express en el puerto 3344 → carga las memorias → renderiza el Mapa de memorias en 3D con Three.js → permite buscar, enviar a la Papelera, restaurar, hacer copias de seguridad y sincronizar.

Recuperación híbrida #

La recuperación ya no depende de una única puntuación de similitud. El motor Memory v2 combina varias señales:

• Canal de palabras clave: FTS5 de SQLite encuentra identificadores exactos y evidencias que aparecen al final de documentos largos
• Canal de embeddings: los vectores de documento del modelo MiniLM local encuentran memorias por su significado
• Refinamiento por pasajes: hasta 50 candidatos por canal proponen como máximo 100 documentos padre, cuyos pasajes se comparan después. Refina candidatos; no es un recorrido exhaustivo de todos los pasajes.
• Fusión de rangos recíprocos: combina las clasificaciones en una sola lista. min_score filtra por similitud de coseno bruta o por cobertura de palabras clave antes de la fusión.
• Alternativa de respaldo: si el modelo de embedding falta o falla, la recuperación por palabras clave sigue disponible y las memorias nuevas se guardan con la indexación semántica pendiente

Sin un filtro project, la recuperación busca en todos los proyectos y da prioridad al actual; recency_boost inclina la clasificación hacia las memorias recientes (vida media de 14 días, peso de recencia del 55%). La ruta de recuperación anterior a la 2.0 se mantiene como vuelta atrás: define SYNABUN_MEMORY_ENGINE=legacy para el servidor y reinícialo.

Herramientas MCP #

SynaBun expone 157 herramientas mediante el Model Context Protocol. Once están siempre activas (remember, recall, reflect, forget, restore, memories, category, sync, loop, profile y choice) y las otras 146 se reparten en 21 grupos de herramientas que los perfiles de herramientas activan y desactivan. Las herramientas de memoria que aparecen a continuación son el núcleo del sistema; cada uno de los demás grupos está documentado en su propia sección.

Grupos de herramientas #

El resto de las herramientas está organizado en grupos. Un perfil decide qué grupos ve un runtime; dos grupos no dependen del perfil, sino de quién hace la llamada.

remember #

Guarda una memoria con contenido, categoría, proyecto y metadatos opcionales. Devuelve el UUID completo de la memoria creada.

// Store a bug fix
remember({
  content: "Fixed race condition in auth middleware by adding mutex lock around token refresh logic. Root cause was concurrent requests hitting the token expiry check simultaneously.",
  category: "bug-fixes",
  project: "my-app",
  importance: 8,
  tags: ["auth", "race-condition", "middleware"],
  kind: "issue",
  source: "self-discovered",
  related_files: ["src/middleware/auth.ts"],
  idempotency_key: "fix:auth-race"
})

category y project son obligatorios en cada llamada. kind puede ser note (valor predeterminado), decision, issue, preference, fact o session. El campo source acepta user-told, self-discovered o auto-saved. La importancia va de 1 (trivial) a 10 (fundamental) y su valor predeterminado es 5.

idempotency_key hace que los reintentos sean seguros: dentro de un proyecto y una categoría, la misma clave con el mismo contenido devuelve el UUID existente en lugar de escribir una copia. source_ref registra el identificador de una sesión o un evento. Las credenciales con formatos conocidos (claves de API, tokens, bloques de claves privadas) se ocultan antes de generar el embedding de la memoria y guardarla.

recall #

Busca en las memorias guardadas con recuperación híbrida. Encuentra las memorias relevantes por su significado aunque las palabras no coincidan, y por palabra clave exacta cuando sí coinciden.

// Compact, budgeted discovery with filters
recall({
  query: "authentication issues token refresh",
  project: "my-app",
  tags: ["auth", "middleware"],
  tag_match: "all",
  after: "2026-09-01T00:00:00Z",
  format: "compact",
  token_budget: 1500,
  explain: true
})

Todos los parámetros de filtro son opcionales. Si omites project, la búsqueda abarca todo y da más peso al proyecto actual. Usa format: "compact" para explorar y luego obtén los originales completos con la acción get o get-batch de memories.

reflect #

Actualiza una memoria existente. Indica solo los campos que quieras cambiar. Si se actualiza content, el vector de embedding se regenera automáticamente.

// Update importance and add a tag, only if nothing changed since revision 3
reflect({
  memory_id: "8f7cab3b-644e-4cea-8662-de0ca695bdf2",
  importance: 9,
  add_tags: ["critical"],
  subcategory: "auth",
  expected_revision: 3
})

// Mark this memory as the replacement for an older one
reflect({
  memory_id: "8f7cab3b-644e-4cea-8662-de0ca695bdf2",
  supersedes: "2c1d7e90-5b1a-4f6e-9a3c-7d2e8f4b6a10"
})

expected_revision rechaza la actualización si la memoria cambió desde esa revisión. supersedes vincula de forma explícita esta memoria como reemplazo de otra memoria activa del mismo proyecto; los ciclos se rechazan, y una memoria reemplazada queda fuera de la recuperación del estado actual.

forget / restore #

forget mueve una memoria a la papelera (borrado reversible). restore la recupera. Las memorias de la papelera también se pueden gestionar desde el panel Papelera de Neural Interface.

// Soft-delete
forget({ memory_id: "8f7cab3b-644e-4cea-8662-de0ca695bdf2" })

// Restore from trash
restore({ memory_id: "8f7cab3b-644e-4cea-8662-de0ca695bdf2" })

memories #

Explora las memorias, obtén una completa, revisa sus revisiones y controla el mantenimiento. Las acciones de listado truncan el contenido a 150 caracteres; get lo devuelve sin truncar.

// Get recent memories
memories({ action: "recent", limit: 10 })

// Fetch one memory in full
memories({ action: "get", id: "8f7cab3b-644e-4cea-8662-de0ca695bdf2" })

// Project briefing without a search query
memories({ action: "context", project: "my-app", token_budget: 1500 })

// Review revisions, then roll back to revision 2
memories({ action: "history", id: "8f7cab3b-644e-4cea-8662-de0ca695bdf2" })
memories({ action: "undo", id: "8f7cab3b-644e-4cea-8662-de0ca695bdf2", revision: 2, expected_revision: 4 })

sync #

Detecta las memorias cuyos related_files han cambiado desde la última actualización de la memoria. Compara los hashes SHA-256 de los archivos con las sumas de verificación guardadas y devuelve una lista compacta (ID y archivos modificados, sin contenido). Pasa categories para acotar el análisis; el limit por defecto es 50 (máximo 1.000).

// Check one project, scoped to two categories
sync({ project: "my-app", categories: ["my-app-architecture", "my-app-bugs"] })

// Raise the limit for a narrow category
sync({ categories: ["my-app-config"], limit: 200 })

category #

Una sola herramienta gestiona la taxonomía de categorías; el parámetro action elige entre crear, actualizar, eliminar o listar. Las categorías pueden tener relaciones de padre e hija. Al crear o actualizar una categoría se refresca el esquema dinámicamente, así que las descripciones de las herramientas se actualizan al instante.

// Create a parent category
category({
  action: "create",
  name: "myproject",
  description: "All knowledge for My Project",
  is_parent: true,
  color: "#3b82f6"
})

// Create a child category
category({
  action: "create",
  name: "myproject-bugs",
  description: "Bug fixes and known issues",
  parent: "myproject"
})

// Rename a category
category({ action: "update", name: "myproject-bugs", new_name: "myproject-issues" })

// Delete, reassigning memories to another category
category({ action: "delete", name: "myproject-issues", reassign_to: "myproject-notes" })

// List all categories as a tree
category({ action: "list", format: "tree" })

list acepta en format los valores tree (por defecto), flat o parents-only. Al eliminar una categoría padre, reassign_children_to mueve sus hijas a otra categoría padre.

profile #

El enrutador de capacidades que siempre está disponible. action: "get" devuelve el perfil actual, sus grupos activos y los presets; action: "set" cambia el perfil solo en este runtime y refresca la lista de herramientas del host. Un cambio nunca afecta a otras sesiones ni al valor por defecto de las sesiones futuras.

// Inspect this runtime
profile({ action: "get" })

// Switch to a preset, or pass comma-separated groups
profile({ action: "set", profile: "linkedin" })
profile({ action: "set", profile: "git,image,browser,gsc" })

• Claude Code siempre usa el perfil full: carga los esquemas de las herramientas bajo demanda, así que no necesita ninguna restricción.
• Los paneles laterales de Codex anuncian el catálogo completo como herramientas diferidas desde el inicio de cada turno, así que allí un perfil es una selección de enfoque y no requiere recargar.
• Los grupos agents y computer nunca forman parte de un preset. profile set no puede mostrarlos ni ocultarlos.
• Los perfiles que agregas en la Neural Interface aparecen junto a los presets integrados. Desde una shell, synabun profile list, synabun profile get y synabun profile set <name> muestran los perfiles y cambian el perfil por defecto guardado.

choice #

Un prompt bloqueante de opción múltiple para hosts sin una herramienta nativa de preguntas, como Codex en modo Default. Envía de una a tres preguntas mediante la elicitación por formulario de MCP; cada pregunta tiene entre dos y cuatro opciones mutuamente excluyentes, y siempre se ofrece una respuesta de texto libre «Otro». Si el host indica que no admite la elicitación, el asistente plantea una sola vez las mismas opciones numeradas en texto plano.

choice({
  questions: [{
    id: "scope",
    header: "Scope",
    question: "Which memories should the audit cover?",
    options: [
      { label: "This project", description: "Only memories tagged with the current project" },
      { label: "Everything", description: "All projects and categories" }
    ]
  }]
})

Motor de memoria v2 #

SynaBun 2.0.0 lleva todos los puntos de acceso a la memoria (las herramientas MCP, la búsqueda de la Neural Interface, los hooks de Claude Code, la indexación de sesiones y la interfaz de terminal) a un único motor local compartido. Los nombres de herramientas, los argumentos obligatorios, los UUID, las etiquetas de proyecto y el contenido guardado que ya tenías siguen funcionando.

Recuperación híbrida #

La recuperación híbrida es el modo por defecto. Combina SQLite FTS5, embeddings de documentos y refinamiento de pasajes mediante fusión de rangos recíprocos.

• Los filtros de proyecto explícitos nunca se amplían a otros proyectos. Los alias de proyecto registrados y las diferencias de mayúsculas y minúsculas se resuelven sin reetiquetar los registros guardados.
• Por defecto, las etiquetas coinciden con cualquiera de los valores; tag_match: "all" exige todos.
• Los documentos largos reciben pasajes de origen verificados con el tokenizador y un vector agregado del documento, de modo que se encuentran los identificadores exactos y la evidencia que aparece al final de los documentos largos.
• Hasta 50 candidatos por canal de recuperación proponen como máximo 100 documentos padre para el refinamiento de pasajes.
• Las puntuaciones de ranking son señales de relevancia, no probabilidades de confianza.

Recuperación compacta y contexto #

El formato de salida original y los límites de recuperación que hayas configurado siguen siendo compatibles. Los agentes pueden pedir, en cambio, evidencia concisa:

{
  "query": "SQLite backup checkpoint policy",
  "project": "synabun",
  "format": "compact",
  "token_budget": 1500,
  "include_sessions": true
}

• El presupuesto compacto incluye los metadatos y usa una estimación local en UTF-8. Obtén la evidencia original con la acción get de memories, o con get-batch y hasta 50 UUID.
• La acción context de memories, con un proyecto explícito, devuelve un resumen acotado y extractivo de las decisiones, incidencias, preferencias y notas recientes sin generar el embedding de una consulta. Conserva los ID de origen y no inventa un relato.
• La inyección automática de memorias en Claude Code usa un límite estimado de 600 tokens. La evidencia repetida solo se suprime para el mismo llamador, sesión, revisión de memoria y generación de contexto; las recuperaciones explícitas se pueden repetir siempre.

Revisiones, deshacer y reemplazo #

• remember: kind, source_ref e idempotency_key son opcionales. Las claves de reintento se limitan al proyecto y la categoría.
• reflect: expected_revision rechaza una actualización obsoleta. supersedes vincula explícitamente un reemplazo con otra memoria activa del mismo proyecto.
• memories: history lista las revisiones; undo necesita id, revision y expected_revision, y crea una revisión nueva. feedback acepta useful, irrelevant o incorrect.
• Las tarjetas de memoria muestran el historial de revisiones y los controles de restauración. Si hay un conflicto de revisión, las ediciones de contenido conservan un borrador sin guardar.
• Verificación de fuentes: las comprobaciones de sumas de verificación de archivos se ejecutan de forma asíncrona tras la recuperación; si un archivo relacionado cambió o falta, la memoria queda marcada para volver a revisarla.

Mantenimiento reversible #

El mantenimiento se ejecuta en local, en tareas acotadas, y se puede pausar, reanudar o reintentar en Ajustes → Memoria y copias de seguridad → Mantenimiento o con la acción maintenance de memories. Indexa pasajes, agrupa las copias exactas dentro de límites compatibles de proyecto, categoría, fuente y etiqueta, y propone para revisión los registros similares o potencialmente contradictorios. Las heurísticas de similitud y negación solo crean sugerencias de revisión; nunca reescriben ni reemplazan un dato por su cuenta. Con las decisiones de IA activadas, un juicio con suficiente confianza puede marcar una memoria como reemplazada, y cada uno de esos reemplazos aparece en una lista con las opciones Deshacer y Conservar.

Ingesta de sesiones #

Los archivos de transcripción gestionados de Claude Code y Codex entran en un lector JSONL acotado y reanudable, y el historial de OpenCode se normaliza hacia la misma ingesta. La ingesta de transcripciones nuevas crea evidencia de sesión en lugar de memorias duplicadas. Se excluyen el razonamiento interno y las inyecciones del sistema, y las transcripciones originales nunca se editan. Un cliente no compatible tiene que exponer su transcripción para que la captura automática funcione: MCP por sí solo no revela una conversación.

Migración y reversión #

• La primera apertura de la base de datos crea una instantánea consistente memory.db.pre-v2-*.bak si el almacén tiene datos y luego migra el esquema de forma aditiva; si algo falla, se revierten los cambios del esquema. Una actualización posterior del esquema crea su propia instantánea memory.db.pre-v3-*.bak.
• Después de actualizar, reinicia la Neural Interface y los procesos MCP conectados para que carguen el mismo motor.
• Para revertir la recuperación, define SYNABUN_MEMORY_ENGINE=legacy en el servidor y reinícialo. Así se conservan la base de datos v2 y todas las escrituras nuevas.
• Si el modelo de embedding aún no está en caché, instala sus recursos una sola vez después del build:

npm --prefix mcp-server run setup:embeddings

Perfiles de recuperación predefinidos #

Controla cuánto contexto entra en cada llamada a recall. Configúralo desde Ajustes → Memoria y copias de seguridad en la Neural Interface.

4 perfiles predefinidos #

6 controles de ajuste fino #

• Número de resultados: límite predeterminado por cada recall.
• Umbral de similitud: puntuación mínima de similitud del coseno.
• Intensidad del filtro de etiquetas: cuánto reordenan los resultados las coincidencias de etiquetas.
• Inclusión de fragmentos de sesión: incluye fragmentos de la transcripción de las conversaciones.
• Importancia mínima: descarta las memorias que no alcanzan un mínimo de importancia.
• Sesgo temporal: inclina la ponderación hacia lo más reciente frente a la similitud semántica.

Indicador de impacto #

El panel de ajustes muestra una estimación en vivo de los tokens por recuperación, las memorias alcanzables y el tamaño del contexto de sesión, para que administres tus ventanas de contexto con intención. El endpoint /api/recall-impact hace el cálculo (con avg_tags_len, avg_files_len y las estadísticas de sesión de cada proyecto).

Valores predeterminados del servidor #

Configura de forma global los parámetros básicos de recuperación con getRecallDefaults(). Todas las CLI siguen los valores predeterminados del servidor, salvo que la llamada a la herramienta los sobrescriba de forma explícita.

Sistema de categorías #

Las categorías son el eje principal de organización en SynaBun. Cada memoria pertenece a una sola categoría. Las categorías admiten una jerarquía de padre e hija, colores personalizados y descripciones que aparecen en las pistas del esquema de la herramienta recall.

Jerarquía #

Las categorías pueden tener una categoría padre, con lo que forman una estructura de árbol. Las categorías padre funcionan como ramas de organización de primer nivel. Las categorías hijas permiten un enrutamiento más preciso dentro de cada rama. Al enrutar una memoria, usa la categoría aplicable más específica.

myproject (parent)
├── myproject-bugs        # Bug fixes and known issues
├── myproject-arch        # Architecture decisions
├── myproject-api         # API design notes
└── myproject-deploy      # Deployment and infrastructure

Descripciones de enrutamiento #

El campo description de cada categoría se expone en el esquema de la herramienta MCP como pista para los asistentes de IA. Una buena descripción explica qué va aquí en términos de enrutamiento:

Good: "Bug fixes, known issues, and error resolutions for My Project"
Good: "Architecture decisions, system design patterns, and rationale"

Bad: "Bugs"
Bad: "My stuff"

Actualización dinámica del esquema #

Cuando creas, renombras o actualizas una categoría, SynaBun actualiza automáticamente el esquema de la herramienta MCP y envía notifications/tools/list_changed. Tu herramienta de IA vuelve a pedir la lista de herramientas y ve las descripciones de categoría actualizadas, sin reiniciar el servidor.

Categorías predeterminadas #

Las categorías las define el usuario. Una instalación nueva incluye de entrada unas pocas de las que dependen los hooks y las herramientas, y cada proyecto registrado recibe una categoría padre con cuatro hijas:

Embeddings locales #

SynaBun genera los embeddings de forma local con Transformers.js. No hay proveedor que elegir, ni clave de API, ni dependencia de la red después de la primera descarga del modelo.

• Un proceso auxiliar sin estado por servidor se encarga de la inferencia nativa con ONNX, con una cola de prioridad acotada y 256 embeddings de consultas y documentos en caché. Las solicitudes interactivas tienen prioridad sobre el trabajo en segundo plano.
• La inferencia de embeddings usa solo archivos en caché y nunca envía el texto de las memorias a un proveedor en la nube.
• Si el modelo de embeddings falta o falla, la recuperación por palabras clave sigue disponible y las memorias nuevas se guardan con la indexación semántica pendiente.

Decisiones de IA (Jev) #

SynaBun puede pedirle a Jev (TypeSafe System One) un juicio tipado allí donde antes una expresión regular o una constante de similitud hacía las veces de decisión semántica. La capa es opcional: cada punto de llamada conserva una heurística de respaldo que funciona, y Ajustes → Decisiones de IA lo controla todo en tiempo de ejecución.

Cómo funciona #

• Respuestas tipadas — un juicio es una elección con un nivel de confianza, una probabilidad de sí o no, o una puntuación. El código de SynaBun le aplica un umbral; el juicio nunca actúa por sí solo.
• Siempre hay un respaldo — sin clave, con la capa apagada, con un área desactivada, tras un tiempo de espera agotado o un límite de solicitudes, la llamada no devuelve nada y el área ejecuta su heurística local igual que antes.
• Configuración — la clave de API es TYPESAFE_API_KEY en ~/.synabun/.env. El interruptor general, el de cada área, los tiempos de espera y los umbrales están en Ajustes y se aplican en segundos, sin recompilar ni reiniciar.
• Interruptor de emergencia — SYNABUN_TYPESAFE=off detiene todas las llamadas salientes y prevalece sobre todo lo demás.
• Registro de juicios — una fila por llamada (área, modelo, latencia, tokens, qué hizo quien realizó la llamada con la respuesta), las 20.000 filas más recientes, con una vista previa sin credenciales.

Qué decide #

Consultivo por diseño #

• En el navegador y en el escritorio, Jev nunca controla nada: responde preguntas tipadas sobre una descripción minimizada de lo que está visible, y las herramientas muestran esa respuesta junto a su salida habitual.
• El texto escrito, los borradores, los valores de formularios, las cookies y el almacenamiento nunca se envían. El texto de páginas y pantallas se trata como datos no confiables y llega a Jev solo como estado, nunca dentro de una instrucción.
• Los valores que podrían ser credenciales se enmascaran antes de que el filtro de secretos los envíe.
• Las dos funciones que sí actuarían a partir de un juicio — la autorreparación segura de un browser_click fallido y la pulsación por intención de computer_ax — vienen desactivadas y permanecen bloqueadas hasta que un benchmark se supere con la configuración exacta en ejecución.

Asistente de SynaBun #

El Asistente es el orquestador central de la Neural Interface, y tiene en cuenta tus memorias. Piensa con el cerebro que elijas (Claude Code, Codex u OpenCode), recupera memorias de SynaBun en cada turno y resuelve por sí mismo las tareas pequeñas — operar tu Mac, navegar con el navegador de SynaBun, ediciones menores y comandos de shell, memoria, loops y programaciones —, mientras que delega el trabajo más pesado en los tres paneles laterales de IA como ejecuciones autónomas de agentes de trabajo que supervisa, dirige y resume.

El cerebro es el planificador: decide dónde se ejecuta cada solicitud que requiere actuar, en su propio modelo o en el modelo de un agente de trabajo, y SynaBun aplica el modo de ruta de la sesión y te pregunta qué modelo usar cuando el modo lo indica.

Cómo abrirlo #

La pestaña de terminal y el panel lateral montan el mismo componente, así que todos los controles, tarjetas y comandos de barra existen en ambos. Una sesión vive en un solo lugar a la vez, y Esc dentro del Asistente cancela un turno en curso.

Cerebros, modos y cuentas #

• Proveedor — Claude Code (Agent SDK), Codex (app-server) u OpenCode (un opencode serve aislado). Al cambiar de proveedor se inicia una sesión de servidor nueva en la misma pestaña.
• Modelo y esfuerzo (Claude, Codex) o agente (OpenCode), proyecto (el directorio de trabajo, que también define el proyecto de memoria), perfil de MCP y modo de permisos (preguntar antes de usar herramientas, o autónomo).
• Plan — un interruptor aparte para los tres proveedores. Mientras Plan está activo, los cambios de código quedan bloqueados y todo lo demás (comandos de shell, el navegador, el uso del equipo, otras herramientas) se ejecuta según el modo de aprobación de la sesión. Aprobar el plan termina el modo Plan.
• Cuentas (Claude y Codex) — elige, agrega, renombra o elimina una cuenta guardada. Las cuentas de Claude son directorios de configuración separados (~/.claude-accounts/<id> con CLAUDE_CONFIG_DIR); las de Codex usan ~/.codex-accounts.
• Modelos ocultos — desactiva cualquier modelo de cualquier proveedor en ⋯ → Models… o con /models. Un modelo oculto nunca llega a las tarjetas de ruta, al catálogo, a los menús de modelos ni al cerebro.

Memoria en cada turno #

• Cada turno del usuario que no sea trivial activa una recuperación con presupuesto de tokens, con el mismo motor que usan los hooks de Claude Code. Las memorias recuperadas aparecen como chips encima de la transcripción.
• Después de cada ejecución de agente de trabajo completada, se espera que el Asistente guarde el resultado con remember, usando el id de la ejecución como source_ref. Si no se guardó nada, el servidor almacena automáticamente una memoria agent-runs.
• Una sesión es una sola conversación continua, no un contexto nuevo por cada prompt. El id de sesión o de hilo del proveedor se conserva en el registro de la sesión, así que la conversación se reanuda después de un periodo de inactividad o de un reinicio del servidor.

Instrucciones tras aclarar la solicitud #

La mayoría de las solicitudes son lo bastante claras como para actuar. Cuando una es ambigua en aspectos importantes —dos lecturas plausibles con resultados distintos, un objetivo poco claro, un alcance destructivo o irreversible, gasto, o memorias que entran en conflicto con ella—, el cerebro pregunta primero, una sola vez, antes de enrutar.

• La tarjeta — Antes de empezar muestra de 1 a 3 preguntas (de 2 a 4 opciones cada una, con la recomendada primero) y, debajo, las suposiciones que hará el cerebro para todo lo que no pregunta. Elige una opción, escribe tu propia respuesta u omite las preguntas y sigue con las suposiciones.
• Espera — agent_clarify espera hasta 45 segundos de forma predeterminada. Después, el cerebro termina su turno y tus respuestas llegan más tarde como un evento del buzón; la tarjeta sigue abierta hasta que se responde.
• El trabajo dependiente espera — mientras haya preguntas abiertas, agent_route responde clarifying y agent_dispatch se rechaza con CLARIFICATION_PENDING. El trabajo que no depende de las respuestas sigue adelante.
• Las instrucciones — tu solicitud original, tus respuestas, las restricciones y las suposiciones forman las instrucciones de la sesión (brief_id). Cada agente de trabajo de esa solicitud las lee como una sección USER BRIEF; las respuestas y las restricciones prevalecen sobre el texto de la tarea cuando hay conflicto, y las suposiciones se marcan como no confirmadas.
• Ajustes — clarify.enabled y clarify.waitSeconds en ~/.synabun/data/assistant-config.json.

Comandos de barra #

/dispatch <claude|codex|opencode> [--model m] [--effort e] [--agent a] [--project p] [--mcp profile] [--account id] [--ask] <task>
/agents   /stop [runId|all]   /recall <query>   /remember <text>   /model   /project
/routes [always|unsure|never]   /computer [on|off]   /budget   /models
/new   /resume   /compact   /clear   /help

Herramientas agent_* #

El cerebro ve el grupo de herramientas agents solo cuando su sesión MCP tiene el rol de asistente. Los agentes de trabajo despachados nunca lo reciben, así que un agente de trabajo no puede despachar más agentes de trabajo. Las llamadas se hacen de una en una.

Enrutamiento de modelos #

El cerebro llama a agent_route una vez antes de cualquier tarea que requiere actuar, con una clase de tarea, un resumen de una línea, su confianza (0–1) y de 1 a 3 propuestas: direct (aquí, con su propio modelo) o dispatch (un proveedor y un modelo para un agente de trabajo). El selector de modo de ruta en la barra de herramientas del Asistente decide qué pasa después.

Modos de ruta #

• Las tarjetas de ruta esperan hasta 45 segundos dentro de la llamada a la herramienta. Después, el cerebro termina su turno y tu elección posterior llega como un evento del buzón.
• Si eliges aquí con otro modelo del proveedor del cerebro, se ejecuta una continuación de un turno con ese modelo en la misma conversación; el turno siguiente vuelve al modelo de la sesión.
• Los modelos se validan contra el catálogo. Las ejecuciones fallidas o bloqueadas incluyen una escalada de un nivel, que se muestra en la tarjeta de la ejecución como Escalar a ‹modelo›. Con las decisiones de IA activadas, un fallo transitorio (tiempo de espera agotado, límite de solicitudes, caída del servicio) ofrece en su lugar un reintento con el mismo modelo, y una ejecución que necesita acceso o tu intervención no ofrece escalada.
• Los ajustes están en ~/.synabun/data/assistant-config.json, dentro de routing, y en el editor de Rutas de modelos (⋯ → Rutas de modelos…, o /routes).

Clases de tarea #

chat, quick, code, complex, review, research, browser, computer, automation, design, image_gen y video_gen. Tres de ellas tienen reglas de capacidad:

• Creación de imágenes (image_gen) y Creación de video (video_gen) siempre se ejecutan en un agente de trabajo cuyo modelo genera el medio por sí mismo. Si no hay un modelo capaz, agent_route rechaza la solicitud con no_capable_model. SynaBun copia los archivos generados en ~/.synabun/data/media/<runId>/ y los muestra en la tarjeta de la ejecución.
• Diseño (design) siempre se ejecuta en un solo agente de trabajo cuyo modelo puede ver. El agente de trabajo recibe las reglas de diseño de SynaBun —que puedes reemplazar en ~/.synabun/data/playbooks/design.md— y el bloque de la Guía de estilo del proyecto, y toma capturas de pantalla a 375 / 768 / 1440 px en el navegador de SynaBun.
• Una instalación estándar no tiene ningún modelo que genere video: Codex y Claude no pueden. La fila Creación de video en Rutas de modelos lo indica hasta que se conecte un proveedor cuyos modelos generen video.

La compuerta de ruta #

Cada turno del cerebro empieza sin ruta. Hasta que el cerebro llama a agent_route en ese turno, toda herramienta fuera de un pequeño conjunto exento —las herramientas de memoria, las herramientas agent_*, las herramientas de preguntas, profile, image_staged, computer_status, ToolSearch y TodoWrite— se rechaza antes de ejecutarse, con un error de herramienta que le indica al modelo qué hacer a continuación. Tras 8 rechazos en un mismo turno, el turno se aborta. Los agentes de trabajo despachados, los paneles laterales de Claude Code / Codex / OpenCode y las sesiones de CLI no tienen compuerta.

Agentes de trabajo y despacho #

Pídelo en lenguaje natural («escribe la documentación de los hooks con Codex y luego haz que Claude la revise») o usa /dispatch. Cada despacho se convierte en una ejecución de tarea: una conversación con el proveedor que ejecuta la tarea, termina con un bloque ## Result (status, summary, changes, follow_ups, una question opcional y media para las ejecuciones de imagen, video y diseño) y luego se mantiene activa para seguimientos hasta que el Asistente la completa o se cumple el tiempo de inactividad.

La ejecución se acopla como una pestaña de automatización en el panel lateral correspondiente, sin robar el foco. El dock de agentes, debajo de la transcripción, lista las ejecuciones con proveedor, modelo, cuenta, estado, tiempo transcurrido y costo, además de Enfocar / Detener / Leer y Detener todo.

// Dispatch a worker on an approved route
agent_dispatch({
  assistant_session_id: "<assistant-session-id>",
  route_id: "<route-id>",
  task: "Write reference docs for the hooks in docs/hooks.md. End with a ## Result block.",
  cwd: "/Users/me/my-project",
  capability: "workspace",
  max_minutes: 30,
  budget_usd: 3,
  title: "Hooks docs"
})

// Block until it goes idle, then read the parsed result
agent_wait({ run_id: "<run-id>", until: "idle", timeout_seconds: 50 })
agent_read({ run_id: "<run-id>", format: "result" })

Parámetros de agent_dispatch #

Controles y límites #

Valores predeterminados, editables en ~/.synabun/data/assistant-config.json dentro de limits y leídos en vivo:

• Concurrencia por proveedor — Claude 3, Codex 4 en total (2 por cuenta), OpenCode 3
• Por sesión — 6 ejecuciones activas y 20 en cola, fan-out de 6
• Tiempo — límite de ejecución de 45 minutos, de inactividad de 20 minutos, de espera de permisos de 10 minutos y de espera de preguntas de 30 minutos
• Seguimientos — 6 turnos de seguimiento por ejecución

Las ejecuciones que leen el navegador o contenido no confiable deben ser read-only o workspace, salvo que lleven la etiqueta user-authorized-full.

Buzón y resultados #

Los eventos del ciclo de vida de las ejecuciones (resultado, necesita información, solicitud de permiso, fallo, bloqueo, aviso de presupuesto, tope máximo alcanzado) se agrupan y se entregan al cerebro en un solo turno [SynaBun Mailbox] cuando está inactivo, y se muestran como chips en la transcripción. agent_wait y agent_status le dan al cerebro vistas reducidas de las ejecuciones (estado por turno y un resumen breve); agent_read con format: "text" devuelve el texto completo.

Política del navegador #

El cerebro y los agentes de trabajo que despacha solo ven páginas, tanto de la web pública como de localhost, a través de las herramientas browser_* de SynaBun, que abren el navegador configurado en SynaBun. No ejecutan su propio código de Playwright, Puppeteer o Selenium, no lanzan binarios de navegadores, no toman capturas en modo headless ni usan herramientas propias de búsqueda web o de fetch. Las comprobaciones visuales pasan por browser_screenshot y los errores de página por browser_console. Cuando el navegador de SynaBun no puede hacer algo, se detienen y lo informan en vez de cambiar de herramienta. Ejecutar la suite de pruebas automatizadas del propio proyecto sigue estando permitido.

Presupuesto #

⋯ → Budget… (también /budget, o un clic en el chip de gasto) define los topes de dinero. Se guardan en assistant-config.json y se aplican sin reiniciar.

Cada importe está entre $0,10 y $1.000, con predeterminado ≤ máximo por ejecución ≤ tope máximo, aviso < tope máximo y tope del cerebro ≤ tope máximo. Si un guardado incumple estas reglas, se rechaza.

Aplicación de los topes #

• Una ejecución nueva recibe, como mucho, lo que deja el tope máximo tras descontar el gasto de la sesión y las reservas de las ejecuciones activas. Si no queda nada, el despacho se rechaza con BUDGET_EXCEEDED.
• Una ejecución que alcanza su propio tope se detiene, y cualquier seguimiento que se le envíe se rechaza.
• Al llegar al tope máximo de sesión, se detienen todas las ejecuciones activas, en cola y retenidas de la sesión, se rechazan los despachos y seguimientos nuevos, y los turnos del cerebro se rechazan hasta que se suba el tope.
• Los topes bloquean los modelos sin precio conocido: esos modelos no se lanzan (BUDGET_UNPRICED).

Cómo se mide cada proveedor #

• Claude informa su propio costo. El tope de la ejecución se pasa a la CLI al iniciarla y se comprueba entre llamadas al modelo, así que una llamada puede superarlo.
• OpenCode informa el costo por cada mensaje del asistente. La ejecución se detiene en el primer paso que supera su tope, así que un paso puede superarlo.
• Codex solo informa tokens, valorados a precio de lista. Los topes se comprueban después de cada turno, así que un turno puede superarlos.
• Ningún tope puede detener una llamada al modelo que ya está en curso. El cerebro se comprueba antes de cada turno; un turno en curso termina.

Uso de tokens #

El Asistente cuenta cada token de una sesión a partir de lo que informa cada proveedor y muestra el total acumulado en un indicador sobre el cuadro de mensaje: la sesión completa, con entrada y salida por separado y los dólares a precio de lista. Los topes en dólares de Presupuesto son aparte: ellos miden dinero, esto cuenta tokens.

Sesiones, tareas y ejecuciones #

• Una tarea es un mensaje tuyo más todo lo que desencadena: los turnos del cerebro, las ejecuciones que despacha, los subagentes de esas ejecuciones, las llamadas a modelos auxiliares y las evaluaciones de decisiones de IA.
• El total de la sesión es la suma de sus tareas. Un prompt de seguimiento inicia una tarea nueva en cero y se suma a la sesión; nunca reinicia la cifra principal.
• El total se calcula a partir de un registro de solo anexado en ~/.synabun/data/assistant-usage/<sessionId>.jsonl, así que al recargar la página o reiniciar el servidor se ve el mismo número.

Clases de tokens #

Cada conteo se divide en cinco clases que nunca se solapan: entrada (sin caché), escritura en caché, lectura de caché, salida (visible) y razonamiento. Las cifras de cada proveedor se convierten a estas clases, y cada objeto tokens incluye además inputTotal (entrada + escritura en caché + lectura de caché), outputTotal (salida + razonamiento) y total.

Estados #

«Exacto» significa igual a lo que informa cada proveedor; no es una medición independiente. Los dólares van a precios de lista de la API, y cada fila de modelo indica cómo se conoce su cifra: informada por la CLI, equivalente a precio de lista, gratis o sin precio de lista.

Cómo consultarlo #

// Session totals plus the current task
agent_usage({ assistant_session_id: "<assistant-session-id>" })

// Every task of the session, narrowed to one run
agent_usage({ assistant_session_id: "<assistant-session-id>", task: "all", run_id: "<run-id>" })

Los mismos datos están disponibles en GET /api/assistant/sessions/:id/usage. agent_usage solo lee, así que el cerebro puede llamarla en un turno que todavía no tiene ruta.

Uso del equipo #

En macOS, el Asistente puede manejar tu Mac como lo haría una persona: toma capturas de pantalla, mueve el ratón y hace clic, escribe, pulsa atajos de teclado, abre aplicaciones y las pone en primer plano, y lee el árbol de accesibilidad de una aplicación. Es totalmente autónomo (no pide aprobación para cada acción) y lo limitan unas protecciones que siempre están activas y unos controles de parada que puedes usar en cualquier momento.

Solo reciben estas herramientas el propio cerebro del Asistente y las ejecuciones de agentes de trabajo que este lanza con uses_computer: true. El uso del equipo requiere macOS 14 o posterior; las demás plataformas devuelven unsupported.

Configuración inicial #

1. Compila el programa auxiliar nativo. SynaBun compila un pequeño programa auxiliar nativo en Swift con las Xcode Command Line Tools. Si falta swiftc, la bandeja de configuración te ofrece instalarlo (xcode-select --install).
2. Concede los permisos. macOS asocia Grabación de pantalla y Accesibilidad a la aplicación que inició SynaBun, que suele ser tu terminal. Activa esa aplicación en Ajustes del Sistema y vuelve a comprobar.
3. Listo. Las sesiones nuevas del Asistente empiezan con el interruptor Equipo activado. Desactívalo en cada sesión con el interruptor o con /computer off.

Herramientas #

// Read the frontmost app's controls, then press one by ref
computer_ax({ action: "snapshot" })
computer_ax({ action: "press", snapshot_id: "s7", ref: "e12" })

// Click a coordinate of the latest screenshot
computer({ action: "left_click", coordinate: [640, 400] })

Las coordenadas son píxeles de la última captura de pantalla. Una acción por coordenadas necesita evidencia reciente: una captura tomada después de la última acción, hace menos de dos minutos y sin que haya habido entrada del usuario ni cambios de pantalla desde entonces. De lo contrario, se rechaza con STALE_SCREENSHOT y se adjunta una captura nueva.

Protecciones #

Controles de parada #

Detén al agente con el botón rojo Detener · Esc, con Esc (funciona en todo el sistema mientras un agente controla el escritorio), llevando el puntero de golpe a la esquina superior izquierda de la pantalla principal o con POST /api/desktop/stop. Al detenerlo se cancela la acción, se sueltan las teclas mantenidas, se interrumpe el turno del Asistente y se detienen los agentes de trabajo que usan el equipo. Después, el uso del equipo queda desactivado hasta que pulses Reanudar: los agentes no pueden reanudarse por sí mismos.

Vinculación con WhatsApp #

Chatea con el Asistente de SynaBun desde WhatsApp. Escribes en un chat de WhatsApp en tu teléfono; el mensaje llega al Asistente que se ejecuta en tu equipo, y sus respuestas, preguntas y aprobaciones vuelven como mensajes de WhatsApp. Todo se configura y se controla en Ajustes → Mensajes → WhatsApp.

SynaBun se vincula con WhatsApp igual que WhatsApp Web, como un dispositivo vinculado de una cuenta, mediante Baileys (un cliente no oficial). No hace falta una cuenta de desarrollador de Meta, ni alquilar un número de teléfono, ni un webhook público, y no hay ningún servidor de SynaBun de por medio. Tu equipo tiene que estar encendido y SynaBun en ejecución.

Dos formas de chatear #

En el modo Escríbete a ti mismo, SynaBun lee solo tu propio chat «Escríbete a ti mismo»; ignora todos los demás chats, grupos y contactos. Con un segundo número, quien envíe primero el código de vinculación de un solo uso se convierte en el propietario, y nunca se le responde a nadie más.

Niveles de permiso #

Ajustes → Mensajes → WhatsApp → Seguridad decide qué puede hacer el Asistente a partir de un mensaje enviado desde el teléfono. El nivel se aplica en tu equipo, a través del runtime del Asistente, su sistema de asignación de tareas y los hooks del cerebro, no en el teléfono.

• Preguntar y Autónomo necesitan un cerebro Claude. Con un cerebro Codex u OpenCode, la conversación se ejecuta en Solo lectura, diga lo que diga el nivel.
• El uso del equipo desde WhatsApp está desactivado salvo que actives su interruptor en Ajustes, desde el equipo. Ningún mensaje del teléfono puede activarlo.
• En todos los niveles se rechazan los comandos y las rutas que acceden a las credenciales, la propia sesión de WhatsApp, puntos de persistencia o perfiles del navegador. Esta lista de bloqueo es un freno, no un sandbox.
• Pausar ahora hace que SynaBun deje de actuar de inmediato ante los mensajes de WhatsApp; el teléfono no puede deshacer una pausa hecha desde el equipo.

Comandos #

Los niveles, los modelos y los ajustes nunca se cambian desde el teléfono. Se leen texto e imágenes (4 imágenes por mensaje, de 5 MB cada una); la voz, el video, los documentos y los stickers aún no se leen. Los mensajes entrantes están limitados a 20 por minuto y 300 por día.

Neural Interface #

La Neural Interface es un mapa de memorias 3D de tu almacén en localhost:3344 y la sala de control de todo lo demás: categorías, hooks, skills, registro de MCP, los paneles laterales y el Asistente de SynaBun.

Funciones principales #

• Mapa de memorias 3D — cada memoria es un punto. Las categorías son islas agrupadas en continentes según su categoría padre y, dentro de cada isla, las posiciones salen de un UMAP de los embeddings de las memorias, así que las memorias similares quedan una junto a otra. Las memorias más nuevas flotan más alto, y más brillo significa más reciente.
• Rótulos que siguen el zoom — continentes, luego islas, luego regiones con nombre y luego títulos de memorias. Haz clic en una memoria para abrirla y ver líneas hacia sus memorias más cercanas en cualquier parte del mapa.
• Alternativa 2D — una vista 2D de las mismas memorias para workflows centrados en el rendimiento.
• Búsqueda semántica — pulsa / para ir a la barra de búsqueda. Los resultados se iluminan y todo lo demás se atenúa.
• Inspector de memorias — abre cualquier memoria para ver su contenido completo, metadatos, archivos relacionados y etiquetas. Las tarjetas de memoria muestran el historial de revisiones y los controles de restauración.
• Barra lateral de categorías — filtrado, edición de la jerarquía y logos personalizados para las categorías padre.
• Panel de Papelera — consulta, restaura o elimina definitivamente las memorias de la papelera sin salir del navegador.
• Panel de sincronización — detecta memorias desactualizadas cuyos archivos de origen cambiaron (comparación de hashes SHA-256).
• Copias de seguridad y restauración — exporta e importa instantáneas verificadas de la base de datos.
• Exportación de categorías — descarga todas las memorias de una categoría en Markdown.
• OpenClaw Bridge — una integración de solo lectura que superpone en el mapa las memorias del workspace de OpenClaw.
• Recorrido por el workspace — el botón ? de la barra de título abre un recorrido dibujado a mano por el workspace: una bienvenida y 14 pasos en seis capítulos, en inglés y portugués de Brasil.

Funciones de IDE #

• Asistente de SynaBun — el orquestador central, como pestaña de terminal o en su propio panel lateral. Consulta Asistente de SynaBun.
• Paneles laterales para Claude Code, Codex y OpenCode — tres paneles de chat dedicados con cancelación por agente, dock de actividad de herramientas, tarjetas de permisos, cajón de TODO, indicador de contexto (con activación de contexto de 1M), menú de sesiones, modal de nueva sesión (selector de proyecto + branch) y Multi-CLI Resume. Consulta Paneles laterales.
• Estudio de Skills — explora, crea, edita, importa y exporta skills y agentes. Soporte para varios archivos, carga de iconos, validación y gestión de instalación y desinstalación. /synabun y /leonardo funcionan tanto en Claude Code como en Codex; /synabun changelog es un botón de acción rápida dentro del panel lateral de OpenCode.
• Panel de Guía de estilo — edita la marca y el sistema de diseño de un proyecto con vistas previas en claro y oscuro, importaciones, historial y propuestas de los agentes. Consulta Guía de estilo.
• Estudio de automatizaciones — editor visual de plantillas para loops y agentes con carpetas plegables creadas por el usuario (arrastrar y soltar, iconos, colores), valores de lanzamiento predeterminados por plantilla (CLI / modelo / esfuerzo de razonamiento / perfil de MCP) y compatibilidad de primer nivel para las 4 CLI (Claude Code, Codex, Gemini, OpenCode). Consulta Estudio de automatizaciones.
• Gestión de MCP — formulario universal para agregar servidores con pegado inteligente (detecta automáticamente 5 formatos de configuración), sincronización multiplataforma entre las 4 CLI, bóveda centralizada de variables de entorno con enmascaramiento de valores sensibles, registro automático de perfiles e instalación desde GitHub con un clic. Consulta Gestión de MCP.
• Terminal con varias pestañas — terminal basada en PTY sobre una única interfaz de xterm.js con soporte de color ANSI (256 colores + truecolor), seguimiento del branch de git, historial de comandos, bloqueo de sesión, vista dividida, sugerencias para Windows ConPTY y comandos unificados de actualización de CLI mediante npm install -g para las 4 CLI.
• Explorador de archivos — árbol de archivos del proyecto con colores de carpeta personalizados, opciones de orden y secciones plegables.
• Lienzo de whiteboard — superficie de dibujo compartida para que la IA y las personas colaboren. Trazo libre, texto, formas, flechas, imágenes y secciones de wireframe, con deshacer y rehacer.
• Tarjetas de memoria flotantes — abre memorias como tarjetas que puedes arrastrar y fijar. Modo compacto (minitarjetas de 220×120px), posición persistente y capturas de pantalla del workspace.
• Widget de costos — seguimiento del costo de la API de Claude con desglose por sesión y costos según el modelo. Plegable y acoplable.
• Panel de estadísticas — cantidad de memorias por categoría o proyecto, distribución por importancia, distribución por antigüedad y comprobaciones de estado (memorias desactualizadas, categorías huérfanas).

Ajustes y personalización #

• Ajustes — once páginas por tarea: Conexiones de IA, Memoria y copias de seguridad, Decisiones de la IA, Proyectos, Navegador, Herramientas conectadas, Acceso a herramientas, Automatizaciones, Mensajes, Notificaciones y Apariencia. Un campo de búsqueda en la parte superior de la barra lateral de Ajustes (Cmd+F / Ctrl+F) encuentra cualquier página, sección o control.
• Idiomas — inglés y portugués de Brasil, que se eligen en Ajustes → Apariencia → Idioma.
• Skins personalizados — sube temas CSS propios para toda la interfaz.
• Atajos de teclado — acciones asignables (mostrar u ocultar paneles, abrir herramientas, navegación, búsqueda) con importación y exportación de configuraciones de atajos.
• Workspaces — guarda y restaura la disposición de los paneles, el estado de la barra lateral y las posiciones de las terminales. Disposiciones predefinidas por variante (2D/3D).
• Iconos de archivo personalizados — iconos por extensión o por nombre de archivo, con soporte para PNG y SVG.
• Acceso de invitados — genera enlaces de invitación de 24 horas con control de permisos por función. Soporte de proxy con túnel de Cloudflare para el acceso remoto.

API REST #

La Neural Interface ejecuta un servidor Express con 500+ endpoints REST. La interfaz, los hooks y las integraciones externas lo usan:

# List all memories
GET http://localhost:3344/api/memories

# Hybrid search
POST http://localhost:3344/api/search
{ "query": "auth bug", "limit": 5 }

# Get, update, or trash a specific memory
GET    http://localhost:3344/api/memory/:id
PATCH  http://localhost:3344/api/memory/:id
DELETE http://localhost:3344/api/memory/:id

# Revision history and undo
GET  http://localhost:3344/api/memory/:id/history
POST http://localhost:3344/api/memory/:id/undo

# Trash
GET  http://localhost:3344/api/trash
POST http://localhost:3344/api/trash/:id/restore

# Categories and stats
GET http://localhost:3344/api/categories
GET http://localhost:3344/api/stats

# Download a verified full system backup (ZIP)
GET http://localhost:3344/api/system/backup

El mismo servidor monta el endpoint de MCP sobre HTTP en /mcp — consulta Soporte multicliente.

Paneles laterales (Claude, Codex, OpenCode) #

SynaBun incluye tres paneles laterales de chat dedicados que se acoplan al costado de tu editor y se comunican con el mismo backend de memoria. Comparten un lenguaje visual y un conjunto de funciones comunes, y a la vez exponen las capacidades nativas de cada CLI.

Matriz de funciones #

Renderizado de código #

• Resaltado de sintaxis en los bloques de código delimitados.
• Rutas de archivo convertidas en enlaces: path/to/file.ts:42 se vuelve un enlace que te lleva al explorador de archivos con un clic.
• Etiquetas de lenguaje en el encabezado del bloque de código, además de un botón de copiar que solo aparece al pasar el cursor.
• Streaming limitado a 30 fps para que los flujos largos de tokens se vean fluidos sin saturar el DOM.
• Bloques de razonamiento en tiempo real, que se renderizan de forma progresiva a medida que el modelo transmite su razonamiento (en las CLI que lo emiten).

Chat temporal (Claude Code) #

El estado vacío de una pestaña nueva de Claude Code tiene un botón Chat temporal. Púlsalo antes del primer mensaje para tener una conversación en la que no se guarda nada y la memoria se puede seguir leyendo.

• No se guarda nada: ni transcripción en disco, ni pestaña guardada, ni entrada en la lista de sesiones. Termina cuando se cierra la pestaña, se recarga la página o se reinicia el servidor.
• La memoria se puede leer, pero no escribir: recall y las demás herramientas de lectura funcionan, y las memorias relacionadas se siguen añadiendo a tu prompt. remember, reflect, forget, restore y sync no están en la sesión.
• Los hooks se hacen a un lado: los hooks de SynaBun no registran nada, nunca retienen una parada para guardar una memoria, no capturan nada durante la compactación y no almacenan ningún plan.
• Las herramientas que actúan fuera de SynaBun (el navegador, git, Discord, etc.) funcionan como siempre, y lo que crean se queda donde se creó.

Paneles de subagentes (OpenCode) #

• Cada subagente de la sesión del panel principal tiene su propia píldora, en el orden en que se iniciaron, y su propio panel con su transcripción, cuadro de mensaje, cola y tarjetas de permisos y de preguntas.
• La píldora muestra un punto mientras el subagente está en ejecución, una marca ámbar mientras espera un permiso o una respuesta, una marca de verificación verde cuando termina y una marca roja cuando falla.
• Nada se abre solo: un subagente nuevo es una píldora y una notificación. Al hacer clic en una píldora, el panel de ese subagente aparece donde estaba el panel principal.
• Minimizar oculta el panel y conserva la píldora; Cerrar quita ambos. Ninguna de las dos acciones elimina ni detiene la sesión del subagente.

Atajos de teclado #

• Esc: cancela el turno actual (funciona en todo el panel, no solo cuando el campo de entrada tiene el foco).
• Ctrl/Cmd+Shift+A: muestra u oculta el dock de actividad de herramientas de OpenCode.
• Enter: envía desde el modal de nueva sesión; Esc lo omite.

Estudio de automatizaciones #

Un editor visual de plantillas para loops autónomos y agentes. Créalas una vez y lánzalas en cualquier CLI.

Carpetas plegables #

• Organiza tus plantillas personalizadas en carpetas creadas por ti; las predefinidas se quedan en categorías fijas (Social / Productivity / Monitoring).
• Arrastra plantillas al encabezado de una carpeta para moverlas; arrastra los encabezados de las carpetas para reordenarlas.
• Cada carpeta tiene su icono (un conjunto de 13 iconos más los de plataformas sociales), su color (paleta de 8 muestras), su nombre y su estado plegado.
• Menús contextuales en las plantillas (Move to folder ▸ / Delete) y en los encabezados de las carpetas (Rename/Recolor, Collapse/Expand, Delete).
• El estado plegado se conserva por dispositivo en localStorage; el indicador collapsed del servidor es el valor predeterminado de la primera ejecución.
• Las copias de seguridad y la restauración cubren todo mediante loop-folders.json; la exportación e importación pasa a version: 2 con un array de carpetas explícito.

Valores de lanzamiento predeterminados por plantilla #

• Guarda en cada plantilla la CLI (Claude Code, Codex, Gemini, OpenCode), el modelo, el nivel de razonamiento (solo Claude) y el perfil MCP (Codex / Gemini / OpenCode).
• El modal de configuración de lanzamiento se abre ya rellenado con las opciones guardadas en la plantilla y permite cambiarlas antes de iniciar el loop.
• La tarjeta de runtime usa elementos <select> nativos para que los nombres largos de perfiles MCP (p. ej., "memory-full — 40 tools") no se corten.
• Las plantillas antiguas que no tienen estos campos muestran valores predeterminados razonables (Claude Code / modelo predeterminado / razonamiento desactivado / MCP "full").

Compatibilidad con 4 CLI #

• El modo loop funciona en las cuatro CLI. cat <taskfile> | opencode run --model <m> es el equivalente no interactivo de codex exec para OpenCode.
• El modo agente es exclusivo de Claude (integración profunda con subagentes). Cuando se selecciona una CLI que no es Claude, el modo agente se desactiva automáticamente y la interfaz vuelve al modo loop.
• Los chips de razonamiento y esfuerzo se ocultan en OpenCode (opencode run no tiene un flag de razonamiento). La sección de perfil MCP se muestra automáticamente en las CLI que no son Claude.
• Una plantilla puede añadir a su prompt la Guía de estilo del proyecto seleccionado.

Gestión de MCP #

Una sola pantalla para instalar, configurar y sincronizar todos los servidores MCP que usas, en todas las CLI.

Formulario universal para añadir (pegado inteligente) #

• Detecta automáticamente 5 formatos de configuración: JSON de stdio, URL HTTP, TOML de OpenCode, el comando mcp add de Claude y JSON simple.
• Argumentos en forma de etiquetas, filas para variables de entorno y casillas de plataforma con detección automática.
• Los valores sensibles (tokens, claves de API) se ocultan en el formulario y se guardan en la bóveda de variables de entorno.

Sincronización multiplataforma #

Una sola entrada de servidor MCP se sincroniza con Claude Code, Codex, Gemini y OpenCode con un clic. Endpoints REST:

# List platforms SynaBun can sync to
GET http://localhost:3344/api/mcp/platforms

# Sync the selected server to every targeted platform
POST http://localhost:3344/api/mcp/sync
{ "serverId": "...", "platforms": ["claude-code", "codex", "gemini", "opencode"] }

# Remove the sync (per platform)
DELETE http://localhost:3344/api/mcp/sync?serverId=...&platform=codex

Bóveda de variables de entorno y registro automático en perfiles #

• Los secretos se guardan una sola vez en la bóveda de variables de entorno centralizada y los servidores MCP los referencian por nombre.
• Las variables sensibles se ocultan en el formulario de alta y en las pantallas de ajustes.
• Los servidores recién añadidos se registran automáticamente en los perfiles, así puedes activarlos o desactivarlos por grupo con la herramienta MCP profile.
• Instalación simplificada desde GitHub: pega la URL de un repositorio y SynaBun clona, compila y registra el servidor.
• La estructura de carpetas de data/mcp/ da a los servidores instalados por el usuario una organización predecible.

Guía de estilo #

Cada proyecto puede tener una Guía de estilo: colores en claro y oscuro con paletas de 11 pasos, tipografía, espaciado, formas, movimiento, iconos, archivos de logo, criterios visuales para las imágenes, especificaciones de componentes y reglas. Se mantiene en un solo lugar y se entrega a cada agente que trabaja en el proyecto. Al guardarla se escriben los archivos que los agentes y las herramientas de build ya leen:

El panel #

• Abre Guía de estilo desde el menú Skills de Neural Interface y selecciona un proyecto registrado.
• El panel edita las catorce secciones con guardado automático, vistas previas de componentes en claro y oscuro, diffs de importación, exportaciones, historial y propuestas de agentes.
• Ocho ajustes predefinidos: SynaBun Default, Minimal SaaS, Dark Developer, Editorial, Playful, Enterprise, Fintech Precision y Warm Organic.
• Importaciones: desde un DESIGN.md, un archivo de tokens de diseño del W3C, propiedades personalizadas de CSS (incluido un @theme de Tailwind v4 o variables al estilo de shadcn), un tema de Tailwind en JSON, el propio código del proyecto o la colección de DESIGN.md de la comunidad. La vista previa devuelve la guía resultante y un diff sin guardar nada.
• Historial: se conserva cada revisión guardada, de la más reciente a la más antigua, hasta un máximo de 30. Al restaurar una revisión, su diseño vuelve como una revisión nueva.

La herramienta style_guide #

Pasa projectPath: la raíz del proyecto o cualquier ruta dentro de él. El valor por defecto es el directorio de trabajo del servidor, que normalmente no es el proyecto de quien hace la llamada.

// The compact brand block
style_guide({ action: "summary", projectPath: "/Users/me/my-project" })

// Tokens as CSS custom properties
style_guide({ action: "tokens", projectPath: "/Users/me/my-project", format: "css" })

// Check contrast for two colors or aliases
style_guide({ action: "contrast", projectPath: "/Users/me/my-project", fg: "{semantic.text}", bg: "{primary.500}" })

// Propose a change for the user to review
style_guide({
  action: "propose",
  projectPath: "/Users/me/my-project",
  changes: { colors: { status: { danger: "#dc2626" } } },
  reason: "The current danger red fails AA on the dark surface"
})

Qué reciben los agentes #

• Los agentes de trabajo que el Asistente despacha para tareas de código, ingeniería compleja, diseño, imagen y video encuentran un bloque STYLE GUIDE en sus instrucciones de tarea: de 300 a 500 tokens para una guía completa, nunca más de 600.
• Las reglas de SynaBun indican a cada herramienta conectada que lea DESIGN.md antes de cualquier trabajo de interfaz, diseño, textos o creatividad, y el Estudio de automatizaciones puede añadir la guía del proyecto seleccionado al prompt de una plantilla.
• Los agentes nunca escriben la guía. Lo único que pueden escribir es una propuesta (un JSON merge patch y un motivo), y nada cambia hasta que la aceptas en el panel. Puede haber como máximo 200 propuestas pendientes.
• Por defecto, el contraste se comprueba según WCAG 2.2 AA: 4,5:1 para texto, 3:1 para texto grande e interfaz.
• La herramienta style_guide está en el grupo styleguide, que forma parte de los perfiles predefinidos core, standard, codex-browser, browser y full.

Hooks de Claude Code #

SynaBun incluye 10 scripts de hooks para Claude Code, registrados como 11 handlers en 9 eventos del ciclo de vida. Recuperan contexto al inicio de la sesión, preparan a los subagentes con contexto de memoria antes de lanzarlos y exigen que se guarden memorias cuando el trabajo termina.

Instalar los hooks #

Instala los hooks desde la Neural Interface: Ajustes → Proyectos → Workspaces → Activar para un solo proyecto, o Ajustes → Automatizaciones → Comportamiento de las automatizaciones → Hooks para todos los proyectos. Esto escribe la configuración de los hooks en el .claude/settings.json correspondiente.

Hook SessionStart #

Se ejecuta cuando Claude Code inicia una sesión nueva. Inyecta el árbol completo de categorías, las reglas de detección de proyectos, 5 directivas obligatorias (recuperación al iniciar la sesión, memorización automática, recuperación antes de tomar decisiones, guardado automático al compactar y aprendizaje sobre el usuario) y el contexto de recuperación tras una compactación. Añade una línea cuando el directorio de trabajo tiene un DESIGN.md. Todo esto se antepone a la sesión antes de que el usuario escriba nada.

Hook UserPromptSubmit #

Intercepta cada mensaje del usuario antes de que llegue a Claude. Analiza el prompt con un sistema de disparadores de varios niveles (ediciones de una tarea anterior que aún no se guardaron en memoria, frases que piden recuperar conversaciones, niveles de recuperación must / should / consider, detección de idiomas distintos del inglés y un aviso discreto de aprendizaje sobre el usuario tras un número configurable de interacciones) e inyecta avisos adaptados al contexto. La inyección automática de memorias no pasa de 3 memorias y 600 tokens. Con las decisiones de IA activadas, una urgencia evaluada por el modelo sustituye a los niveles basados en regex.

Hook PreCompact #

Se dispara antes de que se compacte el contexto. Captura la ruta de la transcripción de la sesión y sus metadatos, y activa una marca pending-compact que el hook Stop se encargará de hacer cumplir, lo que garantiza que la sesión compactada quede indexada en la memoria antes de que Claude pueda continuar.

Hook Stop #

Se ejecuta después de que Claude termina una respuesta. Hace cumplir dos requisitos: (1) si existe una marca pending-compact, bloquea a Claude hasta que la sesión se indexe mediante remember con la categoría "conversations", y (2) si se hicieron ediciones que aún no se han guardado en memoria, lo bloquea hasta que el trabajo quede memorizado. Hay un máximo de 3 reintentos por marca para evitar bucles infinitos. El hook Stop también impulsa las iteraciones del loop autónomo.

Hook PostToolUse (post-remember) #

Coincide con Edit, Write, NotebookEdit y con las herramientas remember, reflect y recall de SynaBun. Lleva la cuenta de las ediciones y borra las marcas de cumplimiento cuando se guardan memorias: la categoría conversations borra la marca de compactación y las demás categorías reinician el contador de remember. Un recall explícito que termina bien registra un comprobante que lee el control de subagentes.

Hook PreToolUse (pre-websearch) #

Intercepta las llamadas a las herramientas WebSearch y WebFetch. Comprueba si hay una sesión de navegador de SynaBun activa o si el loop actual usa el navegador; en ese caso, bloquea la herramienta e inyecta un mensaje que le indica a Claude que use las herramientas de navegador de SynaBun. Si la Neural Interface no responde, deja pasar la llamada sin errores.

Hooks PreToolUse y PostToolBatch (pre-task) #

Recuperación antes de los subagentes. Antes de redactar prompts de Task o Agent, el orquestador debe completar un recall centrado en la tarea e incorporar al prompt las rutas exactas, las correcciones previas y las restricciones. Como red de seguridad, el primer envío sin contexto lanza una única solicitud de recuperación de hasta 5 memorias y 1.200 tokens; si hay memoria relevante, se bloquea ese primer lote una sola vez y se devuelve el resumen, y los envíos en paralelo comparten el resultado. Después, PostToolBatch libera los envíos denegados para que el reintento sea inmediato.

Hook PostToolUse (post-plan) #

Se dispara cuando Claude entra en el modo de planificación o sale de él. Cuando se aprueba un plan mediante ExitPlanMode, guarda el plan definitivo como una memoria en la categoría plans, de modo que las decisiones de arquitectura y las estrategias de implementación quedan registradas sin intervención manual.

Hooks SubagentStart y SubagentStop #

subagent-start.mjs añade contexto de memoria habitual a un agente de trabajo cuando el host proporciona el texto de su tarea, con el mismo presupuesto de 3 memorias / 600 tokens. subagent-stop.mjs le recuerda al agente de trabajo que guarde los hallazgos útiles antes de terminar; solo se ejecuta cuando la opción subagentRemember está activada.

Integración con Claude Code #

SynaBun incluye un único comando de barra, /synabun, que sirve de punto de entrada a todas las funciones basadas en la memoria. Funciona tanto en Claude Code como en Codex, y el panel lateral de OpenCode ofrece un botón de acción rápida dedicado a /synabun changelog. Escríbelo en tu CLI y aparecerá un menú interactivo:

/synabun: el centro de comandos #

El comando /synabun muestra un menú interactivo paginado: tres opciones y un espacio de navegación por página. Si le pasas un argumento, va directo a la opción y se salta el menú.

/synabun
/synabun audit auth module
/synabun search how did we handle token refresh

Prompts interactivos según el runtime #

El menú es una tarjeta interactiva de opciones, no texto plano. La skill usa la herramienta de preguntas propia de cada runtime:

• Claude Code — AskUserQuestion
• OpenCode: la herramienta nativa question
• Codex — request_user_input
• Otros runtimes: una pregunta breve de opción múltiple en texto plano cuando no existe una herramienta interactiva

Reglas de SynaBun #

Tu herramienta de IA necesita un conjunto breve de reglas para usar bien la memoria: recuperar antes de un trabajo importante, memorizar después de cada tarea y llamar a las herramientas de SynaBun de una en una. SynaBun instala esas reglas cuando conectas una herramienta y las mantiene al día. No tienes que pegar nada.

• Al conectar una herramienta se instalan sus reglas y al desconectarla se eliminan. Si conectaste una herramienta antes de que existiera el instalador, SynaBun te pregunta una sola vez y no instala nada hasta que respondas.
• Las actualizaciones son automáticas para una copia que no has editado. Si editas la copia, SynaBun deja de actualizarla; si la borras, SynaBun no la vuelve a crear.
• Tus cambios están a salvo: SynaBun nunca elimina por su cuenta las reglas que editaste. Al desconectar una herramienta, la copia editada se queda donde está, y Eliminar en Ajustes pregunta primero y conserva una copia de seguridad.
• Cada archivo tiene una copia de seguridad antes de que SynaBun lo modifique, en ~/.synabun/backups/rulesets/.
• Las copias antiguas pegadas en el CLAUDE.md, AGENTS.md o GEMINI.md de un proyecto aparecen en Ajustes. SynaBun solo elimina una cuando se lo pides, y solo si es una copia sin editar.
• Codex — cuando un directorio home de Codex contiene un AGENTS.override.md, Codex lee ese archivo en lugar de AGENTS.md. La configuración muestra entonces las reglas como Eclipsadas.

Ajustes → Conexiones de IA → Reglas de SynaBun muestra el estado de cada herramienta con las acciones Instalar, Actualizar, Reemplazar, Eliminar, Ver y Copiar.

Compatibilidad con varios clientes #

SynaBun es un único servidor MCP para todas las herramientas de IA de tu equipo. Claude Code, Codex, OpenCode y los clientes MCP genéricos usan las mismas herramientas y la misma memoria, así que una decisión guardada desde una herramienta se recupera en otra.

Transportes y contexto de quien llama #

• stdio — el cliente lanza mcp-server/run.mjs. El contexto del proyecto proviene de SYNABUN_PROJECT y del entorno de la terminal o de la sesión.
• HTTP — la Neural Interface monta el servidor MCP en http://localhost:3344/mcp; para el acceso por túnel se usa una ruta con clave, /mcp/<key>. El contexto de quien llama se puede indicar con los encabezados X-Synabun-Project, X-Synabun-Memory-Session y X-Synabun-Context-Generation.
• Un cliente que anuncia una sola raíz de sistema de archivos MCP estándar aporta el contexto del proyecto automáticamente. Los argumentos project explícitos de las herramientas tienen prioridad, y con varias raíces hay que indicar el proyecto de forma explícita: no se adivina.

Perfiles de herramientas por runtime #

Cada runtime MCP tiene su propio perfil de herramientas activo, así que cambiar de perfil en un panel lateral, un loop o una programación nunca afecta a los demás. La gestión de MCP sincroniza una misma entrada de servidor entre Claude Code, Codex, Gemini y OpenCode, y las reglas de SynaBun mantienen al día las instrucciones de cada herramienta.

Herramientas del whiteboard #

SynaBun incluye un lienzo visual compartido que tu IA puede ver, dibujar y usar para diagramas de arquitectura, planificación y bocetos colaborativos. 5 herramientas MCP controlan el whiteboard.

Tipos de elementos #

• text — Cuadros de texto con tamaño de fuente y color configurables
• list — Listas con viñetas o numeradas
• shape — Rectángulos, píldoras, círculos, triángulos y círculos dibujados a mano
• arrow — Conectores de 2 o más puntos cuyos extremos pueden anclarse a otros elementos (startAnchor, endAnchor)
• pen — Trazos de dibujo libre con grosor configurable
• image — Imágenes servidas por la Neural Interface e incrustadas en el lienzo
• section — Bloques de wireframe (navbar, hero, sidebar, content, footer, card, form, image-placeholder, button, text-block, grid, modal)

// Add two shapes side by side with auto-layout
whiteboard_add({
  elements: [
    { type: "text", content: "Auth Flow", fontSize: 24 },
    { type: "shape", id: "login", shape: "rect" },
    { type: "shape", id: "token", shape: "pill" }
  ],
  layout: "row"
})

// Connect them: anchored ends snap to the target's edge
whiteboard_add({
  elements: [
    { type: "arrow", points: [[30, 50], [70, 50]], startAnchor: "login", endAnchor: "token" }
  ],
  coordMode: "pct"
})

Herramientas de tarjetas #

Las tarjetas de memoria son paneles flotantes de la Neural Interface que muestran el contenido de una memoria. Tu IA puede abrir, organizar, fijar y capturar tarjetas para armar workspaces visuales de investigación, análisis o material de referencia.

// Open a memory as a compact card
card_open({
  memoryId: "8f7cab3b-644e-4cea-8662-de0ca695bdf2",
  left: 50,
  top: 10,
  coordMode: "pct",
  compact: true
})

Herramientas de Discord #

8 herramientas MCP para gestionar por completo un servidor de Discord. Requiere un DISCORD_BOT_TOKEN en ~/.synabun/.env. Define DISCORD_GUILD_ID para tener un servidor predeterminado.

// Send a message
discord_message({
  action: "send",
  channel: "general",
  content: "Deployment complete! v2.1.0 is live."
})

// Create a role
discord_role({
  action: "create",
  name: "Beta Tester",
  color: "#3b82f6",
  mentionable: true
})

Loops autónomos #

La herramienta loop permite la iteración autónoma: tu IA puede ejecutar tareas de larga duración con hasta 50 iteraciones (10 por defecto) y un límite de tiempo configurable de hasta 480 minutos (60 por defecto). El progreso se registra en un diario que sobrevive a las compactaciones de contexto.

// Start a monitoring loop
loop({
  action: "start",
  task: "Check the deploy status every iteration and report any failures",
  iterations: 20,
  max_minutes: 120
})

Herramienta Git #

La herramienta MCP git ofrece operaciones de control de versiones directamente a través del protocolo MCP: status, diff, commit, log y gestión de branches.

// Check repo status
git({
  action: "status",
  path: "/Users/me/my-project"
})

// Commit specific files
git({
  action: "commit",
  path: "/Users/me/my-project",
  message: "Fix auth middleware race condition",
  files: ["src/middleware/auth.ts"]
})

Automatización del navegador #

SynaBun integra Playwright para darle a tu asistente de IA un navegador propio con sesiones persistentes. Tu IA puede navegar por sitios web, interactuar con elementos, completar formularios, tomar capturas de pantalla, leer la consola, ejecutar JavaScript y extraer datos estructurados, todo con comandos en lenguaje natural a través de MCP.

Cómo funciona #

Las sesiones se ejecutan en el navegador configurado en Ajustes → Navegador: un perfil de navegador gestionado por SynaBun, tu Chrome real o un perfil de MoreLogin. Las sesiones conservan sus propias cookies, inicios de sesión y almacenamiento local entre conversaciones con la IA: tu IA sigue conectada a las plataformas sin tener que autenticarse cada vez. Cada cliente trabaja en su propia pestaña: las comprobaciones de propiedad de pestaña impiden que un agente actúe sobre la pestaña de otro cliente.

Herramientas del navegador (21) #

• browser_navigate — Abre cualquier URL en el navegador de la IA
• browser_click — Hace clic en elementos por ref de snapshot, selector CSS, contenido de texto, rol ARIA o data-testid. Un textHint permite que un localizador frágil se recupere cuando un sitio retoca su DOM.
• browser_fill — Vacía y completa campos de entrada y áreas de texto
• browser_type — Escribe texto carácter por carácter (para elementos contenteditable, como los editores de publicaciones de las redes sociales)
• browser_snapshot — Observa la estructura de la página y las refs de los elementos como texto (una alternativa a las capturas de pantalla que gasta menos tokens). Modos: ai (por defecto; salida compacta con refs de elementos [ref=eN] para pasar a click, fill y type), interactive, landmarks y full. Acótalo con selector y depth, y usa los ID de snapshot y los diffs para ver solo lo que cambió.
• browser_screenshot — Captura la página como imagen: por defecto, el viewport en JPEG, reducido a 1024 px de ancho. width / height emulan un breakpoint solo para esa captura, fullPage captura la página completa y save o path guardan un archivo a resolución completa.
• browser_console NUEVO — Lee los mensajes de consola y los errores de página no capturados de la pestaña actual (los últimos 200), incluidas las páginas de localhost. Filtra con level, since y limit; clear vacía el búfer después de leer.
• browser_content — Extrae el contenido de la página como texto (por defecto) o como markdown, una salida optimizada para LLM que conserva encabezados y enlaces. selector lo limita al subárbol de un elemento.
• browser_evaluate — Ejecuta JavaScript arbitrario en el contexto de la página
• browser_hover — Pasa el cursor sobre elementos de la página
• browser_select — Selecciona opciones de listas desplegables
• browser_press — Pulsa teclas y atajos de teclado
• browser_wait — Espera a que aparezcan elementos, a estados de carga de la página o a que pase un tiempo
• browser_scroll — Desplaza la página o elementos concretos
• browser_go_back — Vuelve a la página anterior
• browser_go_forward — Avanza a la página siguiente
• browser_reload — Recarga la página actual
• browser_upload — Sube archivos mediante campos de formulario
• browser_session — Crea, lista o cierra sesiones del navegador. Las sesiones están aisladas entre la CLI y los paneles laterales y loops de Neural Interface, para que los agentes no se disputen el mismo navegador.
• browser_cheatsheet — Guía rápida de selectores estables, seleccionados por platform (twitter, facebook, tiktok, whatsapp, instagram, linkedin, bluesky), que opcionalmente se puede filtrar a una sola action.
• browser_batch NUEVO — Ejecuta en secuencia hasta 10 pasos de navegador conocidos en una pestaña y devuelve un único snapshot final. Forma parte de Browser V2.

Browser V2 #

Browser V2 es la ruta de ejecución más rápida. Viene activado por defecto; no hace falta ninguna variable para habilitarlo.

• browser_batch — acepta de 1 a 10 pasos {tool, args, observe?} para una sesión y una pestaña. Valida cada paso antes de actuar, ejecuta en orden las herramientas protegidas existentes, se detiene en el primer fallo y devuelve los resultados completados hasta ese momento. El snapshot final es full (por defecto), diff o none. Los pasos no pueden cambiar el enrutamiento ni ejecutar JavaScript arbitrario.
• ID de snapshot y diffs — browser_snapshot devuelve un ID de snapshot compacto y acepta baselineId. Un diff necesita un snapshot compatible ya entregado, del mismo llamador y de la misma página; force: true solicita una vista completa.
• Snapshots automáticos acotados — la observación tras un clic se limita por defecto a 6.000 caracteres, tras una navegación o un desplazamiento a 12.000, y los snapshots explícitos a 30.000. El truncado termina siempre en líneas completas.
• Extracción paginada — las herramientas browser_extract_* aceptan fields y maxChars como opcionales, eliminan los elementos duplicados según su identidad e indican por qué se detuvieron.
• Ritmo de escritura en redes sociales — las escrituras de interacción en redes sociales mantienen una separación aleatoria de 30–90 segundos y se ejecutan en serie dentro de cada sesión del navegador.
• Cancelación — cancelar una llamada a una herramienta detiene las solicitudes pendientes e impide los pasos posteriores del lote. Nunca repitas un lote entero ni un clic dudoso; revisa primero el estado actual.
• Vuelta atrás — define SYNABUN_BROWSER_V2=0 tanto para la Neural Interface como para sus procesos MCP y, después, reinícialos.

// Selectors and sequence are already known: one call, one final diff
browser_batch({
  steps: [
    { tool: "browser_fill", args: { selector: "#email", value: "[email protected]" } },
    { tool: "browser_click", args: { selector: "#save" } }
  ],
  snapshot: "diff"
})

Capturas de pantalla y consola para QA visual #

// Full-page capture at a mobile breakpoint, saved as a file
browser_screenshot({ width: 375, fullPage: true, save: true })

// Only the errors since the last read
browser_console({ level: "error", clear: true })

Por defecto, una captura de pantalla guardada va a ~/.synabun/data/media/screenshots/<date>/. Un path explícito debe ser absoluto, terminar en .png, .jpg o .jpeg y estar dentro de un proyecto registrado o de la carpeta de capturas.

Asistencia de Jev (orientativa) #

Con las decisiones de IA activadas, las herramientas del navegador añaden a su salida habitual una lectura tipada de la página. Es solo texto y nunca forma parte del flujo de control: con la opción desactivada, cada herramienta responde exactamente igual que antes.

• browser_navigate acepta un intent opcional. Tras el snapshot puede aparecer una línea como Jev assessment: authentication_required (94%) — pause for human sign-in. Un bloqueo significa detenerse y ceder el control a la persona; un diálogo de consentimiento nunca se cierra automáticamente.
• browser_snapshot acepta un intent opcional y puede añadir una línea Jev target: que indica la mejor ref de ese mismo snapshot. Nunca hace clic.
• Una acción de clic, relleno, escritura, hover, selección o subida que falla o resulta ambigua devuelve sus pistas habituales, reordenadas cuando se encontró una coincidencia fiable.
• Dentro de browser_batch no hay asistencia; un lote que navegó recibe, al terminar, una única evaluación de su página final.

MoreLogin #

MoreLogin es un navegador antidetección y multicuenta. SynaBun puede gestionar sus perfiles con la herramienta morelogin y usar uno de ellos como navegador de IA predeterminado, de modo que todas las herramientas browser_* controlen ese perfil.

// Find a profile, then make it the default AI browser
morelogin({ action: "list" })
morelogin({ action: "use_default", envId: "<env-id>" })

MoreLogin como navegador predeterminado #

• Mientras Ajustes → Navegador indique MoreLogin como predeterminado, cada loop, programación, ejecución despachada, recuperación y sesión interactiva controla el perfil predeterminado de MoreLogin.
• Si no se puede acceder a MoreLogin, la ejecución falla y su registro recoge el motivo. Nada recurre a Chrome como alternativa.
• Las herramientas de página rechazan una sesión que no corresponda al navegador predeterminado, así que un agente nunca actúa sobre una página en el navegador equivocado.
• Las páginas de localhost se abren en el perfil de MoreLogin como cualquier otra. La opción Port scan protection de cada perfil de MoreLogin decide qué puertos locales se cargan: añade los puertos de tu servidor de desarrollo en Edit profile → Advanced settings → Port scan protection y reinicia el perfil. Una navegación bloqueada falla con un mensaje que indica el puerto.

Automatización de redes sociales #

Además de las herramientas generales del navegador, SynaBun incluye 25 herramientas de plataforma para Twitter/X, Facebook, TikTok, WhatsApp, Instagram y LinkedIn: 22 herramientas de extracción que convierten el contenido en JSON estructurado, dos sondas de solo lectura del estado de redacción y la herramienta de directorio fb_groups. Son más rápidas y fiables que browser_snapshot porque analizan cada plataforma de forma específica. Las herramientas de plataforma siempre se ejecutan en el navegador predeterminado.

Twitter / X #

• browser_extract_tweets — Analiza todos los tweets visibles: autor, usuario, texto, fecha y hora, URL, respuestas, reposts, me gusta y número de visualizaciones. Funciona en cronologías, resultados de búsqueda y páginas de perfil.
• browser_x_compose_state NUEVO — Inspecciona el área de redacción en una sola llamada de solo lectura: el texto del editor, el número de caracteres y el indicador de límite superado, el tipo de tarjeta de cita (quote, link o none), el botón de envío y su selector, y una recommendedAction (submit, type, open-composer, fix-quote-url, trim-text o unknown). Consúltala antes de publicar: una cita solo es segura de publicar cuando el tipo de tarjeta es quote.

TikTok #

• browser_extract_tiktok_videos — Extrae los videos del feed con usuario, URL del video, descripción, me gusta, comentarios, guardados, compartidos e información de la música
• browser_extract_tiktok_search — Analiza los resultados de búsqueda con URL de los videos, usuarios, descripciones y número de visualizaciones
• browser_extract_tiktok_profile — Extrae la información del perfil: nombre, usuario, biografía, seguidores, seguidos y me gusta, además de la cuadrícula de videos con sus URL y visualizaciones
• browser_extract_tiktok_studio — Analiza la lista de contenido de TikTok Studio: título, URL, fecha, ajuste de privacidad y estadísticas de rendimiento

Facebook #

• browser_extract_fb_posts — Analiza los posts visibles: autor, URL del autor, texto, fecha y hora, URL del post y reacciones. Funciona en el feed de noticias, en feeds de grupos y en páginas de empresa.
• browser_fb_composer_state NUEVO — Inspecciona el área de publicación en una sola llamada de solo lectura: el diálogo de publicación abierto, los editores de la página (los cuadros de comentarios se marcan y nunca se tratan como editores de posts), el botón de envío, el estado del envío (visible-post, pending-approval, posting-failed, composer-open o unknown), una recommendedAction y boostRisk, que señala los controles de pago Boost / Promote, en los que nunca se debe hacer clic. Tolera distintos idiomas: PT, EN, TR, FR, ES y DE.
• browser_extract_fb_groups NUEVO — Extrae todos los grupos a los que te has unido desde la página de grupos como un índice ordenado por región. Desplaza automáticamente la lista virtualizada y elimina duplicados por URL en una sola llamada; cada grupo incluye su nombre, URL, número de miembros, región, idioma y moneda.
• fb_groups NUEVO — Un directorio de grupos estructurado, respaldado por SQLite, con una lista de comprobación de publicación por grupo. Consulta las acciones a continuación.

WhatsApp #

• browser_extract_wa_chats — Analiza la barra lateral de WhatsApp Web: nombre del chat, último mensaje, hora, número de mensajes sin leer y estado de silenciado o fijado
• browser_extract_wa_messages — Extrae los mensajes de una conversación abierta: remitente, hora, fecha, dirección (entrante/saliente) y texto

Estas herramientas leen WhatsApp Web en el navegador. Para chatear con el Asistente desde tu teléfono, consulta Vinculación con WhatsApp.

Instagram #

• browser_extract_ig_feed — Analiza los posts del feed: nombre de usuario, descripción, me gusta, comentarios y fecha y hora
• browser_extract_ig_profile — Extrae los datos del perfil: biografía, cifras de seguidores y seguidos, cuadrícula de posts e historias destacadas
• browser_extract_ig_post — Un solo post con todos sus comentarios (admite paginación)
• browser_extract_ig_reels — Extrae reels con métricas de interacción y el nombre y la URL del audio
• browser_extract_ig_search — Analiza los resultados de Explorar y de búsquedas por hashtag

LinkedIn #

• browser_extract_li_feed — Posts del feed con autor, titular, texto, reacciones, comentarios y enlaces a artículos
• browser_extract_li_profile — Datos del perfil: titular, ubicación, contactos, experiencia, educación y aptitudes
• browser_extract_li_post — Un post con todos sus comentarios (admite paginación)
• browser_extract_li_notifications — Notificaciones con texto, fecha y hora, y estado de lectura
• browser_extract_li_messages — Conversaciones de mensajería y mensajes del hilo activo
• browser_extract_li_search_people — Resultados de búsqueda de personas con titular y ubicación
• browser_extract_li_network — Contactos de tu red y sugerencias de contactos
• browser_extract_li_jobs — Ofertas de empleo de los resultados de búsqueda y de las recomendaciones de la página de inicio (puesto, empresa, ubicación, salario, fecha de publicación)

Otras plataformas #

BlueSky y YouTube tienen grupos de herramientas propios: consulta Herramientas de BlueSky y Herramientas de YouTube. Las herramientas generales de automatización del navegador pueden interactuar con cualquier plataforma web: Reddit, Pinterest o cualquier sitio que se abra en el navegador. Usa browser_navigate, browser_click, browser_type y browser_content para automatizar interacciones en cualquier sitio web.

Herramientas de BlueSky #

SynaBun incluye 15 herramientas de BlueSky que llaman a la API de AT Protocol directamente desde la pestaña de bsky.app con la sesión iniciada, en lugar de extraer datos de la página. Inicia sesión en bsky.app una sola vez en el navegador de SynaBun: las herramientas reutilizan esa sesión y renuevan por sí solas el token de acceso cuando expira.

// Confirm the session, search, publish, and engage
bluesky_session({})
bluesky_search_posts({ q: "mcp server", sort: "latest", maxItems: 20 })
bluesky_post({ text: "Notes on wiring persistent memory into a coding agent: https://synabun.ai/docs" })
bluesky_action({ action: "follow", target: "alice.bsky.social" })

• Las herramientas de lectura devuelven JSON compacto y un cursor; pasa maxItems para paginar automáticamente.
• Cada llamada completa tiene un único plazo de 48 segundos. Una solicitud que no responde a tiempo se informa como posiblemente completada y nunca se reintenta: compruébalo antes de repetir una escritura.
• Activa el grupo con el perfil predefinido bluesky (git, image, browser y las herramientas de BlueSky); también forma parte de browser y full.

Herramientas de YouTube #

SynaBun incluye 11 herramientas de YouTube para un proceso completo de tráileres de videojuegos: descubrir, descargar, publicar y analizar. La automatización del navegador controla YouTube Studio directamente a través de tu sesión de Google iniciada, lo que evita el bloqueo en privado que la Data API aplica a los proyectos no auditados y su reducida cuota diaria de subidas. La búsqueda de material y las analíticas se delegan en la API de Neural Interface.

Descubrimiento y descarga (2) #

• youtube_source — Descubre tráileres de videojuegos candidatos mediante IGDB (metadatos, id de la aplicación en Steam, ids de tráileres de YouTube) y Steam Storefront (URL directas de MP4). Admite filtros de género, plataforma y expectación, y ventanas de tiempo hacia atrás.
• youtube_download — Descarga un tráiler al disco. Da prioridad a los MP4 del editor en Steam por HTTPS directo; recurre a yt-dlp para los tráileres que solo están en YouTube.

Publicación en Studio (7) #

• youtube_navigate — Abre una sección de YouTube Studio (panel, contenido, analíticas, listas de reproducción, comentarios, subtítulos, derechos de autor, ingresos, personalización). Resuelve automáticamente el canal con la sesión iniciada.
• youtube_upload modifica datos — Sube un video local mediante el cuadro de diálogo Create → Upload: título, descripción, etiquetas, contenido para niños y, después, Details → Video elements → Checks → Visibility.
• youtube_metadata modifica datos — Edita el título, la descripción, las etiquetas, la categoría y la marca de contenido para niños de un video existente.
• youtube_thumbnail modifica datos — Sube una miniatura personalizada a un video.
• youtube_schedule modifica datos — Programa una fecha de publicación futura o define la visibilidad inmediata. Acepta ISO o YYYY-MM-DD HH:MM.
• youtube_playlist modifica datos — Crea listas de reproducción, agrega videos o lista las listas de reproducción existentes.
• youtube_endscreen modifica datos — Aplica una plantilla de pantalla final a un video.

Analíticas (2) #

• youtube_analytics — YouTube Analytics en modo de solo lectura mediante la YouTube Analytics API (OAuth): visualizaciones, tiempo de reproducción, «me gusta» y suscriptores ganados, de todo el canal o por video.
• youtube_channel — Información del canal o una lista de las subidas recientes para evitar duplicados.

Herramientas de Leonardo.ai #

SynaBun incluye 5 herramientas MCP de Leonardo.ai basadas en el navegador para generar imágenes y videos con IA. Estas herramientas automatizan la interfaz web de Leonardo.ai directamente con Playwright, sin necesidad de una clave de API. Usa las herramientas genéricas del navegador para configurar los ajustes (modelo, estilo, dimensiones, controles de movimiento) y, después, usa las herramientas de Leonardo para generar y obtener los resultados.

Herramientas del navegador (5) #

• leonardo_browser_navigate — Navega a páginas específicas de Leonardo.ai (inicio, biblioteca, editor de imágenes, video, escalador, blueprints, lienzo en tiempo real, modelos).
• leonardo_browser_generate — Rellena el prompt y haz clic en Generate. Configura antes todos los ajustes de la interfaz (modelo, estilo, dimensiones, controles de movimiento) con las herramientas genéricas del navegador (browser_click, browser_fill, browser_snapshot).
• leonardo_browser_library — Explora o busca en la biblioteca de generaciones a través de la interfaz web.
• leonardo_browser_download — Toma una captura de pantalla de la página actual de Leonardo.ai para ver los resultados de la generación.
• leonardo_browser_reference — Sube imágenes de referencia y adjúntalas a la próxima generación. Acepta filePaths y un type: image_ref, style_ref, content_ref, character_ref o image_to_image para imágenes; start_frame o end_frame para video.

Herramientas de Google Search Console #

SynaBun incluye 30 herramientas MCP de Google Search Console basadas en el navegador que manejan la interfaz web de GSC directamente con Playwright: sin clave de API, sin cuotas y sin JSON de cuenta de servicio. Tu IA usa tu propia sesión autenticada de Google en el navegador que administra SynaBun. Los selectores no dependen del idioma (usan rutas de URL, ligaduras de material-icon y roles aria en lugar de textos traducidos de la interfaz), así que las herramientas funcionan sin importar el idioma en que se muestre GSC.

Navegación y propiedades (2) #

• gsc_navigate — Abre cualquier sección de GSC (overview, performance_search/discover/news, inspect, pages, videos, sitemaps, removals, cwv_mobile/desktop, https, security, manual_actions, links, achievements, settings, crawl_stats, users, change_address, associations, disavow, shopping, merchant, además de 17 informes de mejoras). Conserva la propiedad activa.
• gsc_property — Lista, selecciona, lee o agrega una propiedad (de dominio o de prefijo de URL).

Inspección de URL (4) #

• gsc_inspect_url — Inspecciona una URL, espera hasta 30s a que aparezca el panel de resultados y devuelve un JSON estructurado (indexingState, canonicals, lastCrawl, sitemap, robots, enhancements, etc.).
• gsc_inspect_test_live — Hace clic en "Probar URL publicada" y espera hasta 90s los resultados de la prueba en vivo (el tiempo límite del propio Google).
• gsc_inspect_request_indexing modifica datos — Envía la URL a la cola de indexación de Google.
• gsc_inspect_view_crawled — Abre el panel de la página rastreada y cambia entre las pestañas html / screenshot / http_response / more_info.

Rendimiento (3) #

• gsc_performance_query — Consulta un informe de rendimiento: searchType, dateRange (predefinido o personalizado), dimension (query/page/country/device/searchAppearance/date), filtros y comparación. Recorre la tabla automáticamente hasta limit filas y devuelve los totales y la tabla en JSON.
• gsc_performance_export — Abre el menú de exportación del informe (CSV / Excel / Google Sheets).
• gsc_performance_chart_screenshot — Toma una captura del gráfico de rendimiento actual.

Indexación y cobertura (6) #

• gsc_pages_report — Lee el informe de páginas (cobertura): totales, grupos por motivo y, si lo pides, el detalle con URL de ejemplo.
• gsc_pages_validate_fix modifica datos — Inicia la validación de una corrección para el grupo de motivos que elijas.
• gsc_videos_report — Lee el informe de indexación de videos (con la misma estructura que gsc_pages_report).
• gsc_sitemap — Lista, envía o elimina sitemaps, o consulta sus errores.
• gsc_removals — Lista o crea solicitudes de retirada de URL (temporal de 6 meses, contenido obsoleto, SafeSearch).
• gsc_removals_cancel modifica datos — Cancela una retirada temporal pendiente.

Experiencia y problemas (5) #

• gsc_cwv_report — Core Web Vitals (móvil / escritorio): número de URL deficientes, que necesitan mejorar y buenas, y grupos por problema.
• gsc_https_report — Cobertura HTTPS y motivos de las URL que no usan HTTPS.
• gsc_security_issues — Lee los problemas de seguridad y, si quieres, solicita una revisión.
• gsc_manual_actions — Lee las acciones manuales y, si quieres, envía una solicitud de reconsideración con un texto personalizado.
• gsc_enhancements — Lee cualquier informe de mejoras de datos estructurados (breadcrumbs, faq, sitelinks, videos, products, recipes, review, events, jobposting, speakable, qa, logos, sitenames, dataset, practice, math, merchant).

Enlaces (2) #

• gsc_links_report — Páginas más enlazadas / sitios que enlazan / textos de enlace / enlaces internos. Pagina automáticamente.
• gsc_links_export — Abre el menú de exportación del informe de enlaces.

Ajustes y varios (8) #

• gsc_settings — Lee la página de ajustes (propiedad, verificación, usuarios) y permite cambiar la dirección.
• gsc_crawl_stats — Estadísticas de rastreo: totales (solicitudes, bytes, tiempo de respuesta) y desgloses por host, código de respuesta, tipo de archivo y tipo de Googlebot.
• gsc_users — Lista, agrega o elimina usuarios de la propiedad, o cambia su rol.
• gsc_associations — Lista, agrega o elimina asociaciones (Analytics, Merchant Center, Ads, Play, YouTube, Actions, Chrome Web Store).
• gsc_disavow modifica datos — Descarga, sube o elimina el archivo de desautorización de enlaces.
• gsc_shopping — Lee el informe de Shopping / fichas de comerciante.
• gsc_extract_table — Extractor genérico de tablas de GSC a JSON para cuando ninguna herramienta específica cubre un panel.
• gsc_screenshot — Captura de página completa de la pestaña activa de GSC.

Vibe coding con SynaBun #

El vibe coding es un estilo de desarrollo en el que colaboras con asistentes de IA conversando: describes lo que quieres en lenguaje natural y la IA escribe, refactoriza y depura el código. Herramientas como Claude Code, Cursor y Windsurf lo han vuelto algo habitual.

El problema: la amnesia de la IA #

Sin memoria persistente, cada sesión de programación con IA empieza de cero. Tu IA olvida las decisiones de arquitectura, los errores que ya corregiste, las convenciones de código que definiste y el contexto del proyecto. Terminas explicando lo mismo en cada sesión, pierdes tiempo y pierdes continuidad.

Cómo lo resuelve SynaBun #

SynaBun le da a tu IA una memoria persistente que se conserva de una sesión a otra:

• Captura automática de memorias — Los hooks de Claude Code guardan automáticamente las decisiones importantes, las correcciones de errores y los patrones después de cada tarea
• Recuperación semántica — Tu IA encuentra el contexto relevante por su significado, no por palabras clave exactas. Pregunta "¿cómo resolvimos la autenticación?" y encuentra la memoria sobre "JWT token refresh flow"
• Detección de desfases — Cuando cambian los archivos fuente, SynaBun marca como posiblemente desactualizadas las memorias que hacen referencia a ellos
• Aislamiento entre proyectos — Cada proyecto tiene su propio espacio de memoria, con búsqueda entre proyectos cuando hace falta
• Continuidad entre sesiones — La indexación de la memoria de conversaciones captura el contexto de la sesión en cada compactación para poder recuperarlo en otras sesiones

Más allá de la memoria: un kit completo de IA #

SynaBun ofrece 157 herramientas MCP que convierten cualquier editor de IA compatible en un entorno de desarrollo completo:

• Asistente de SynaBun — Un orquestador con acceso a la memoria que dirige cada tarea al modelo adecuado y lanza agentes de trabajo de Claude Code, Codex y OpenCode con presupuestos y control de tokens
• Generación de imágenes y videos con IA — Crea imágenes y videos con Leonardo.ai, con combinación de estilos, controles de movimiento e imágenes de referencia adjuntas
• Automatización del navegador — Prueba aplicaciones web, extrae datos y revisa páginas en cualquier breakpoint con un navegador real; browser_batch ejecuta secuencias conocidas en una sola llamada y browser_console muestra los errores de la página
• Uso del equipo — En macOS, el Asistente puede manejar aplicaciones de escritorio, limitado por protecciones siempre activas y controles de parada
• Guía de estilo — Un DESIGN.md por proyecto y tokens de diseño que todos los agentes leen antes de trabajar en la interfaz
• Whiteboard visual — Diagramas de arquitectura, diagramas de flujo y planificación colaborativa en un lienzo compartido
• Tarjetas flotantes — Fija notas de investigación, análisis y decisiones en un workspace visual
• Estudio de automatizaciones — Editor visual de plantillas con carpetas creadas por el usuario, valores de lanzamiento predeterminados por plantilla y compatibilidad con Claude Code / Codex / Gemini / OpenCode
• Loops autónomos — Tareas de IA de larga duración con intervalos configurables en cualquiera de las cuatro CLI
• Paneles laterales — Paneles laterales dedicados para Claude Code, Codex y OpenCode, con cancelación por agente, barra de actividad de herramientas, tarjetas de permisos y Multi-CLI Resume
• Estudio de skills — Crea workflows de IA reutilizables y comandos personalizados; /synabun y /leonardo funcionan tanto en Claude Code como en Codex
• Herramientas para redes sociales — Interactúa con Twitter/X, TikTok, Facebook, Instagram, LinkedIn, WhatsApp, BlueSky y YouTube

Configuración #

SynaBun funciona sin ninguna configuración. Cada ajuste es una variable de entorno opcional, definida en ~/.synabun/.env o en el entorno desde el que se inicia SynaBun.

Directorio de datos #

El estado mutable del usuario vive fuera de la aplicación, en ~/.synabun de forma predeterminada, así que actualizar el código nunca toca tus datos:

~/.synabun/
├── .env            # optional settings and API keys
├── mcp-data/
│   └── memory.db   # the SQLite database: memories, vectors, revisions
├── data/           # Neural Interface state: assistant config and sessions, media, audit logs
└── backups/        # verified backups and ruleset backups

Las instalaciones que guardaban su estado dentro del checkout pueden previsualizar un traslado seguro con synabun migrate-data y aplicarlo con synabun migrate-data --apply.

Almacenamiento #

# Root for mutable user state (default: ~/.synabun)
# SYNABUN_DATA_HOME=/custom/synabun

# Database file path (default: ~/.synabun/mcp-data/memory.db)
# SQLITE_DB_PATH=/custom/path/to/memory.db

# Data directory for MCP runtime files (default: ~/.synabun/mcp-data/)
# MEMORY_DATA_DIR=/custom/data/dir

# SQLite runs embedded in Node.js via node:sqlite
# No port, no API key, no external process needed

Servidor e integraciones #

# Neural Interface server port (default: 3344)
# NEURAL_PORT=3344

# Setup wizard completion flag
# SETUP_COMPLETE=true

# Discord bot token for the Discord tools
# DISCORD_BOT_TOKEN=your-token-here

# TypeSafe API key for AI decisions (optional)
# TYPESAFE_API_KEY=your-key-here

Interruptores de funciones #

Comandos de la CLI #

El comando synabun se instala con npm install -g synabun. Desde un checkout de git, npm start es el mismo punto de entrada, y los subcomandos se pasan después de --.

Scripts de npm #

# From a checkout: setup + launch (same as the synabun command)
npm start

# Run a CLI subcommand from a checkout
npm start -- doctor

# Start only the Neural Interface server
npm run server

# Rebuild the MCP server after changing its source
npm run mcp:build

# Install the local embedding model assets
npm --prefix mcp-server run setup:embeddings

# Migrate an older Qdrant-based installation into SQLite
npm --prefix mcp-server run migrate

Actualización #

• npm — npm install -g synabun@latest mantiene el estado del usuario fuera del paquete. El actualizador integrado crea una instantánea verificada antes de reemplazar el código, y una actualización manual con npm hace la misma verificación en el primer inicio.
• git — ejecuta git pull --ff-only y luego inicia SynaBun una vez. El primer inicio migra el estado local del checkout antes del arranque normal; no ejecutes git clean -fdx hasta que ese inicio haya terminado.
• Raíces en conflicto — SynaBun nunca fusiona automáticamente dos raíces de datos con contenido. Ejecuta synabun doctor y luego elige de forma explícita con synabun migrate-data --choose external o --choose legacy. Ambas copias se conservan antes de activar la elección.

Self-hosting #

SynaBun está diseñado para ser self-hosted. Todos los datos viven en tu base de datos SQLite y en tu sistema de archivos local, y no hace falta ninguna cuenta.

Gestión de la base de datos #

SynaBun usa SQLite a través del módulo node:sqlite integrado en Node.js (requiere Node.js 22.5+). La base de datos es un único archivo ubicado de forma predeterminada en ~/.synabun/mcp-data/memory.db: sin Docker, sin procesos aparte, sin puertos de red.

# Database location
ls ~/.synabun/mcp-data/memory.db

# Inspect database, migration, client-registration, and backup health
synabun doctor

Copias de seguridad y restauración #

Usa Ajustes → Memoria y copias de seguridad → Copias de seguridad para obtener una copia consistente con el WAL y verificada con checksum, o descarga una desde la API. Las copias programadas son archivos ZIP inmutables, con marca de tiempo, checksums en el manifiesto y una instantánea consistente de SQLite.

# Download a verified full system backup
curl -o synabun-backup.zip http://localhost:3344/api/system/backup

# Verify a backup (dry run)
synabun restore-backup --from ./synabun-backup.zip

# Restore it, with SynaBun's MCP and server processes stopped
synabun restore-backup --from ./synabun-backup.zip --apply

La retención predeterminada conserva todas las copias durante 24 horas, una por día durante 30 días y una por semana durante 12 semanas, con un límite de 10 GB.

Varias instancias #

Puedes mantener almacenes separados (por ejemplo, uno por entorno) si inicias cada instancia con su propio directorio de datos y su propio puerto:

SYNABUN_DATA_HOME=/srv/synabun-a NEURAL_PORT=3344 synabun
SYNABUN_DATA_HOME=/srv/synabun-b NEURAL_PORT=3345 synabun

Deploy en producción #

Para un deploy en producción, ejecuta SynaBun como un proceso de Node.js con un gestor de procesos como PM2. La base de datos SQLite y los embeddings locales se ejecutan en la misma máquina, sin servicios externos:

# Start with PM2
pm2 start npm --name synabun -- start

# Running on this machine:
# - SQLite database (~/.synabun/mcp-data/memory.db)
# - MCP server + Neural Interface (:3344)

Consulta Comandos de la CLI para actualizar de forma segura una instalación existente.

Cómo contribuir #

SynaBun es open source bajo la licencia Apache 2.0. Agradecemos los reportes de errores y las solicitudes de funciones. No se aceptan pull requests: el código lo mantienen exclusivamente los autores de SynaBun.

• Reportes de errores: abre un issue en GitHub Issues con los pasos para reproducirlo
• Solicitudes de funciones: abre un issue en GitHub Issues que describa el problema y la solución propuesta
• Forks: puedes hacer un fork de SynaBun y modificarlo libremente bajo Apache 2.0. Los forks deben usar un nombre distinto (política de marca).

Consulta el CONTRIBUTING.md completo para ver los detalles, la configuración del entorno de desarrollo y la guía para forks.