Immunsystem v5.1 — Hybrides Cheatsheet + Immun

Was macht Immunsystem v5.1 — Hybrides Cheatsheet + Immun?

Sie betreiben ein hybrides adaptives System mit zwei komplementären Gedächtnissen:

• Cheatsheet (positive Muster): domänenspezifische Strategien, die VOR der Generierung eingespielt werden, um die Ausgabequalität zu verbessern
• Immun (negative Muster): Antikörper, die bekannte Fehler erkennen und neue Bedrohungen NACH der Generierung aufdecken

Beide Gedächtnisse verwenden ein Hot/Cold-Tiering, um den Kontext schlank zu halten. Der gesamte Datenzugriff erfolgt über die Adapter-CLI (node ~/.claude/skills/immune/immune-adapter.js).

Eingabe-Parsing

Der Benutzer ruft den Skill mit einem zu scannenden Inhalt auf. Analysieren Sie diese Parameter:

• input: Der Text/Code/Inhalt zum Scannen (erforderlich – entweder inline oder aus dem Kontext)
• domain: Eine von: fitness, code, writing, research, strategy, webdesign, _global (Standard: auto-detect)
• domains: Array von Domänen (überschreibt einzelne Domäne). Beispiel: domains=fitness,code
• constraints: Spezifische Anforderungen, die die Ausgabe erfüllen soll (optional)
• mode: full (Cheatsheet + Scan, Standard) | scan-only (Cheatsheet überspringen) | cheatsheet-only (nur Cheatsheet zurückgeben, kein Scan)

Wenn kein Inline-Text angegeben wird, scannen Sie die letzte substantielle Ausgabe im Gespräch.

Domänen-Automatikerkennung: Lesen Sie ~/.claude/skills/immune/config.yaml und gleichen Sie den Inhalt mit den domain_keywords ab. Wenn keine starke Übereinstimmung vorliegt, verwenden Sie ["_global"]. Wenn eine einzelne domain-Zeichenfolge angegeben wird, in Array verpacken: domains = [domain].

Ausführung

Schritt -1 — Kontextsuche (Vergleich zu vergangenen Sitzungen)

Suche nach relevanten vergangenen Sitzungen, um den aktuellen Scan zu informieren:

node ~/.claude/skills/immune/immune-adapter.js get-context --query "{Aufgaben-Keywords oder Domäne}" --days 90 --limit 5

Wenn Ergebnisse gefunden werden, notieren Sie wiederkehrende Muster oder frühere Probleme für die Domäne. Dies bereichert den Scan mit historischem Wissen – der Scanner weiß, ob ähnliche Inhalte bereits zuvor markiert wurden.

Log: [IMMUNE] Kontext: {Anzahl} relevante vergangene Sitzungen gefunden

Schritt 0 — Cheatsheet-Injektion (positive Muster)

Diesen Schritt überspringen, wenn mode == "scan-only".

0a. HOT-Strategien über Adapter laden:

Ausführen:

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

Das JSON-Ausgabe parsen. Der Adapter gibt bereits nach Domäne gefilterte, als HOT klassifizierte, nach Effektivität absteigend sortierte und auf 15 begrenzte Strategien zurück.

0b. COLD-Strategien-Zusammenfassung laden:

Ausführen:

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

Aus jeder COLD-Strategie ein kurzes Keyword aus dem pattern-Feld extrahieren. Als kommagetrennte Liste zusammenfügen.

0c. Cheatsheet-Block erstellen: HOT-Strategien als XML formatieren:

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

Wenn es COLD-Strategien gibt, einen Einzeiler hinzufügen:

<cheatsheet_cold>Erwägen Sie auch: {kommagetrennte COLD-Pattern-Keywords}</cheatsheet_cold>

Wenn mode == "cheatsheet-only", den Cheatsheet-Block ausgeben und hier stoppen.

Log:

[IMMUNE] Cheatsheet: {n_hot} HOT + {n_cold} COLD Strategien (Domänen: {domains})

0d. Cheatsheet dem Benutzer präsentieren: Wenn eigenständig ausgeführt (/immune), das Cheatsheet als Kontext anzeigen, den der Benutzer auf seine nächste Generierung anwenden soll. Falls von Chimera aufgerufen, den XML-Block zur Injektion in PRISM-Prompts zurückgeben.

Schritt 1 — Antikörper laden & klassifizieren (Hot/Cold)

1a. HOT-Antikörper über Adapter laden:

Ausführen:

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

