# Portabilität: UNIVERSAL
# Zuletzt validiert: 2026-02-08 (Help-Forensik - Connector-Integration)
# Nächste Prüfung: 2026-08-08
# Ressourcen: [CONSOL_REPORT_20260130, hub/consolidation.py, hub/memory.py, bach_api.py]

MEMORY-SYSTEM (Cognitive Model)
================================

STAND: 2026-01-30

Definition: BACH nutzt ein kognitives Memory-System, das dem menschlichen 
Gedächtnis nachempfunden ist. Es geht über reines Speichern hinaus und 
integriert aktive Gewichtung, Decay (Vergessen) und Boost (Erinnern).

DIE 5 KOGNITIVEN TYPEN:
-----------------------

1. WORKING MEMORY (memory_working)
   - "Das Kurzzeitgedächtnis"
   - Fokus: Aktuelle Session, flüchtig.
   - Befehl: `bach mem write "..."`

2. EPISODISCHES GEDÄCHTNIS (memory_sessions)
   - "Das Erlebnistagebuch"
   - Speichert abgeschlossene Sessions (360+).
   - Befehl: `bach --memory session "..."`

3. SEMANTISCHES GEDÄCHTNIS (memory_facts, docs/help/, wiki/)
   - "Das Weltwissen"
   - Fakten, Definitionen, Architektur (230+ Fakten).
   - Befehl: `bach --memory fact "..."`

4. PROZEDURALES GEDÄCHTNIS (memory_lessons, tools/, skills/)
   - "Das Können" / "Best Practices"
   - Wie Dinge getan werden (Workflows, Tools).
   - Befehl: `bach lesson add "..."`

5. ASSOZIATIVES GEDÄCHTNIS (memory_context, context_triggers)
   - "Die Brücke"
   - Verknüpft Wissen via Triggern mit der aktuellen Situation.
   - Befehl: `bach --memory search "..."`
   - Integration: context_triggers feuern auch beim Connector-Routing

DYNAMISCHES LERNSYSTEM (NEU v1.1.80)
------------------------------------
Im Gegensatz zu traditionellen Systemen sind die Injektoren bei BACH nun DYNAMISCH:
- TRIGGER-DB: 900+ Trigger aus Lessons, Workflows und Tools werden automatisch generiert.
- KOGNITIVE LAST: Nur relevanter Kontext wird in die Session geladen.
- RÜCKFLUSS: Erledigte Tasks und gelernte Lektionen verändern das Systemverhalten sofort.

CONNECTOR-INTEGRATION (NEU v2.0 - 2026-02-08)
---------------------------------------------
context_triggers werden jetzt auch beim Connector-Routing genutzt:
- Eingehende Telegram/Discord/HomeAssistant-Nachrichten durchlaufen context_triggers
- Erkannte Trigger werden als Metadata an messages.metadata angefügt
- LLM bekommt automatisch relevanten Kontext (z.B. "Steuer" → Steuer-Facts)
- Siehe: --help connector (Kontext-Integration Abschnitt)

DATENBANK-TABELLEN:
  memory_working       Temporäre Notizen (is_active Flag)
  memory_facts         Globale Fakten (cat: user, project, system, domain)
  memory_lessons       Erkenntnisse (severity: info, warn, critical)
  memory_sessions      Session-Historie (mit Summary & Context)
  memory_consolidation Tracking-Metadaten (weight, last_accessed)
  memory_context       Source-Pfade mit Triggern (legacy)
  context_triggers     900+ dynamische Trigger (Lessons/Workflows/Tools)
                       → Feuern in Injektoren + Connector-Routing

KONFIDENZ-SYSTEM:
=================

Das Memory-System verwendet Konfidenz-Werte zur Qualitätsbewertung von Fakten.

KONFIDENZ-SKALA (0.0 - 1.0):
  1.0       Absolut sicher (verifiziert, mehrfach bestaetigt)
  0.8-0.9   Sehr sicher (aus zuverlaessiger Quelle)
  0.5-0.7   Moderat (Annahme oder Beobachtung)
  0.3-0.4   Unsicher (Vermutung)
  0.0-0.2   Sehr unsicher (zu prüfen)

VISUELLE DARSTELLUNG:
  Konfidenz wird als Balken angezeigt: [*****] = 1.0, [***  ] = 0.6, [*    ] = 0.2

QUELLEN-TRACKING:
  Jeder Fakt kann eine Quelle haben (--source), z.B. "user", "system", "observation"

BEFEHLE (Vollständig):
=======================

GRUNDBEFEHLE:
  bach mem write "..."              Arbeitsgedächtnis füllen
  bach --memory facts               Semantisches Wissen abrufen
  bach --memory fact "key:value"    Neuen Fakt speichern
  bach --memory session "..."       Session-Bericht speichern
  bach --memory search "..."        Assoziative Suche
  bach --memory status              Detaillierter Memory-Status
  bach --memory provenance          Herkunft, Evidenzart, Personenbezug und Privacy-Hinweise
  bach --status                     Memory-Status im Header sehen

