Mnemoclaw/immune

Sistema Immune v5.1 — Cheatsheet + Immune Híbrido

Operas un sistema adaptativo híbrido con dos memorias complementarias:

• Cheatsheet (patrones positivos): estrategias específicas de dominio inyectadas ANTES de la generación para mejorar la calidad del output
• Immune (patrones negativos): anticuerpos que detectan errores conocidos y descubren nuevas amenazas DESPUÉS de la generación

Ambas memorias usan un sistema de niveles Hot/Cold para mantener el contexto ligero. Todo el acceso a datos se realiza a través de la CLI adaptadora (node ~/.claude/skills/immune/immune-adapter.js).

Análisis de Entrada

El usuario invoca el sistema con contenido a escanear. Analiza estos parámetros:

• input: El texto/código/contenido a escanear (obligatorio — ya sea en línea o desde el contexto)
• domain: Uno de: fitness, code, writing, research, strategy, webdesign, _global (por defecto: detección automática)
• domains: Array de dominios (anula el dominio único). Ejemplo: domains=fitness,code
• constraints: Cualquier requisito específico que el output debe satisfacer (opcional)
• mode: full (cheatsheet + escaneo, por defecto) | scan-only (saltar cheatsheet) | cheatsheet-only (devolver solo cheatsheet, sin escaneo)

Si no se proporciona texto en línea, escanea el último output sustancial de la conversación.

Detección automática de dominio: Lee ~/.claude/skills/immune/config.yaml y compara el contenido con domain_keywords. Si no hay una coincidencia sólida, usa ["_global"]. Si se proporciona un único domain como cadena, envuélvelo en un array: domains = [domain].

Ejecución

Paso -1 — Búsqueda de Contexto (conciencia de sesiones pasadas)

Busca sesiones relevantes pasadas para informar el escaneo actual:

node ~/.claude/skills/immune/immune-adapter.js get-context --query "{palabras clave de la tarea o dominio}" --days 90 --limit 5

Si se encuentran resultados, anota patrones recurrentes o problemas pasados para el dominio. Esto enriquece el escaneo con conocimiento histórico; el escáner sabrá si contenido similar fue marcado antes.

Registra: [IMMUNE] Contexto: {count} sesiones relevantes encontradas

Paso 0 — Inyección de Cheatsheet (patrones positivos)

Salta este paso si mode == "scan-only".

0a. Cargar estrategias HOT a través del adaptador:

Ejecuta:

node ~/.claude/skills/immune/immune-adapter.js get-strategies --domains '{domains_json}' --tier hot --limit 15

Analiza el output JSON. El adaptador devuelve estrategias pre-filtradas por dominio, clasificadas como HOT, ordenadas por efectividad descendente y limitadas a 15.

0b. Cargar resumen de estrategias COLD:

Ejecuta:

node ~/.claude/skills/immune/immune-adapter.js get-strategies --domains '{domains_json}' --tier cold

Extrae una palabra clave corta del campo pattern de cada estrategia COLD. Únelas como lista separada por comas.

0c. Construir bloque cheatsheet: Formatea las estrategias HOT como XML:

<cheatsheet domain="{domains}">
  <strategy id="{id}" effectiveness="{effectiveness}">
    {pattern}
    Ejemplo: {example}
  </strategy>
  ...
</cheatsheet>

Si hay estrategias COLD, añade una línea:

<cheatsheet_cold>También considera: {palabras clave COLD separadas por comas}</cheatsheet_cold>

Si mode == "cheatsheet-only", genera el bloque cheatsheet y detente aquí.

Registra:

[IMMUNE] Cheatsheet: {n_hot} HOT + {n_cold} COLD estrategias (dominios: {domains})

0d. Presentar el cheatsheet al usuario: Si se ejecuta de forma independiente (/immune), muestra el cheatsheet como contexto que el usuario debe aplicar a su próxima generación. Si lo llama Chimera, devuelve el bloque XML para inyectarlo en los prompts PRISM.

Paso 1 — Cargar y Clasificar Anticuerpos (Hot/Cold)

1a. Cargar anticuerpos HOT a través del adaptador:

Ejecuta:

node ~/.claude/skills/immune/immune-adapter.js get-antibodies --domains '{domains_json}' --tier hot --limit 15

El adaptador devuelve anticuerpos pre-filtrados por dominio, clasificados como HOT (severity=critical O seen_count>=3 O last_seen<30d), ordenados por severidad y luego seen_count, limitados a 15.

1b. Cargar resumen de anticuerpos COLD:

Ejecuta:

node ~/.claude/skills/immune/immune-adapter.js get-antibodies --domains '{domains_json}' --tier cold

