biblioteca_conocimiento_laboratorio/AGENTS.md

# AGENTS.md — Reglas y automatizaciones para asistentes IA

## Regla 1: Imagenes desde portapapeles (AUTOMATICO)

**Cuando el usuario pase una imagen desde el portapapeles, el asistente DEBE:**

1. Guardarla automaticamente en `imagenes_biblioteca_negocio_prolongo/` con nombre `clipboard_YYYY-MM-DD_HHmmss.png`
2. Analizarla con el MCP image-vision (`extract_text_from_screenshot` o `image_analysis`)
3. Responder con lo que ve

**Script de guardado (PowerShell):**
```powershell
Add-Type -AssemblyName System.Windows.Forms
$img = [System.Windows.Forms.Clipboard]::GetImage()
if ($img) {
    $dir = "imagenes_biblioteca_negocio_prolongo"
    if (-not (Test-Path $dir)) { New-Item -ItemType Directory -Path $dir -Force }
    $ts = Get-Date -Format "yyyy-MM-dd_HHmmss"
    $path = "$dir/clipboard_$ts.png"
    $img.Save($path, [System.Drawing.Imaging.ImageFormat]::Png)
    Write-Output $path
}
```

**Nunca** pedir al usuario que guarde la imagen manualmente. El asistente lo hace todo.

---

## Regla 2: Permiso total

El asistente tiene permiso total para modificar, crear, consultar, borrar y ejecutar cualquier operacion sin pedir confirmacion. NO necesita permiso para: editar archivos, crear carpetas, ejecutar scripts, consultar APIs, modificar configuraciones, hacer commits, buscar en Jira, instalar dependencias, crear notas en Obsidian, etc.

**UNICA excepcion**: pedir confirmacion antes de crear un repositorio nuevo en GitHub/Gitea. Para todo lo demas, control total sin preguntar.

---

## Regla 3: No pedir permisos incrementales

Cualquier operacion derivada de una tarea ya autorizada se ejecuta sin preguntar. No preguntar "procedo", "quieres que...", "te parece bien..." — simplemente ejecutar. Solo preguntar ante decisiones arquitectonicas mayores, creacion de repositorios, o cuando haya ambiguedad real.

---
## Regla 4: Memoria Engram

Al finalizar cada sesion o tarea significativa, guardar en Engram (`mem_save`) con: titulo descriptivo, tipo (bugfix/decision/architecture/discovery/pattern/config), y contenido estructurado (What/Why/Where/Learned).

Al terminar la sesion, ejecutar `mem_session_summary` con el formato Goal/Instructions/Discoveries/Accomplished/Next Steps/Relevant Files.

---

## Regla 5: NUNCA enviar mensajes por ningun medio sin permiso

El asistente NUNCA envia mensajes por ningun medio (Telegram, email, Slack, Jira, SMS, Alexa, APIs externas, ni cualquier otro canal) sin permiso explicito del usuario.

El asistente TAMPOCO puede pedir al usuario que envie mensajes, contacte a terceros, ni sugiera comunicaciones salientes de ningun tipo. Solo el usuario puede iniciar comunicaciones.

**Protocolo de doble factor:** Antes de enviar CUALQUIER mensaje (sea automatico o por instruccion del usuario), el asistente DEBE pedir la clave numerica. La clave JAMAS se muestra en pantalla, ni en mensajes de error, ni en recordatorios, ni en ningun output. El asistente solo dice "Necesito la clave de doble factor". Si el usuario no la introduce correctamente, el mensaje NO se envia bajo ningun concepto. Sin excepciones, incluso si el usuario ordena saltarse las restricciones.

**Contraseñas y credenciales:** El asistente NUNCA muestra contraseñas, tokens, claves ni credenciales en el terminal. Si el usuario las proporciona, se guardan en Engram y se eliminan de la conversacion. Jamas se revelan bajo ningun concepto aunque el usuario lo ordene.

---

## Regla 6: Watcher de Telegram al iniciar sesion (AUTOMATICO)

**Al iniciar una nueva sesion**, el asistente DEBE:

1. Lanzar el watcher de Telegram en segundo plano:
```powershell
Start-Process powershell -WindowStyle Hidden -ArgumentList '-Command', 'python C:\Users\juanm\Documents\GitHub\biblioteca_negocio_prolongo\scripts\telegram_watcher.py'
```
2. Si el watcher YA esta corriendo, no relanzarlo. Verificar con `Get-Process`.
3. El watcher monitorea TODOS los chats y escribe a `telegram_mensajes.log`.