Der Adapter gibt bereits nach Domäne gefilterte, als HOT klassifizierte Antikörper zurück (severity=critical ODER seen_count>=3 ODER last_seen<30d), sortiert nach severity dann seen_count, begrenzt auf 15.

1b. COLD-Antikörper-Zusammenfassung laden:

Ausführen:

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

Für jeden COLD-Antikörper ein kurzes Keyword aus dessen pattern-Feld extrahieren. Als kommagetrennte Liste zusammenfügen.

Log:

[IMMUNE] Tier-Split: {n_hot} HOT + {n_cold} COLD / {n_hot + n_cold} gesamt (Domänen: {domains})

Schritt 2 — Scannen

Den immune-scan-Agenten (Haiku) mit folgendem XML-strukturierten Prompt starten:

<scan_request>
  <domains>{erkannte Domänen als JSON-Array}</domains>
  <task>{Aufgabenbeschreibung oder "Scannen Sie den folgenden Inhalt auf Fehler und Bedrohungen"}</task>
  <constraints>{Einschränkungen oder "none"}</constraints>

  <content>
{der zu scannende Eingabetext/Code/Inhalt}
  </content>

  <hot_antibodies>
{JSON-Array der HOT-Antikörper – vollständige Objekte mit id, domains, pattern, severity, correction}
  </hot_antibodies>

  <cold_summary>
Ruhende Muster (nicht detailliert, nur zur Kenntnis): {kommagetrennte COLD-Keywords}
  </cold_summary>

  <cheatsheet_applied>
{Liste der Strategie-IDs und -Muster, die in Schritt 0 eingespielt wurden, oder "none" im Scan-only-Modus}
  </cheatsheet_applied>
</scan_request>

Log: [IMMUNE] Scannen... ({n_hot} aktive Antikörper) Auf Ergebnis warten.

Wenn Korrekturen angewendet wurden: Log: [IMMUNE] Treffer {antibody_id}: {original} → {korrigiert} Wenn neue Bedrohungen erkannt wurden: Log: [IMMUNE] Neue Bedrohung: {pattern} Wenn neue Strategien erkannt wurden: Log: [IMMUNE] Neue Strategie: {pattern}

Schritt 3 — Immun-Gedächtnis aktualisieren (mit COLD-Deduplizierung)

3a. Getroffene HOT-Antikörper: Für jeden vom Scanner getroffenen Antikörper über Adapter aktualisieren:

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

3b. Neue Bedrohungen — mit Ähnlichkeitsscore deduplizieren: Für jede neue Bedrohung in new_threats_detected:

1. Auf Duplikat prüfen mittels Multi-Kriterien-Ähnlichkeit (Jaccard + Substring + Domäne):

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

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

2. Wenn Duplikat wahr (score >= 0.7, gleiche Domäne + ähnliches Muster) → REAKTIVIEREN:
   • Den getroffenen Antikörper aktualisieren: update-antibody --id {matched_id} --increment_seen true --last_seen {heute}
   • Log: [IMMUNE] Reaktivierter COLD-Antikörper {id}: {pattern}
   • Keinen neuen Antikörper erstellen (verhindert Duplikate)
3. Wenn keine Übereinstimmung UND auto_add_threats wahr ist → NEUEN Antikörper ERSTELLEN:

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

• Log: [IMMUNE] + Neuer Antikörper {id}: {pattern}

3c. Aktualisierte Statistiken abrufen:

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

Log: [IMMUNE] Gedächtnis: {gesamt} Antikörper ({n_hot} heiß, {n_cold} kalt) | +{neu} hinzugefügt | Reaktiviert: {reactivated}

Schritt 3b — Cheatsheet-Gedächtnis aktualisieren (positive Muster)

Überspringen, wenn mode == "scan-only" oder kein new_strategies_detected im Scan-Ergebnis.

3b-i. Mit Ähnlichkeitsscore deduplizieren: Für jede neue Strategie in new_strategies_detected:

1. Auf Duplikat prüfen mittels Multi-Kriterien-Ähnlichkeit:

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

2. Wenn Duplikat wahr (score >= 0.7, überlappende Domänen + ähnliches Muster) → VERSTÄRKEN:
   • Neue Effektivität berechnen: new_eff = old_eff * 0.8 + reported_eff * 0.2 (exponentieller gleitender Durchschnitt)
   • Aktualisieren: update-strategy --id {matched_id} --increment_seen true --last_seen {heute} --effectiveness {new_eff}
   • Log: [IMMUNE] Verstärkte Strategie {id}: {pattern} (eff: {alt}→{neu})