Para cada anticuerpo COLD, extrae una palabra clave corta de su campo pattern. Únelas como lista separada por comas.

Registra:

[IMMUNE] División de niveles: {n_hot} HOT + {n_cold} COLD / {n_hot + n_cold} total (dominios: {domains})

Paso 2 — Escaneo

Lanza el agente immune-scan (Haiku) con el siguiente prompt estructurado en XML:

<scan_request>
  <domains>{dominios_detectados como array JSON}</domains>
  <task>{descripción de la tarea o "Escanear el siguiente contenido en busca de errores y amenazas"}</task>
  <constraints>{restricciones o "ninguna"}</constraints>

  <content>
{el texto/código/contenido a escanear}
  </content>

  <hot_antibodies>
{array JSON de anticuerpos HOT — objetos completos con id, domains, pattern, severity, correction}
  </hot_antibodies>

  <cold_summary>
Patrones inactivos (sin detalle, solo para conocimiento): {palabras clave COLD separadas por comas}
  </cold_summary>

  <cheatsheet_applied>
{lista de IDs de estrategia y patrones que se inyectaron en el Paso 0, o "ninguno" si el modo es scan-only}
  </cheatsheet_applied>
</scan_request>

Registra: [IMMUNE] Escaneando... ({n_hot} anticuerpos activos) Espera el resultado.

Si se aplicaron correcciones: Registra: [IMMUNE] Coincidencia {antibody_id}: {original} → {corrected} Si se detectaron nuevas amenazas: Registra: [IMMUNE] Nueva amenaza: {pattern} Si se detectaron nuevas estrategias: Registra: [IMMUNE] Nueva estrategia: {pattern}

Paso 3 — Actualizar Memoria Immune (con deduplicación COLD)

3a. Anticuerpos HOT coincidentes: Para cada anticuerpo coincidente con el escáner, actualiza a través del adaptador:

node ~/.claude/skills/immune/immune-adapter.js update-antibody --id {antibody_id} --increment_seen true --last_seen {today}

3b. Nuevas amenazas — deduplicar mediante puntuación de similitud: Para cada nueva amenaza en new_threats_detected:

1. Verifica duplicado usando similitud multicriterio (Jaccard + subcadena + dominio):

node ~/.claude/skills/immune/immune-adapter.js check-duplicate --pattern "{pattern}" --domains '{domains_json}' --type antibody

Devuelve { duplicate: true/false, best_match: { id, score, pattern }, threshold: 0.7 }

2. Si duplicate es true (score >= 0.7, mismo dominio + patrón similar) → REACTIVAR:
   • Actualiza el anticuerpo coincidente: update-antibody --id {matched_id} --increment_seen true --last_seen {today}
   • Registra: [IMMUNE] Anticuerpo COLD reactivado {id}: {pattern}
   • NO crees un nuevo anticuerpo (evita duplicados)
3. Si no hay coincidencia Y auto_add_threats es true → CREAR nuevo anticuerpo:

node ~/.claude/skills/immune/immune-adapter.js add-antibody --json '{"id":"AB-{next_number}","domains":{domains},"pattern":"{pattern}","severity":"{severity}","correction":"{correction}","seen_count":1,"first_seen":"{today}","last_seen":"{today}"}'

• Registra: [IMMUNE] + Nuevo anticuerpo {id}: {pattern}

3c. Obtener estadísticas actualizadas:

node ~/.claude/skills/immune/immune-adapter.js stats

Registra: [IMMUNE] Memoria: {total} anticuerpos ({n_hot} hot, {n_cold} cold) | +{new} añadidos | Reactivados: {reactivated}

Paso 3b — Actualizar Memoria Cheatsheet (patrones positivos)

Salta si mode == "scan-only" o no hay new_strategies_detected en el resultado del escaneo.

3b-i. Deduplicar mediante puntuación de similitud: Para cada nueva estrategia en new_strategies_detected:

1. Verifica duplicado usando similitud multicriterio:

node ~/.claude/skills/immune/immune-adapter.js check-duplicate --pattern "{pattern}" --domains '{domains_json}' --type strategy

2. Si duplicate es true (score >= 0.7, dominios superpuestos + patrón similar) → REFORZAR:
   • Calcula nueva efectividad: new_eff = old_eff * 0.8 + reported_eff * 0.2 (media móvil exponencial)
   • Actualiza: update-strategy --id {matched_id} --increment_seen true --last_seen {today} --effectiveness {new_eff}
   • Registra: [IMMUNE] Estrategia reforzada {id}: {pattern} (eff: {old}→{new})
3. Si no hay coincidencia Y auto_add_strategies es true → CREAR nueva estrategia:

node ~/.claude/skills/immune/immune-adapter.js add-strategy --json '{"id":"{prefix}-{next_number}","domains":{domains},"pattern":"{pattern}","example":"{example}","effectiveness":{eff},"seen_count":1,"first_seen":"{today}","last_seen":"{today}"}'

• Registra: [IMMUNE] + Nueva estrategia {id}: {pattern}

3b-ii. Podar estrategias de baja efectividad: Si alguna estrategia tiene effectiveness < 0.2 Y seen_count >= 5, anótala para revisión manual.

Registra: [IMMUNE] Cheatsheet: {total} estrategias | +{new} añadidas | Reforzadas: {reinforced}

Paso 4 — Puntuación

Calcula la puntuación universal a través del adaptador:

node ~/.claude/skills/immune/immune-adapter.js score --domains '{domains_json}' --severities '[{"severity":"critical","count":N},{"severity":"warning","count":N},{"severity":"info","count":N}]'

El adaptador devuelve: score (0-100), pass (booleano), z (z-score vs línea base del dominio), baseline (media, desviación estándar, umbral, n), deductions.

Paso 5 — Salida

Si está limpio:

───
IMMUNE v5.1 | domains={domains} | Score: {score}/100 ({PASS|FAIL}) | z={z}
   Línea base ({domain}): media={mean} std={std} umbral={threshold}
   Cheatsheet: {n_strategies} estrategias aplicadas | Anticuerpos: {n_hot}/{max} HOT, {n_cold} COLD
   No se detectaron problemas
───

Si se encontraron correcciones o amenazas:

───
IMMUNE v5.1 | domains={domains} | Score: {score}/100 ({PASS|FAIL}) | z={z}
   Línea base ({domain}): media={mean} std={std} umbral={threshold}

Correcciones Aplicadas:
  [AB-XXX] {pattern} → {correction}

Nuevas Amenazas Detectadas:
  [{severity}] {pattern} — {suggested_correction}

Reactivados:
  [AB-XXX] {pattern} (era COLD, ahora HOT)

Nuevas Estrategias Aprendidas:
  [CS-XXX] {pattern} (eff: {effectiveness})

───
Salida Corregida:
{el contenido corregido, formateado para el dominio}
───
Memoria: {total_ab} anticuerpos + {total_cs} estrategias | +{new_ab} AB | +{new_cs} CS
───

Luego presenta la salida corregida en un formato legible para humanos apropiado para el dominio.

Paso 6 — Registro de Sesión

Registra el resultado de la sesión para contexto futuro:

node ~/.claude/skills/immune/immune-adapter.js log-session --date {today} --domains '{domains_json}' --result {clean|corrected|flagged} --summary "{resumen breve de lo escaneado y encontrado}" --score {score}

Esto escribe en context/YYYY-MM-DD.md + session_logs (SQLite) + índice FTS4 para futuras búsquedas de get-context.

Paso 7 — Volcado Pre-Compactación (opcional)

Si el contexto de la conversación se acerca a la compactación, guarda cualquier anticuerpo/estrategia pendiente que aún no se haya confirmado:

node ~/.claude/skills/immune/immune-adapter.js flush-pending --json '{"antibodies":[...],"strategies":[...]}'

Validación de control de calidad:

• El patrón debe tener >= 20 caracteres
• Los anticuerpos requieren: id, pattern, severity, correction
• Las estrategias requieren: id, pattern
• La verificación de duplicados FTS4 evita recrear patrones existentes
• Los registros volcados se marcan con quality_gate=1

Registra: [IMMUNE] Volcado pre-compactación: +{n} anticuerpos, +{n} estrategias (quality_gate=true)

Manejo de Errores

• Si la CLI del adaptador falla: recurre a leer los archivos JSON directamente (immune_memory.json, cheatsheet_memory.json) — se mantienen sincronizados mediante escritura dual.
• Si immune_memory.json no existe: el adaptador lo crea automáticamente con anticuerpos vacíos.
• Si cheatsheet_memory.json no existe: el adaptador lo crea automáticamente con estrategias vacías.
• Si immune_memory.json tiene "version": 2: el adaptador migra automáticamente "domain" a "domains": ["valor_del_dominio"].
• Si el agente devuelve JSON inválido: reintenta una vez. Si sigue siendo inválido, reporta la salida sin procesar con una advertencia.
• Si no se proporciona entrada y no existe output reciente: pregunta al usuario qué escanear.
• Si todos los anticuerpos son COLD (ninguno califica como HOT): igualmente envía el escaneo con un array hot_antibodies vacío y el cold_summary completo. Haiku aún puede detectar nuevas amenazas mediante la Fase 2.