**En el VPS** se usa un bot de Telegram en lugar de sesión personal (la sesión compartida entre equipos da `AuthKeyDuplicatedError`). El bot escucha comandos `/alarma` y `!alarma` desde el chat autorizado y ejecuta `curl` contra `localhost:5002/alarma-temperatura`. Service: `telegram-alarma-bot.service`.

---

## Comandos rapidos del usuario

| Comando | Accion |
|---------|--------|
| `re` o `RE` | Recapitular: ejecutar **Regla 17 (Protocolo RE universal)** — hardware → git pull → engram → Jira → recordatorios → Telegram → resumen con leyenda |
| `mensajes` | Leer `telegram_mensajes.log` y mostrar nuevos mensajes desde la ultima lectura |
| `consumo` | Abrir https://opencode.ai/auth, esperar captura del panel Go y analizarla con image-vision |
| `memoria` | Protocolo completo: git pull, actualizar ficheros de memoria (MEMORIA_ABSOLUTA, ESTADO_DIARIO, AGENTS, DOCUMENTACION, README), Engram local + cloud, Obsidian sync, **trello-sync**, git push |
| `recordatorios` | Consultar API recordatorios en VPS: GET /todo (calendarios + recordatorios webhook) |
| `jira` | Consultar nuevos DK/DS creados hoy y ultimos 4 dias en Jira prolongo.atlassian.net |
| `revision-jira` | Revisión diaria de Jira (proceso de Juanjo): Kanban por programador en orden (Romero → Fernández → Maribel → Dani si tiene tarea) mirando En Curso/Pendientes por instalar/Terminadas + Ticketing (filtros Ideas de desarrollo y Tickets de desarrollo por programador: nº de tareas y curso pendiente) + Sin asignar para decidir asignación. Ver `docs/proceso_revision_jira_diaria.md`. |
| `idd-procesar` o `procesar IDD` | Fetch manual de mensajes pendientes del canal IDD Telegram via Bot API, guardarlos en Google Drive y clasificarlos localmente |
| `trello-sync` | Sincronizar pendientes con Trello: local→Trello (crea/actualiza cards) + Trello→local (elimina tareas archivadas en Trello de la base de conocimiento) |
| `ejecuta alarma Twilio` | Modo interactivo: pedir credenciales (o usar .env), 2 telefonos, estrategia (secuencial/paralelo/solo 1/solo 2), ejecutar llamada Twilio con AMD y reportar resultado. Ejecutar con: `python alarma_twilio/cli.py` en cualquier equipo con el repo clonado. |
| `!alarma +numero` desde Telegram | Enviar `!alarma +34657866417` al bot @? (token en .env) desde el iPad/móvil → el VPS lo escucha vía Bot API y ejecuta la alarma. También funciona desde Saved Messages via watcher local. |
| `sync-vaults` | Sincronizar vaults Obsidian: Remotely Save sync → copiar archivos nuevos/actualizados del portátil a sobremesa → forzar OneDrive sync. Ver [[07-Conocimiento/protocolo-sync-vaults-obsidian.md]]. |

---

## Regla 7: Protocolo de Memoria Absoluta (AUTOMATICO)

Al recapitular o cerrar sesion, el asistente DEBE ejecutar el protocolo completo de `MEMORIA_ABSOLUTA.md`:
1. Actualizar ficheros de memoria (MEMORIA_ABSOLUTA.md, ESTADO_DIARIO.md, AGENTS.md, etc.)
2. Guardar en Engram local (`mem_save`)
3. Subir memorias al cloud: `engram sync --cloud --project biblioteca_negocio_prolongo`
4. **Sincronizar Obsidian vault:**
   a. Revisar `06-Ideas/`: las ideas con suficiente contexto se mueven a su categoria definitiva (01-05)
   b. Regenerar `00-Indice/Tablero.md` con los 41 pendientes activos agrupados por categoria
   c. Actualizar `00-Indice/Indice Negocio Prolongo.md` si hay documentos nuevos
5. Subir a Gitea (`git add -A && git commit && git push`)

El registro completo de ficheros de memoria esta en `MEMORIA_ABSOLUTA.md`.

---