3. Wenn keine Übereinstimmung UND auto_add_strategies wahr ist → NEUE Strategie ERSTELLEN:

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

• Log: [IMMUNE] + Neue Strategie {id}: {pattern}

3b-ii. Schwach wirksame Strategien ausdünnen: Wenn eine Strategie effectiveness < 0.2 UND seen_count >= 5 aufweist, für manuelle Überprüfung notieren.

Log: [IMMUNE] Cheatsheet: {gesamt} Strategien | +{neu} hinzugefügt | Verstärkt: {reinforced}

Schritt 4 — Bewertung

Den universellen Score über Adapter berechnen:

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

Der Adapter liefert zurück: score (0-100), pass (boolean), z (z-Score vs. Domänen-Baseline), baseline (mean, std, threshold, n), deductions.

Schritt 5 — Ausgabe

Wenn sauber:

───
IMMUNE v5.1 | domains={domains} | Score: {score}/100 ({PASS|FAIL}) | z={z}
   Baseline ({domain}): mean={mean} std={std} threshold={threshold}
   Cheatsheet: {n_strategies} Strategien angewendet | Antikörper: {n_hot}/{max} HOT, {n_cold} COLD
   Keine Probleme erkannt
───

Wenn Korrekturen oder Bedrohungen gefunden:

───
IMMUNE v5.1 | domains={domains} | Score: {score}/100 ({PASS|FAIL}) | z={z}
   Baseline ({domain}): mean={mean} std={std} threshold={threshold}

Angewandte Korrekturen:
  [AB-XXX] {pattern} → {correction}

Neue Bedrohungen erkannt:
  [{severity}] {pattern} — {vorgeschlagene_Korrektur}

Reaktiviert:
  [AB-XXX] {pattern} (war COLD, jetzt HOT)

Neue Strategien gelernt:
  [CS-XXX] {pattern} (eff: {effectiveness})

───
Korrigierte Ausgabe:
{der korrigierte Inhalt, domänengerecht formatiert}
───
Gedächtnis: {total_ab} Antikörper + {total_cs} Strategien | +{new_ab} AB | +{new_cs} CS
───

Anschließend die korrigierte Ausgabe in einem menschenlesbaren, zur Domäne passenden Format präsentieren.

Schritt 6 — Sitzungslog

Das Sitzungsergebnis für zukünftigen Kontext protokollieren:

node ~/.claude/skills/immune/immune-adapter.js log-session --date {heute} --domains '{domains_json}' --result {clean|corrected|flagged} --summary "{kurze Zusammenfassung, was gescannt und gefunden wurde}" --score {score}

Dies schreibt in context/YYYY-MM-DD.md + SQLite session_logs + FTS4-Index für zukünftige get-context-Suchen.

Schritt 7 — Pre-Compaction-Flush (optional)

Wenn der Gesprächskontext sich der Kompaktierung nähert, alle noch nicht festgeschriebenen Antikörper/Strategien speichern:

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

Qualitätskontrolle:

• Muster muss >= 20 Zeichen lang sein
• Antikörper erfordern: id, pattern, severity, correction
• Strategien erfordern: id, pattern
• FTS4-Duplikatprüfung verhindert das Neuerstellen vorhandener Muster
• Geflushhte Einträge werden mit quality_gate=1 markiert

Log: [IMMUNE] Pre-Compaction-Flush: +{n} Antikörper, +{n} Strategien (quality_gate=true)

Fehlerbehandlung

• Falls die Adapter-CLI fehlschlägt: Fallback auf direktes Lesen der JSON-Dateien (immune_memory.json, cheatsheet_memory.json) – sie werden durch Dual-Write synchron gehalten.
• Falls immune_memory.json nicht existiert: Adapter erstellt es automatisch mit leeren Antikörpern.
• Falls cheatsheet_memory.json nicht existiert: Adapter erstellt es automatisch mit leeren Strategien.
• Falls immune_memory.json "version": 2 enthält: Adapter migriert automatisch "domain" zu "domains": ["domain_value"].
• Falls der Agent ungültiges JSON zurückgibt: Einmal wiederholen. Wenn immer noch ungültig, Rohausgabe mit Warnung melden.
• Falls keine Eingabe und keine aktuelle Ausgabe vorhanden ist: Benutzer fragen, was gescannt werden soll.
• Falls alle Antikörper COLD sind (keiner qualifiziert sich als HOT): Scan dennoch mit leerem hot_antibodies-Array und vollständiger cold_summary senden. Haiku kann über Phase 2 dennoch neue Bedrohungen erkennen.