Mnemoclaw/immune

Système Immunitaire v5.1 — Aide-mémoire hybride + Immunitaire

Vous utilisez un système adaptatif hybride avec deux mémoires complémentaires :

• Aide-mémoire (Cheatsheet) (motifs positifs) : stratégies spécifiques au domaine injectées AVANT la génération pour améliorer la qualité du résultat
• Immunitaire (Immune) (motifs négatifs) : anticorps qui détectent les erreurs connues et découvrent de nouvelles menaces APRÈS la génération

Les deux mémoires utilisent une hiérarchisation à chaud/froid pour maintenir un contexte allégé. Tout accès aux données passe par la CLI adaptateur (node ~/.claude/skills/immune/immune-adapter.js).

Analyse d'entrée

L'utilisateur invoque avec un contenu à analyser. Interprétez ces paramètres :

• input : Le texte/code/contenu à analyser (obligatoire — soit en ligne, soit depuis le contexte)
• domain : Un domaine parmi : fitness, code, writing, research, strategy, webdesign, _global (par défaut : auto-détection)
• domains : Tableau de domaines (remplace un seul domaine). Exemple : domains=fitness,code
• constraints : Exigences spécifiques que le résultat doit satisfaire (optionnel)
• mode : full (aide-mémoire + analyse, par défaut) | scan-only (ignorer l'aide-mémoire) | cheatsheet-only (retourner l'aide-mémoire, pas d'analyse)

Si aucun texte en ligne n'est fourni, analysez la dernière sortie substantielle dans la conversation.

Auto-détection du domaine : Lisez ~/.claude/skills/immune/config.yaml et faites correspondre le contenu avec domain_keywords. S'il n'y a pas de correspondance forte, utilisez ["_global"]. Si une chaîne domain unique est fournie, placez-la dans un tableau : domains = [domain].

Exécution

Étape -1 — Recherche contextuelle (conscience des sessions passées)

Recherchez dans les sessions passées pertinentes pour éclairer l'analyse actuelle :

node ~/.claude/skills/immune/immune-adapter.js get-context --query "{mots-clés de la tâche ou domaine}" --days 90 --limit 5

Si des résultats sont trouvés, notez les motifs récurrents ou les problèmes passés pour le domaine. Cela enrichit l'analyse avec une conscience historique — l'analyseur saura si un contenu similaire a déjà été signalé.

Journal : [IMMUNE] Contexte : {count} sessions pertinentes trouvées

Étape 0 — Injection de l'aide-mémoire (motifs positifs)

Ignorer cette étape si mode == "scan-only".

0a. Charger les stratégies CHAUDES via l'adaptateur :

Exécutez :

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

Analysez la sortie JSON. L'adaptateur retourne les stratégies pré-filtrées par domaine, classifiées comme CHAUDES, triées par efficacité décroissante, et limitées à 15.

0b. Charger le résumé des stratégies FROIDES :

Exécutez :

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

Extrayez un mot-clé court du champ pattern de chaque stratégie FROIDE. Concaténez-les en une liste séparée par des virgules.

0c. Construire le bloc d'aide-mémoire : Formatez les stratégies CHAUDES en XML :

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

S'il y a des stratégies FROIDES, ajoutez une ligne :

<cheatsheet_cold>Considérez également : {mots-clés des motifs FROIDS séparés par des virgules}</cheatsheet_cold>

Si mode == "cheatsheet-only", affichez le bloc d'aide-mémoire et arrêtez-vous ici.

Journal :

[IMMUNE] Aide-mémoire : {n_hot} CHAUDES + {n_cold} FROIDES stratégies (domaines : {domains})

0d. Présenter l'aide-mémoire à l'utilisateur : En mode autonome (/immune), montrez l'aide-mémoire comme contexte que l'utilisateur doit appliquer à sa prochaine génération. Si appelé par Chimera, retournez le bloc XML pour injection dans les prompts PRISM.

Étape 1 — Charger et classifier les anticorps (Chaud/Froid)

1a. Charger les anticorps CHAUDS via l'adaptateur :

Exécutez :

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

L'adaptateur retourne les anticorps pré-filtrés par domaine, classifiés comme CHAUDS (severity=critical OU seen_count>=3 OU last_seen<30d), triés par sévérité puis seen_count, limités à 15.

1b. Charger le résumé des anticorps FROIDS :

Exécutez :

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

Pour chaque anticorps FROID, extrayez un mot-clé court de son champ pattern. Concaténez-les en une liste séparée par des virgules.

Journal :

[IMMUNE] Répartition par niveau : {n_hot} CHAUD + {n_cold} FROID / {n_hot + n_cold} total (domaines : {domains})

Étape 2 — Analyse

Lancez l'agent immune-scan (Haiku) avec le prompt suivant structuré en XML :

<scan_request>
  <domains>{domaines_détectés sous forme de tableau JSON}</domains>
  <task>{description de la tâche ou "Analysez le contenu suivant pour les erreurs et menaces"}</task>
  <constraints>{contraintes ou "aucune"}</constraints>

  <content>
{le texte/code/contenu à analyser}
  </content>

  <hot_antibodies>
{tableau JSON des anticorps CHAUDS — objets complets avec id, domains, pattern, severity, correction}
  </hot_antibodies>

  <cold_summary>
Motifs dormants (non détaillés, pour information uniquement) : {mots-clés FROIDS séparés par des virgules}
  </cold_summary>

  <cheatsheet_applied>
{liste des ID de stratégies et motifs qui ont été injectés à l'étape 0, ou "aucun" en mode scan-only}
  </cheatsheet_applied>
</scan_request>

Journal : [IMMUNE] Analyse en cours... ({n_hot} anticorps actifs) Attendez le résultat.

Si des corrections sont appliquées : Journal : [IMMUNE] Correspondance {antibody_id} : {original} → {corrigé} Si de nouvelles menaces sont détectées : Journal : [IMMUNE] Nouvelle menace : {pattern} Si de nouvelles stratégies sont détectées : Journal : [IMMUNE] Nouvelle stratégie : {pattern}

Étape 3 — Mettre à jour la mémoire immunitaire (avec déduplication des FROID)

3a. Anticorps CHAUDS correspondants : Pour chaque anticorps correspondant trouvé par l'analyseur, mettez à jour via l'adaptateur :

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

3b. Nouvelles menaces — déduplication via score de similarité : Pour chaque nouvelle menace dans new_threats_detected :

1. Vérifiez les doublons en utilisant la similarité multi-critères (Jaccard + sous-chaîne + domaine) :

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

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

2. Si duplicata est vrai (score >= 0.7, même domaine + motif similaire) → RÉACTIVER :
   • Mettez à jour l'anticorps correspondant : update-antibody --id {matched_id} --increment_seen true --last_seen {aujourd'hui}
   • Journal : [IMMUNE] Anticorps FROID réactivé {id} : {pattern}
   • Ne créez PAS un nouvel anticorps (empêche les doublons)
3. Si aucune correspondance ET auto_add_threats est vrai → CRÉER un nouvel anticorps :

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

• Journal : [IMMUNE] + Nouvel anticorps {id} : {pattern}

3c. Obtenir les statistiques mises à jour :

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

Journal : [IMMUNE] Mémoire : {total} anticorps ({n_hot} chauds, {n_cold} froids) | +{new} ajoutés | Réactivés : {reactivated}

Étape 3b — Mettre à jour la mémoire de l'aide-mémoire (motifs positifs)

Ignorer si mode == "scan-only" ou aucun new_strategies_detected dans le résultat de l'analyse.

3b-i. Déduplication via score de similarité : Pour chaque nouvelle stratégie dans new_strategies_detected :

1. Vérifiez les doublons en utilisant la similarité multi-critères :

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

2. Si duplicata est vrai (score >= 0.7, domaines se chevauchant + motif similaire) → RENFORCER :
   • Calculez la nouvelle efficacité : new_eff = old_eff * 0.8 + reported_eff * 0.2 (moyenne mobile exponentielle)
   • Mettez à jour : update-strategy --id {matched_id} --increment_seen true --last_seen {aujourd'hui} --effectiveness {new_eff}
   • Journal : [IMMUNE] Stratégie renforcée {id} : {pattern} (eff : {old}→{new})
3. Si aucune correspondance ET auto_add_strategies est vrai → CRÉER une nouvelle stratégie :

node ~/.claude/skills/immune/immune-adapter.js add-strategy --json '{"id":"{préfixe}-{prochain_numéro}","domains":{domains},"pattern":"{pattern}","example":"{example}","effectiveness":{eff},"seen_count":1,"first_seen":"{aujourd'hui}","last_seen":"{aujourd'hui}"}'

• Journal : [IMMUNE] + Nouvelle stratégie {id} : {pattern}

3b-ii. Élaguer les faibles efficacités : Si une stratégie a effectiveness < 0.2 ET seen_count >= 5, signalez-la pour révision manuelle.

Journal : [IMMUNE] Aide-mémoire : {total} stratégies | +{new} ajoutées | Renforcées : {reinforced}

Étape 4 — Score

Calculez le score universel via l'adaptateur :

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

L'adaptateur retourne : score (0-100), pass (booléen), z (z-score par rapport à la ligne de base du domaine), baseline (moyenne, écart-type, seuil, n), deductions.

Étape 5 — Résultat

Si propre :

───
IMMUNE v5.1 | domains={domaines} | Score : {score}/100 ({RÉUSSI|ÉCHEC}) | z={z}
   Ligne de base ({domain}) : moyenne={mean} écart-type={std} seuil={threshold}
   Aide-mémoire : {n_strategies} stratégies appliquées | Anticorps : {n_hot}/{max} CHAUD, {n_cold} FROID
   Aucun problème détecté
───

Si des corrections ou menaces sont trouvées :

───
IMMUNE v5.1 | domains={domaines} | Score : {score}/100 ({RÉUSSI|ÉCHEC}) | z={z}
   Ligne de base ({domain}) : moyenne={mean} écart-type={std} seuil={threshold}

Corrections appliquées :
  [AB-XXX] {pattern} → {correction}

Nouvelles menaces détectées :
  [{severity}] {pattern} — {correction_suggérée}

Réactivés :
  [AB-XXX] {pattern} (était FROID, maintenant CHAUD)

Nouvelles stratégies apprises :
  [CS-XXX] {pattern} (eff : {effectiveness})

───
Sortie corrigée :
{le contenu corrigé, formaté pour le domaine}
───
Mémoire : {total_ab} anticorps + {total_cs} stratégies | +{new_ab} AB | +{new_cs} CS
───

Présentez ensuite la sortie corrigée dans un format lisible par l'humain adapté au domaine.

Étape 6 — Journal de session

Enregistrez le résultat de la session pour le contexte futur :

node ~/.claude/skills/immune/immune-adapter.js log-session --date {aujourd'hui} --domains '{domains_json}' --result {clean|corrected|flagged} --summary "{résumé bref de ce qui a été analysé et trouvé}" --score {score}

Ceci écrit dans context/YYYY-MM-DD.md + session_logs SQLite + index FTS4 pour les futures recherches get-context.

Étape 7 — Vidage avant compaction (optionnel)

Si le contexte de la conversation approche de la compaction, sauvegardez tous les anticorps/stratégies en attente qui n'ont pas encore été validés :

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

Validation de qualité :

• Le motif doit avoir >= 20 caractères
• Les anticorps nécessitent : id, pattern, severity, correction
• Les stratégies nécessitent : id, pattern
• La vérification des doublons FTS4 empêche la recréation de motifs existants
• Les enregistrements vidés sont marqués avec quality_gate=1

Journal : [IMMUNE] Vidage avant compaction : +{n} anticorps, +{n} stratégies (quality_gate=true)

Gestion des erreurs

• Si la CLI adaptateur échoue : revenez à la lecture directe des fichiers JSON (immune_memory.json, cheatsheet_memory.json) — ils sont maintenus synchronisés par double écriture.
• Si immune_memory.json n'existe pas : l'adaptateur le crée automatiquement avec des anticorps vides.
• Si cheatsheet_memory.json n'existe pas : l'adaptateur le crée automatiquement avec des stratégies vides.
• Si immune_memory.json a "version": 2 : l'adaptateur migre automatiquement "domain" vers "domains": ["valeur_du_domaine"].
• Si l'agent retourne un JSON invalide : réessayez une fois. Si toujours invalide, rapportez la sortie brute avec un avertissement.
• Si aucune entrée n'est fournie et qu'il n'existe aucune sortie récente : demandez à l'utilisateur ce qu'il faut analyser.
• Si tous les anticorps sont FROIDS (aucun ne se qualifie comme CHAUD) : envoyez tout de même l'analyse avec un tableau hot_antibodies vide et un cold_summary complet. Haiku peut toujours détecter de nouvelles menaces via la Phase 2.