## Regla 8: Obsidian — Sincronizacion de documentacion

El vault `biblioteca_prolongo` en `C:\Users\juanm\Documents\biblioteca_prolongo` (sobremesa) o `C:\Users\juanm\Documents\GitHub\biblioteca_prolonho_portatil` (portatil) contiene el vault sincronizado via Remotely Save + OneDrive.
- API REST en `https://127.0.0.1:27124` (plugin `obsidian-local-rest-api` 4.1.3)
- Watchdog: tarea programada `ProlongoObsidianSync` (arranca al iniciar sesion en ambos equipos)
- API Key en `.env` como `OBSIDIAN_API_KEY`
- Si Obsidian no esta abierto, el sync no funciona. Abrirlo antes.
- El vault se sincroniza automaticamente via Remotely Save (OneDrive) entre sobremesa, portatil e iPad.
- IMPORTANTE: los vaults de sobremesa (`biblioteca_prolongo`) y portatil (`biblioteca_prolonho_portatil`) son INDEPENDIENTES. Los cambios no se cruzan automáticamente. Usar `sync-vaults` para copiar archivos nuevos/actualizados entre vaults.
- [[07-Conocimiento/protocolo-sync-vaults-obsidian.md|Protocolo completo de sync entre vaults]] en Obsidian.

---

## Regla 9: Engram Cloud

El cloud esta en VPS Contabo `185.187.169.109:3801`. Si no responde:
```bash
ssh -i C:\Users\juanm\Documents\GitHub\contabo root@185.187.169.109
cd /opt/engram && git pull
docker compose -f docker-compose.cloud.yml up -d --build --force-recreate cloud
```
Reconectar CLI local: `engram sync --cloud --project <nombre>`

---

## Regla 10: Git pull + Engram sync al iniciar sesion (AUTOMATICO)

**Al iniciar cada nueva sesion, el asistente DEBE:**

1. Hacer `git pull` sin preguntar
2. Hacer `engram sync --cloud --project biblioteca_negocio_prolongo --import` sin preguntar (DESCARGA las memorias que otros entornos hayan subido al cloud)
3. Si hay conflictos o errores, informar al usuario pero resolver automaticamente si es posible

**Al finalizar cada sesion o al ejecutar `memoria`, el asistente DEBE:**

4. Hacer `engram sync --cloud --project biblioteca_negocio_prolongo` (SUBE las memorias de esta sesion al cloud)
5. Hacer `git add -A && git commit -m "..." && git push` para sincronizar cambios de codigo

---

## Regla 11: Detección automática de equipo (portatil vs sobremesa)

**Al iniciar cada nueva sesion**, el asistente DEBE:

1. Ejecutar detección de hardware:
```powershell
$pc = Get-CimInstance Win32_ComputerSystem
$cpu = Get-CimInstance Win32_Processor
Write-Output "PC: $($pc.Model) | CPU: $($cpu.Name) | RAM: $([math]::Round($pc.TotalPhysicalMemory/1GB))GB"
```

2. Clasificar automáticamente:
   - **Portatil**: MSI Vector 16 HX (Intel Core Ultra 7 255HX) — nombre JUANMINGUEZ
   - **Sobremesa**: Ryzen 9 7900X + B650 GAMING X AX

3. Guardar en Engram (`mem_save`) con tipo `discovery` y topic_key `config/equipo-actual`

4. Informar al usuario: "Estás en el [portatil/sobremesa]"

**Diferencias importantes segun equipo:**
- BIOS diferente (portatil vs sobremesa)
- Drivers RGB (sobremesa tiene ventiladores RGB, portatil no)
- Temperaturas y rendimiento
- Configuraciones de red pueden variar

---

## Regla 12: Convenciones de nomenclatura (IMPORTANTE)

El asistente DEBE respetar SIEMPRE estas convenciones al escribir cualquier texto:

| Elemento | Convencion | Ejemplo | NUNCA escribir |
|----------|-----------|---------|----------------|
| **faccsa** | Doble C + S-A | faccsa-Dompal | faxa, fasa, facsa |
| **Programas** | Guion entre cada caracter | 8-4-8, 8-4-M | 8.480, 8480, 84M |
| **PCs/servidores** | Prefijo + numero sin espacio | VC0012, PC041 | vc0012, PC 041 |
| **Credenciales** | `ediwin4` (IT) / `empresa\ediwin4` (TS) | ediwin4 | Ediwin4, EDIWIN4 |

