# CÓMO USAR EL CEREBRO — orden exacto por agente (NO improvisar)

> Generado 2026-07-17 (consolidación del cerebro). Este documento es la ORDEN EXACTA de
> conexión al cerebro CESCAC para que ningún agente tenga que redescubrir la integración.
> Si algo de aquí no funciona igual que lo descrito, es un bug de este documento — repórtalo
> en `docs/REGISTRO_CAMBIOS_CORE.md`, no inventes un camino alterno.

## 0 · Antes que nada: lee el manifiesto

1. `https://vps.cescac.com/cerebro/index.php` (o `index.md` si estás on-box) — orden de
   lectura general del cerebro (contexto-maestro, reglas, memoria, grafo).
2. Este documento cubre la pieza que faltaba: **cómo conectar herramientas (MCP) al cerebro**,
   no el contenido del cerebro en sí.


## 0b · REGLA OBLIGATORIA — conectar los 4 cerebros ANTES de trabajar

> **Parche quirurgico 2026-07-19.** TODO AGENTE (Cursor, Claude Code, Codex, Antigravity,
> Hermes, Gemini CLI), al leer este documento, DEBE configurar estos 4 MCP ANTES de cualquier
> accion productiva. Sin los 4 cerebros conectados, el agente NO tiene contexto completo.

### Estado real 2026-07-19 (mantener actualizado)

| Cerebro | Cursor | Claude Code |
|--------|--------|-------------|
| graphify | CONECTADO (2026-07-19) | CONECTADO |
| obsidian | CONECTADO (2026-07-19) | CONECTADO |
| codegraph | CONECTADO (2026-07-19) | CONECTADO |
| notebooklm | Config SIN login (setup_auth) | Config SIN login |

### Como configurarlos

Ver secciones 2-4 de este documento para comandos exactos por agente. Resumen:

- **graphify:** MCP sobre `graphify-out/graph.json` (1434 nodos, codigo+docs+conceptos)
- **obsidian:** MCP sobre `obsidian_cescac/` (vault unico, ~300 notas navegables)
- **codegraph:** `codegraph serve --mcp` (2798 nodos, 6007 edges, call-graph profundo)
- **notebooklm:** `npx notebooklm-mcp@2.0.0 mcp` + `setup_auth` (requiere Google login del dueno)

Si al leer este documento los 4 cerebros NO estan en tu mcp.json, **NO estas completo.**
Configuralos AHORA — el manifiesto y las reglas-fijas (§12) lo exigen.


## 1 · El vault Obsidian único (EL cerebro navegable)

Desde 2026-07-17 hay **UN SOLO vault Obsidian oficial**:

```
C:\Users\CESCAC\Desktop\CRM_CESCAC\obsidian_cescac
```

- ~300 notas (auditorías, arquitectura, agentes, campañas) exportadas del repo `CRM_CESCAC`
  vía `graphify`, con enlaces `[[wikilink]]` automáticos al final de cada nota
  (sección `## Connections`).
- `memoria-agente/` dentro del vault — 5 notas curadas (perfil Anthony, personas, preferencias,
  personalidad, decisiones).
- Nota `00_LEEME_ESTE_ES_EL_CEREBRO.md` en la raíz del vault explica qué se archivó y por qué.
- **Vaults viejos (NO usar, archivados con backup, no borrados):**
  `CRM_CESCAC/memory_ARCHIVADO_20260717/` y
  `Documents/Obsidian-CESCAC_ARCHIVADO_20260717/`.

## 2 · MCP `obsidian` — leer/escribir notas del vault

Ya conectado en esta máquina (Claude Code, scope local del proyecto `CRM_CESCAC`):

```bash
claude mcp add obsidian -s local -- npx -y obsidian-mcp "C:/Users/CESCAC/Desktop/CRM_CESCAC/obsidian_cescac"
```

Requisito silencioso de `obsidian-mcp`: la carpeta `.obsidian/` del vault necesita
`app.json` (aunque sea `{}`) o el servidor rechaza el vault con
"Not a valid Obsidian vault". Si migras el vault a otra carpeta, crea ese archivo primero.