LIBRARY API (bach_api.py):
  from bach_api import memory
  memory.write("Notiz")             Working Memory
  memory.facts()                    Alle Fakten
  memory.fact("key:value")          Fakt speichern
  memory.search("query")            Assoziativ suchen
  memory.status()                   Status
  memory.session("Summary")         Session beenden

KONFIDENZ-BEFEHLE:
  bach --memory certain             Nur sichere Fakten anzeigen (>=0.8)
  bach --memory uncertain           Unsichere Fakten zur Prüfung (<0.5)
  bach --memory confidence KEY 0.9  Konfidenz eines Fakts aktualisieren

SESSION-BEFEHLE:
  bach --memory sessions            Alle Sessions anzeigen
  bach --memory sessions N          Letzte N Sessions anzeigen

PROVENANCE-VIEWS:
  bach --memory provenance              Letzte Einträge aus allen Memory-Bereichen
  bach --memory provenance facts 10     Nur Fakten mit Quelle, Evidenz und Privacy-Hinweis
  bach --memory provenance sessions 5   Session-Zusammenfassungen mit Partner-/Privacy-Sicht

FAKT MIT KONFIDENZ SPEICHERN:
  bach --memory fact "key:value" --conf=0.8 --source="user"

  Parameter:
    --conf=X      Konfidenz-Wert (0.0-1.0), Standard: 0.5
    --source=X    Quelle des Fakts (z.B. "user", "system", "observation")

KONSOLIDIERUNG:
  bach consolidate run              Lernprozesse starten (Decay/Boost)

HEADLESS API (GUI-Server):
  GET  /api/memory/facts?limit=50         Alle Fakten (JSON)
  POST /api/memory/facts                  Neuen Fakt erstellen
  DEL  /api/memory/facts/<id>             Fakt löschen
  GET  /api/memory/lessons?limit=50       Alle Lessons
  POST /api/memory/lessons                Neue Lesson erstellen
  DEL  /api/memory/lessons/<id>           Lesson deaktivieren

SIEHE AUCH:
  --help injectors      Das Injektor-System
  --help consolidation  Konsolidierungs-Engine
  --help connector      Connector-Integration (context_triggers)
  docs/help/lessons.txt      Umgang mit Lektionen
  bach_api.py           Library API (memory Modul)
  SKILL.md              System-Initialisierung

SHUTDOWN-WORKFLOW:
==================

RICHTIG (neu):
  1. bach --shutdown                  Directory-Scan + Hinweis
  2. bach --memory session "..."      Session-Bericht in DB speichern
  
  Oder alles in einem:
  bach --memory session "THEMA: Was gemacht wurde. NAECHSTE: Was noch kommt."

FALSCH (veraltet):
  - Markdown-Dateien in memory/archive/ erstellen
  - Session-Berichte als .md Dateien speichern

SESSION-BERICHT FORMAT:
=======================

Empfohlenes Format für den Summary-Text:

  "THEMA: Kurzbeschreibung.
   
   ERLEDIGT:
   - Aufgabe 1
   - Aufgabe 2
   
   ERSTELLT: X neue Tasks
   
   NAECHSTE SCHRITTE:
   1. Priorität 1
   2. Priorität 2"

Alternativ kompakt:
  "ATI-Architektur, 9 Tasks erstellt. Nächste: ati.py Handler"

BEST PRACTICES:
===============

1. Session-Start:
   - bach --startup ausführen
   - Liest letzte Session aus memory_sessions

2. Während Session:
   - bach mem write "wichtige Erkenntnis"
   - bach --memory fact "projekt.name:BACH"

3. Session-Ende:
   - bach --shutdown
   - bach --memory session "Zusammenfassung"

4. Lessons Learned:
   - bach lesson add "Titel: Lösung"
   - Eigener Handler, nicht --memory!

DATENBANK-SCHEMA:
=================

memory_sessions:
  - session_id          Eindeutige ID (session_YYYYMMDD_HHMMSS)
  - started_at          Startzeit
  - ended_at            Endzeit (NULL wenn aktiv)
  - summary             Session-Bericht
  - tasks_created       Anzahl erstellter Tasks
  - tasks_completed     Anzahl erledigter Tasks
  - continuation_context  Für nächste Session

ARCHITEKTUR-DIAGRAMM
====================

Visueller Vergleich Mensch <-> BACH Memory:
  docs/ARCHITECTURE_DIAGRAMS.md  -> Diagramm 4: Memory-System

Zeigt alle 5 kognitiven Typen mit menschlicher Entsprechung
und aktive Prozesse (Vergessen, Erinnern, Lernen, Aufmerksamkeit,
Schlaf-Konsolidierung, Metakognition).

KOGNITIVES MODELL: LERNEN ALS MEMORY-KREISLAUF
===============================================

These: "Lernen ist eine Form von Memory."
(Erarbeitet: User + Claude + Gemini, Januar 2026)

DER LERNPROZESS ALS KREISLAUF:

```
┌─────────────────────────────────────────────────────────────────────┐
│  MEMORY / ERFAHRUNGSSCHATZ (Langzeitspeicher)                       │
│  ┌───────────────────────────────────────────────────────────────┐  │
│  │ Lessons      - Was hat funktioniert? Was nicht?               │  │
│  │ Workflows    - WIE geht es? (Prozedurales Gedaechtnis)        │  │
│  │ Sessions     - Was war mein Ziel? (Ausrichtung auf Zukunft)   │  │
│  │ Fakten       - docs/help/ + wiki/ + facts (Weltwissen)             │  │
│  │ Best Pract.  - Zu Regeln gemachte Erfahrungen                 │  │
│  └───────────────────────────────────────────────────────────────┘  │
│        │                                                            │
│        │ ABRUF ──> automatisch: Injektoren                          │
│        │      ──> bewusst: Nachdenken                               │
│        v                                                            │
│  ┌───────────────────────────────────────────────────────────────┐  │
│  │  JETZT-EBENE                                                  │  │
│  │  (1) ENERGIESPAREN: Regeln abrufen, automatisch handeln       │  │
│  │  (2) NACHDENKEN: Injektoren provozieren, Szenarien spielen    │  │
│  │  -> HANDELN -> Ergebnis (= neues EREIGNIS)                    │  │
│  └───────────────────────────────────────────────────────────────┘  │
│        │                                                            │
│        v EREIGNIS                                                   │
│  ┌───────────────────────────────────────────────────────────────┐  │
│  │  SPEICHERN -> lessons, facts, sessions                        │  │
│  └───────────────────────────────────────────────────────────────┘  │
│        │                                                            │
│        v                                                            │
│  ┌───────────────────────────────────────────────────────────────┐  │
│  │  KONSOLIDIERUNG (= Schlaf)                                    │  │
│  │  Komprimieren, Best Practices bilden, Lessons ableiten        │  │
│  └───────────────────────────────────────────────────────────────┘  │
│        │                                                            │
│        v                                                            │
│  ┌───────────────────────────────────────────────────────────────┐  │
│  │  RÜCKFLUSS -> Injektoren aktualisieren                       │  │
│  │  System verhält sich ANDERS = echtes Lernen                  │  │
│  └───────────────────────────────────────────────────────────────┘  │
│        │                                                            │
│        └──────> zurück zu MEMORY (neuer Zustand)                   │
└─────────────────────────────────────────────────────────────────────┘
```

ZUORDNUNG: MENSCHLICHES GEDAECHTNIS <-> BACH
--------------------------------------------

| Menschlich               | BACH-Entsprechung              | Funktion                    |
|--------------------------|--------------------------------|-----------------------------|
| Zentrale Exekutive       | Injektoren                     | Aufmerksamkeit steuern      |
| Arbeitsgedaechtnis       | memory_working                 | Aktuelle Session            |
| Prozedurales Gedaechtnis | Workflows, tools/, skills/     | WIE man etwas tut           |
| Episodisches Gedaechtnis | memory_lessons, memory_sessions| WAS passiert ist            |
| Semantisches Gedaechtnis | docs/help/, wiki/, memory_facts     | Weltwissen (fast leer*)     |
| Regelwissen              | Best Practices, SKILL.md       | Bewaehrte Erfahrungen       |

*) Semantisches Gedaechtnis ist bei BACH fast leer, weil das Weltwissen
   bereits in den Trainingsdaten des LLM enthalten ist.

INJEKTOREN ALS "GEDANKEN"
-------------------------

Injektoren entsprechen Gedanken im menschlichen Denken:
- AUTOMATISCH: Feuern bei Keyword-Match (wie unbewusste Assoziationen)
- BEWUSST: Gezielt provozieren durch Nachfragen (wie Nachdenken)

Zwei Modi der Verarbeitung:
  (1) ENERGIESPAREN - Schnell, regelbasiert, automatisch
      -> Injektoren feuern, direkte Aktion
  (2) NACHDENKEN - Langsam, assoziativ, bewusst
      -> Injektoren reflektieren, Szenarien durchspielen
  (3) KONSOLIDIERUNG - Offline, komprimierend (= Schlaf)
      -> bach consolidate (Daemon-Job)

AKTUELLER STAND & ZIEL
----------------------

IST-Zustand (seit v1.1.80 teilweise dynamisch):
  Wissen -> Memory (DB) -> Trigger-DB (900+ dynamische Trigger)
  Injektoren sind teilweise dynamisch (Trigger-DB + Python-Dicts)

SOLL-Zustand (in Arbeit):
  Wissen -> Memory (DB) -> Injektoren -> Verhalten aendert sich
                       -> Workflows -> Automation
                       -> Patterns -> Delegation

Der "Rückfluss" von konsolidiertem Wissen in die Injektoren
ist das fehlende Stück für echtes Lernen.

Siehe auch:
  --help injectors     (Injektor-System)
  --help consolidation (Konsolidierungs-Engine)
  docs/archive/ANALYSE_Lernsysteme_BACH_vs_recludOS.md (Vollanalyse)

---
Version: 1.3.0 | Aktualisiert: 2026-02-08
(Connector-Integration dokumentiert, Library API + Headless API ergänzt)