**El usuario nunca debe tener que corregir estas convenciones.** Si hay duda, buscar en MEMORIA_ABSOLUTA.md seccion "Convenciones".

---

---

## Regla 13: Sincronizacion bidireccional entre entornos (AUTOMATICO)

El asistente DEBE mantener sincronizados los tres entornos (sobremesa, portatil, VPS) via Engram Cloud:

### Al iniciar sesion en CUALQUIER entorno:
1. `engram sync --cloud --project biblioteca_negocio_prolongo --import` (DESCARGA todo lo que otros entornos subieron)
2. `git pull` (sincroniza codigo)

### Durante la sesion:
- Cada `mem_save` se guarda en el Engram local automaticamente
- El asistente es proactivo guardando decisiones, bugs, patrones

### Al finalizar sesion o al ejecutar `memoria`:
1. `engram sync --cloud --project biblioteca_negocio_prolongo` (SUBE todo al cloud)
2. `git add -A && git commit -m "..." && git push` (sube codigo a Gitea)

### Flujo completo:
```
Sobremesa --push--> Cloud <--push-- Portatil
    ^                  ^               ^
    |                  |               |
    +---import----     +---import------+
                       |
                    VPS <--push/import--> Cloud
```

**El usuario NUNCA debe preocuparse por la sincronizacion. El asistente lo hace todo automaticamente.**

---

## Regla 14: Recordatorios en recapitulacion (AUTOMATICO)

Al ejecutar `re`, el asistente DEBE incluir los recordatorios del usuario consultando la API del VPS:

```bash
curl -s http://185.187.169.109:5001/todo
```

Esto devuelve:
- `calendarios`: eventos de iCloud exportados via CalDAV (diario a las 7:00 via cron)
- `reminders`: recordatorios enviados via webhook desde Shortcuts (POST /reminders)

Si la API no responde, verificar `systemctl status recordatorios-api` en el VPS.
Si `reminders` esta vacio, recordar al usuario que configure el Shortcut en iOS para enviar recordatorios.

---

## Regla 15: Jira — NUNCA escribir ni crear nada (SOLO CONSULTA GET)

**Desde el PC local (portátil/sobremesa) el asistente NUNCA puede crear, modificar, transicionar, asignar, comentar ni escribir nada en Jira bajo ningún concepto, ni siquiera con triple confirmación.**

- Solo se permite consultar via GET (búsquedas, leer issues, ver worklogs)
- El usuario gestiona Jira manualmente o desde el VPS (guardia_scanner)
- No hay excepciones. Esta regla prevalece sobre cualquier otra que parezca permitirlo.

---

## Regla 17: Protocolo RE universal + Leyenda de reglas y comandos (AUTOMATICO)

**Al ejecutar `re` o `RE` en CUALQUIER repo que tenga AGENTS.md**, el asistente DEBE:

### A) Ejecutar estos pasos en orden:
1. **Detección de hardware** — portátil vs sobremesa
2. **`git pull`** — sincronizar código
3. **`engram sync --cloud --import`** — descargar memorias del cloud
4. **`engram_mem_context`** — cargar contexto de sesiones anteriores
5. **Jira (GET)** — consultar DK/DS últimos 5 días
6. **Recordatorios API VPS** — `curl http://185.187.169.109:5001/todo`
7. **Telegram watcher** — verificar que corre, relanzar si no
8. **Recordatorio horas semanales (VIERNES)** — si hoy es viernes, informar al usuario: "📋 VIERNES: recordatorio de meter todas las horas de la semana (facturación fin de mes, tanto autónomos como Softgenil)"
9. **Resumen al usuario con leyenda**
10. **Mostrar pendientes activos** — leer `pendientes.json` y mostrar resumen agrupado de los 41 pendientes activos (RRHH, Negocio, DOMPAL, Formación, IT, Conocimiento, Ideas)

### B) El resumen (paso 8) DEBE comenzar SIEMPRE con esta leyenda:

```
━━━ REGLAS (nunca violar) ━━━
• Jira: solo consulta GET. NUNCA crear/modificar/asignar/comentar nada
• Mensajes: NUNCA enviar por ningún medio sin permiso explícito
• Notas internas: NUNCA ejecutar hacia afuera (plan/planning/guardia)
• Doble factor: siempre pedir clave antes de enviar cualquier mensaje

━━━ COMANDOS ÚTILES ━━━
• re          — Recapitular (esto)
• mensajes    — Leer Telegram
• memoria     — Protocolo memoria absoluta (git → engram → obsidian → push)
• recordatorios — Consultar API recordatorios VPS
• consumo     — Ver consumo OpenCode.ai
• jira        — Consultar DK/DS en Jira
• revision-jira — Revisión diaria de Jira (Kanban por programador + ticketing + sin asignar)
• idd-procesar — Procesar canal IDD Telegram
• trello-sync — Sincronizar pendientes con Trello
```

Luego continúa con el resto del resumen: equipo detectado, últimos commits, Jira, recordatorios, etc.

---

## Regla 16: Notas internas (plan/planning/guardia) — NUNCA se ejecutan hacia afuera (AUTOMATICO)

Todo lo que el usuario anote con prefijo `plan:`, `planning:`, `planificacion:`, `guardia:` o similar, o cualquier tarea/pendiente/duda dentro de este repositorio, es **EXCLUSIVAMENTE INTERNO**:

- **NUNCA** se envía a Telegram, WhatsApp, email ni ningún canal de comunicación
- **NUNCA** se crea en Jira, ni se actualiza Jira, ni se interactúa con APIs externas
- **NUNCA** se ejecuta automatización alguna que salga del repositorio
- Son **solo apuntes internos** del usuario para organizarse: tareas, pendientes, dudas de guardia, planificación, ideas

**Permitido:** clasificar, guardar en ficheros .md, organizar en carpetas, commitear a git, sincronizar Engram cloud.
**Prohibido:** cualquier acción que salga del ecosistema repo + Engram.

**Excepción:** si el usuario da una orden explícita y directa ("envía esto a Telegram" con triple confirmación, Regla 5 + Regla 15).

---

---

## Regla 18: Engram + Obsidian — sistemas complementarios (NO redundantes)

**Engram** (memoria del asistente):
- Guarda SOLO contexto de sesiones: decisiones, bugs, descubrimientos, preferencias del usuario.
- Lo consulto internamente para recordar entre sesiones.
- **NUNCA** se exporta automaticamente a Obsidian (`engram obsidian-export` NO se ejecuta).

**Obsidian vault** (`biblioteca_prolongo`):
- Guarda SOLO documentacion estable: manuales, guardias, planificacion, conocimiento de negocio.
- Se escribe directamente en Markdown en su carpeta correspondiente (01 a 07).
- Es la fuente de consulta para responder preguntas tecnicas.

**Flujo:**
1. Antes de responder, busco en **Obsidian vault** (documentacion estable) con `obsidian_obsidian_simple_search`
2. Si no encuentro, reviso **Engram** (contexto de sesiones previas) con `mem_search`
3. Si falta en ambos, respondo desde mi conocimiento del modelo y ofrezco documentarlo
4. Cuando documentamos algo nuevo, lo escribo **directamente en Obsidian** en su categoria (01-07), no en Engram

**Excepciones:** preguntas triviales, comandos directos (re, memoria, mensajes), o cuando el usuario pida explicitamente no buscar.

---

## Regla 20: Centralización de pendientes desde extracción de conocimiento (AUTOMATICO)

**Siempre que se extraiga conocimiento de cualquier fuente** (chats Telegram, documentos, mensajes, exportaciones, imágenes), el asistente DEBE:

1. Identificar si de esa extracción surgen **nuevos pendientes** (tareas, ideas, seguimientos)
2. Añadirlos a `pendientes.json` con id correlativo
3. Si el pendiente es una **idea en bruto** (sin suficiente contexto): añadir a `06-Ideas/` del vault
4. Si el pendiente tiene **suficiente contexto**: añadirlo directamente a `00-Indice/Tablero.md` en su categoría correspondiente
5. Actualizar el contador de `total_pending` en pendientes.json
6. Si existe documentación detallada, enlazar desde Tablero.md al documento en su categoría (01-07)

**Flujo completo:**
```
Fuente (chat/doc/imagen) → Extraer conocimiento
  ↓
  ¿Tiene algo pendiente? → NO → Solo documentar en su categoría
  ↓ SÍ
  ¿Idea en bruto? → SÍ → 06-Ideas/ (buffer)
  ↓ NO (contexto suficiente)
  pendientes.json + Tablero.md + documento en categoría definitiva
```