Herramientas que expone: `search-vault`, `create-note`, `edit-note`, `list-available-vaults`.

## 3 · MCP `graphify` — el grafo de conocimiento (repo completo, no solo el vault)

Ya conectado (Claude Code, local):

```bash
claude mcp add graphify -s local -- "C:\Users\CESCAC\AppData\Local\hermes\hermes-agent\venv\Scripts\python.exe" -m graphify.serve "C:\Users\CESCAC\Desktop\CRM_CESCAC\graphify-out\graph.json"
```

Fuente: `graphify-out/graph.json` — **1434 nodos, 1902 links** (build al commit `2561bbb`),
mezcla código (AST: PHP/Python/JS — funciones, clases, `calls`, `inherits`, `implements`),
documentos, conceptos y `rationale`. Espejo público en el VPS:
`https://vps.cescac.com/cerebro/grafo/graph.json` y `/cerebro/grafo/index.html` (navegable).

### Cómo consultar el grafo por CLI (sin pasar por el MCP)

```bash
cd C:\Users\CESCAC\Desktop\CRM_CESCAC
python -m graphify query "tu pregunta en lenguaje natural" --graph graphify-out/graph.json
python -m graphify explain "NombreDeNodo"          # explicación de un nodo y sus vecinos
python -m graphify path "NodoA" "NodoB"             # camino más corto entre dos nodos
python -m graphify affected "archivo_o_funcion.php" # qué se rompe si tocas X
```

`query` hace BFS (o `--dfs`) sobre el grafo y devuelve nodos relevantes con `src=`, `loc=`
(línea) y `community=` (cluster temático) — úsalo ANTES de grep/read cuando la pregunta es
"qué toca a X" o "cómo se relaciona X con Y", ahorra tool calls.

### Regenerar el grafo tras cambios grandes

```bash
python -m graphify update .        # re-extrae código, sin LLM, rápido
python -m graphify cluster-only .  # solo si quieres re-clusterizar/relabel comunidades
```

Después de regenerar, sincroniza al VPS (con backup):

```bash
ssh cescac-root "cp /home/admin/web/vps.cescac.com/public_html/cerebro/grafo/graph.json /home/admin/web/vps.cescac.com/public_html/cerebro/grafo/graph.json.bak_$(date +%Y%m%d)"
scp graphify-out/graph.json cescac-root:/home/admin/web/vps.cescac.com/public_html/cerebro/grafo/graph.json
```

## 4 · MCP `codegraph` — grafo de código profundo (símbolos, no solo archivos)

Instalado 2026-07-17, **complementa** a `graphify`, no lo reemplaza:

- `graphify` = grafo de CONOCIMIENTO amplio (código + docs + conceptos + razonamiento),
  build manual/bajo demanda, pensado para el "cerebro"/vault.
  Rendered: file-level + AST superficial (1434 nodos totales, de los cuales 1022 `code`).
- `codegraph` = grafo de CÓDIGO profundo (variables, funciones, imports, clases, métodos,
  call graph con dispatch dinámico), auto-sync en cada cambio, 100% local (SQLite, sin
  API keys, sin salir de la máquina). En este repo: **252 archivos, 2798 nodos, 6007 edges**
  (83 PHP, 83 Python, 73 YAML, 5 JS, 5 TS). Úsalo para preguntas de "qué llama a qué",
  "impacto de cambiar esta función" — ahorra lecturas de archivo completas.

Instalación ya hecha (Claude Code, local, este repo):

```bash
npm i -g @colbymchenry/codegraph
claude mcp add codegraph -s local -- codegraph serve --mcp
cd C:\Users\CESCAC\Desktop\CRM_CESCAC && codegraph init   # indexa el repo (una vez; luego auto-sync)
codegraph status                                          # ver stats del índice
```

Para conectar otros agentes (Cursor, Codex CLI, Antigravity, Hermes) sin el bloqueo de
permisos que da `codegraph install` en modo automático, usa `--print-config <id>` y pega el
snippet a mano en la config del agente (ids válidos: `claude`, `cursor`, `codex`, `opencode`,
`hermes`, `gemini`, `antigravity`, `kiro`):

```bash
codegraph install --print-config cursor
codegraph install --print-config hermes
```

## 5 · NotebookLM — estado real (léelo antes de asumir que está integrado)

**Veredicto: NO integrado. Config lista, login pendiente del dueño (Anthony). Riesgo de ToS real.**

Repo evaluado: [`PleasePrompto/notebooklm-mcp`](https://github.com/PleasePrompto/notebooklm-mcp)
(npm `notebooklm-mcp@2.0.0`, MIT, activamente mantenido — v2.0.0 es la línea actual, v1
descontinuada). NO existe API oficial pública de NotebookLM — este proyecto y todos los demás
encontrados (`julianoczkowski/notebooklm-mcp-2026`, `roomi-fields/notebooklm-mcp`,
`alfredang/notebooklm-mcp`, `jacob-bd/notebooklm-mcp-cli`, `Pantheon-Security/notebooklm-mcp-secure`)
son **wrappers de automatización de navegador**, no clientes de API.

Mecánica exacta de `PleasePrompto/notebooklm-mcp`: controla un Chrome real vía **Patchright**
(fork de Playwright con fingerprint "stealth" para evadir detección de bots de Google). Guarda
cookies de sesión en un perfil de Chrome persistente (`%APPDATA%` en Windows). Primer uso exige
`setup_auth`, que abre un navegador visible donde **el dueño debe iniciar sesión con SU cuenta
de Google manualmente** — ningún agente puede ni debe hacer ese login por él (es su credencial
personal). Soporta multi-cuenta con `--account <nombre>`.

**Riesgo real (no lo esconde el propio proyecto, pero tampoco lo destaca):** automatizar la UI
web de un producto de consumo de Google con fingerprint anti-detección puede violar los
Términos de Servicio de Google y arriesgar la cuenta del dueño (suspensión/flag). No hay ToS
override ni API key de por medio — es scraping disfrazado de sesión de navegador real.

**Lo que se dejó listo (config, sin ejecutar login):**

```bash
claude mcp add notebooklm -s local -- npx -y notebooklm-mcp@latest
```

Ya está en el config local de Claude Code de este proyecto (`claude mcp get notebooklm` →
conectado como proceso, pero SIN sesión de NotebookLM todavía).

**Paso que SOLO puede hacer Anthony (no delegable a un agente):**

1. Abrir una sesión de Claude Code (o el cliente MCP que sea) con el server `notebooklm` activo.
2. Pedirle a la IA que invoque la tool `setup_auth` (o correr `npx notebooklm-mcp@latest setup-auth`
   desde una terminal en su propia máquina).
3. Se abre un Chrome visible → Anthony inicia sesión con su cuenta Google real (o una cuenta
   dedicada/desechable de Google para minimizar riesgo, recomendado).
4. Aceptar el riesgo de ToS explícitamente antes de este paso — es su decisión, no la de un agente.

Si Anthony decide NO asumir ese riesgo, la alternativa segura ya cubierta es `graphify` +
`codegraph` + el vault Obsidian — cubren búsqueda semántica, grafo de conocimiento y grafo de
código sin tocar ningún servicio de Google.

## 6 · Checklist de arranque para un agente NUEVO (cualquier IDE/CLI)

1. Lee `https://vps.cescac.com/cerebro/index.php` (manifiesto).
2. Lee `?doc=contexto-maestro`, `?doc=reglas`, `?doc=memoria`.
3. Lee `?doc=agentes-roles` — confirma cuál es TU rol/tier en el ecosistema y de qué te
   abstienes antes de tomar cualquier tarea (detalle en §8 de este documento).
4. Conecta `graphify` MCP (o usa el CLI `python -m graphify query "..."`) para preguntas de
   "cómo se conecta X con Y" en todo el repo (código + docs).
5. Conecta `obsidian` MCP apuntando a `obsidian_cescac/` para leer/crear notas del vault único.
6. Si vas a tocar código con frecuencia, conecta `codegraph` (`codegraph install --print-config <tu-id>`)
   para no gastar tool calls leyendo archivos completos.
7. NotebookLM: NO asumas que está disponible. Si necesitas research con citas, usa
   `firecrawl`/`WebSearch`/`WebFetch` hasta que Anthony complete `setup_auth`.
8. Cierre 5-campos siempre + registro en `docs/REGISTRO_CAMBIOS_CORE.md`.

## 7 · TABLERO DE TAREAS multiagente — coordinación real (añadido 2026-07-17)

> Antes de esto NO existía un tablero compartido real: "MCP cescac-omega" (`mcp.cescac.com`)
> **nunca se desplegó** — no hay forma de disparar tareas por API a Cursor/Codex/Antigravity/
> Hermes. Lo que sí existe y funciona HOY es un tablero **PULL**: un archivo que todos pueden
> leer, y que cada agente actualiza cuando toma o cierra una tarea. Evidencia real de por qué
> hacía falta: las 4 tareas asignadas el 2026-07-10 a Cursor/Codex/Antigravity/Hermes en
> `TASK_QUEUE.md` (outliers de precio, tests de comisiones, QA responsive, monitoreo 404) nunca
> generaron el entregable esperado — nadie tenía un lugar único, estructurado y fácil de leer
> donde ver "qué está libre" sin releer todo el `TASK_QUEUE.md` histórico.

### 7.1 Dónde está

| Qué | Ruta |
|---|---|
| Fuente canónica (on-box, editable) | `/home/admin/web/admin-docs/memory-bank/tablero_agentes.json` |
| Espejo público JSON (lectura externa) | `https://vps.cescac.com/cerebro/tablero_agentes.json` |
| Espejo público Markdown legible | `https://vps.cescac.com/cerebro/index.php?doc=tablero-agentes` |
| Helper — solo tareas libres (owner=null) | `https://vps.cescac.com/cerebro/tablero.php` |
| Helper con filtros | `https://vps.cescac.com/cerebro/tablero.php?estado=pendiente\|en_progreso\|bloqueado\|hecho`, `?owner=DUENO\|libre\|ClaudeCode\|Cursor\|Codex\|Antigravity\|Hermes`, `?prioridad=P0..P3`, `?formato=json` |

Ambos espejos (`memory-bank/` on-box y `cerebro/` público) deben mantenerse sincronizados a
mano tras cada edición — mismo patrón que el grafo de `graphify` (sección 3): editar el
canónico, copiar con backup al espejo público.

### 7.2 Esquema de cada tarea (JSON)

```json
{
  "id": "T-EJEMPLO",
  "titulo": "...",
  "descripcion": "...",
  "servicio": "SM | Contable | CRM | Vendedores | Marketing | Infraestructura | ...",
  "prioridad": "P0 | P1 | P2 | P3",
  "tier_sugerido": "haiku | sonnet | opus",
  "estado": "pendiente | en_progreso | bloqueado | hecho",
  "owner": null,
  "depende_de": [],
  "fuente": "archivo/doc donde se originó",
  "notas": "..."
}
```

`owner: null` = libre para tomar. `owner: "DUENO"` = nadie la puede tomar, espera acción humana
no delegable (credenciales, decisión de negocio, acceso físico). `owner: "<AgenteX>"` = tomada.

### 7.3 Protocolo de coordinación (simple, sin infraestructura nueva)

1. **LEE** — cualquier agente hace `curl https://vps.cescac.com/cerebro/tablero.php` (o el JSON
   completo) al arrancar sesión, como parte del boot normal (junto con `contexto-maestro`,
   `reglas`, `memoria`).
2. **TOMA** — si vas a trabajar una tarea con `owner: null`, edita el JSON canónico en el VPS:
   `owner` → tu nombre de agente, `estado` → `en_progreso`. Backup previo obligatorio
   (`tablero_agentes.json.bak_YYYYMMDD_HHMM`). Sincroniza el espejo público inmediatamente
   después (ver 7.1).
3. **NO PISES** — nunca tomes una tarea cuyo `owner` ya sea distinto de `null` y `DUENO` con
   `estado: en_progreso`. Si crees que quedó abandonada (mismo owner, sin cambios en varios
   días), avísalo en `docs/REGISTRO_CAMBIOS_CORE.md` en vez de sobrescribir en silencio.
4. **REPORTA** — al cerrar: `estado` → `hecho`, agrega una línea a `notas` con qué se hizo y
   dónde queda la evidencia, y registra el cierre en `docs/REGISTRO_CAMBIOS_CORE.md` (formato
   `AGT-<tuID>`) con el cierre de 5 campos de siempre.
5. Si una tarea queda **bloqueada** por algo que no puedes resolver, cambia `estado` →
   `bloqueado` y dilo explícitamente en `notas` (qué falta, quién debe resolverlo).

### 7.4 Limitación honesta — léela antes de asumir que esto es un orquestador real

**Esto NO controla a los otros agentes.** No existe forma de disparar tareas por API a
Cursor/Codex/Antigravity/Hermes — no hay webhook, no hay push, no hay notificación. Es un
tablero **PULL**: cada agente solo lo lee cuando el dueño lo enciende y le pide trabajar. Si
un agente no se conecta en varios días, sus tareas asignadas simplemente quedan esperando —
exactamente lo que ya pasó con las 4 tareas del 2026-07-10 descritas arriba.

**Lo que SÍ logra:** que cuando dos o más agentes SÍ están activos en la misma ventana de
tiempo, no se pisen (ven el mismo `owner` en el mismo archivo), y que el dueño tenga una vista
única del estado real de todo lo pendiente sin tener que releer el histórico completo de
`TASK_QUEUE.md`. Es coordinación, no automatización — el dueño sigue siendo el que "enciende"
cada agente.

## 8 · ROLES/TIERS de cada agente + prompt de onboarding (añadido 2026-07-17)

> Este documento (§0-7) cubre CÓMO conectar herramientas al cerebro. Faltaba formalizar QUIÉN
> es cada agente, a qué se dedica y de qué se abstiene — eso vive ahora en dos documentos
> hermanos, para no duplicar contenido aquí:

- **`https://vps.cescac.com/cerebro/index.php?doc=agentes-roles`** — tiers de modelo (Ollama
  gratis → LiteLLM barato → Sonnet/Opus premium) con ejemplos reales; rol exacto de cada
  sub-agente Claude Code (`cescac-haiku-fast` = lecturas/validaciones/SÍ-NO,
  `cescac-sonnet-normal` = codificar/contenido/edits medianos, `cescac-opus-critical` =
  arquitectura/auditoría/decisiones críticas — planifica pero NO hace escritura pesada, la
  delega) — qué hace y de qué se ABSTIENE cada uno; reglas de delegación (cuándo inline vs.
  spawnear, nunca dos agentes en el mismo archivo crítico, backup+registro siempre, verificar
  SIEMPRE desde afuera, nunca exponer secretos, PHI y pagos = máximo cuidado); y qué hace mejor
  cada agente externo (Cursor = ejecuta lo que el clasificador de Claude Code bloquea, Codex =
  "Claude planea → Codex ejecuta", Antigravity = exploración/dashboards, Hermes = orquestador
  24/7 de monitoreo).
- **`https://vps.cescac.com/cerebro/index.php?doc=prompt-onboarding-agentes`** — el PROMPT
  exacto, uno por agente externo (Cursor/Codex/Antigravity/Hermes), listo para que el dueño lo
  pegue como primer mensaje de cualquier sesión nueva: lee el cerebro → lee el tablero → toma
  una tarea libre de su tier/fuerte → respeta reglas/backups/registro → reporta.

Léelos ANTES de tomar una tarea del tablero (§7) si es la primera vez que trabajas en este
ecosistema — evita que un agente tome trabajo fuera de su rol o queme un tier caro en algo
mecánico.

---

## 8 · Sincronía anti-pisado + aprendizaje (guía dedicada)

Protocolo completo de cómo NO pisarse entre agentes (lock atómico `scripts/agente_lock.sh`), dónde escribe cada agente al cerrar, y cómo aprende el flujo (error → lecciones.md → prohibido repetir): ver **`FLUJO_SINCRONIA_AGENTES.md`** (repo + `https://vps.cescac.com/cerebro/FLUJO_SINCRONIA_AGENTES.md`).