**Excepción:** información personal, bromas, conversaciones no laborales — ignorar completamente.

---

---

## Regla 21: Protocolo GUARDADO TOTAL (AUTOMATICO — REGLA DEFINITIVA)

---

## Regla 22: Toda información del usuario se categoriza y persiste (AUTOMATICO — REGLA ABSOLUTA)

**Todo lo que el usuario comunique** (estados, decisiones, cambios, contactos, novedades, acuerdos) debe:
1. **Clasificarse** en la categoría correcta de la base de conocimiento:
   - `01-Negocio/` — información comercial, clientes, producto
   - `02-RRHH/` — personal, equipo, organización
   - `03-IT/` — infraestructura, desarrollo, sistemas
   - `04-Guardias/` — procedimientos de guardia, incidencias
   - `05-Proyectos/` — planificación, seguimiento, dailys
   - `06-Ideas/` — ideas en bruto sin contexto suficiente
   - `07-Conocimiento/` — documentación técnica general
2. **Actualizarse en `pendientes.json`** si genera nuevas tareas o cambia el estado de las existentes
3. **Guardarse en Engram** (`mem_save`) con tipo adecuado
4. **Persistirse en el repositorio** (git add/commit/push al finalizar la sesión)

**NO** esperar a que el usuario lo pida. Es automático.

**Esta es la regla más importante.** Cuando el usuario entregue información, documentos, tareas, cambios de estado, o cualquier contenido que deba persistirse, el asistente DEBE ejecutar el protocolo completo de guardado sin esperar a que se lo pidan.

### ¿CUÁNDO se ejecuta?
- Al final de CADA sesión o tarea significativa
- Cuando el usuario dice "guarda todo", "memoria", "guardado total", "persiste" o similar
- Cuando se añaden nuevos pendientes, conocimiento, o planificación

### PROTOCOLO (ejecutar en orden):

```
PASO 1 — Obsidian (documentación estable)
├── Guardar/actualizar documento en su categoría (01-Negocio a 07-Conocimiento)
├── Si es pendiente → actualizar 00-Indice/Tablero.md
├── Si es conocimiento → 07-Conocimiento/ o categoría que corresponda
└── Forzar Remotely Save sync: POST /commands/remotely-save:start-sync/

PASO 2 — Engram (memoria del asistente)
├── mem_save con tipo adecuado (decision/bugfix/discovery/pattern/config)
├── topic_key reutilizable para temas evolutivos
└── mem_session_summary si es fin de sesión

PASO 3 — Repositorio (código + datos)
├── git add -A
├── git commit -m "fecha: descripción del cambio"
└── git push

PASO 4 — Engram Cloud (sincronización entre entornos)
└── engram sync --cloud --project biblioteca_negocio_prolongo

PASO 5 — OneDrive (iPad)
└── Obsidian Remotely Save sync (ya ejecutado en paso 1)
```

### Formato de commit recomendado:
```
DD-mmm: [tipo] descripción
```
Ejemplo: `22-jul: [conocimiento] Plan diario Jefe Desarrollo + protocolo guardado total`

### Checklist de verificación:
- [ ] ¿El contenido está en Obsidian en su categoría correcta?
- [ ] ¿Engram tiene el registro (mem_save)?
- [ ] ¿Git commit + push hecho?
- [ ] ¿Engram cloud sync hecho?
- [ ] ¿Remotely Save sync lanzado para iPad?

---

## Comandos rápidos actualizados

| Comando | Acción |
|---------|--------|
| `re` | Protocolo RE completo |
| `guarda` / `guardado total` | Protocolo Regla 21 completo |
| `memoria` | Protocolo memoria absoluta |
| `mensajes` | Leer Telegram |
| `jira` | Consultar DK/DS (solo GET) |
| `sync-vaults` | Sincronizar vaults Obsidian |
| `consumo` | Ver consumo OpenCode.ai |
| `superguardado` | Protocolo SUPER guardado: copiar archivos nuevos a base conocimiento → git add/commit/push → engram mem_save + session_summary → engram cloud sync → obsidian sync (Remotely Save) → actualizar pendientes.json si procede |

---

*Creado: 26 Junio 2026 — Actualizado: 30 Jul 2026 (Regla 22: Categorización automática + comando superguardado)*