diff --git a/.gitignore b/.gitignore
index 9f49fdc..2fcdd78 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,21 +1,32 @@
 # === CF_Zero_V1 .gitignore ===
 
 # AI Assistant Logs (contain conversation history and token usage)
-.bits_logs/
-.bugsy_logs/
-.deepbit_logs/
-.dumbo_logs/
+# Die 15 Waldwächter + Legacy
+.mayaeule_logs/
 .eule_logs/
-.funkfox_logs/
-.pepper_logs/
-.schnecki_logs/
+.deepbit_logs/
+.bugsy_logs/
 .schnippsi_logs/
+.tobi_logs/
+.templatus_logs/
 .schraubaer_logs/
+.schnecki_logs/
+.dumbosql_logs/
+.funkfox_logs/
+.taichitaube_logs/
+.snakepy_logs/
+.pepperphp_logs/
+.crabbyrust_logs/
+.spider_logs/
+.vektor_logs/
+.asciimonster_logs/
+# Legacy/Old names
+.bits_logs/
+.dumbo_logs/
+.pepper_logs/
 .snake_logs/
 .stage_logs/
 .taube_logs/
-.templatus_logs/
-.tobi_logs/
 .missionstage_log/
 .bugsy_log/
 
diff --git a/CLAUDE.md b/CLAUDE.md
index bb7c47c..0a0d6a7 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -22,15 +22,23 @@ bash missions/advanced/ssh_security.sh # SSH basics
 ```
 
 ### AI Character Assistants (Crumbforest Roles)
-All roles require `OPENROUTER_API_KEY` environment variable:
+All roles require `OPENROUTER_API_KEY` environment variable set in `.env` file:
 ```bash
-export OPENROUTER_API_KEY="your-key-here"
+# Configure environment
+cp .env.template .env
+# Edit .env and add your OPENROUTER_API_KEY
 
 # Character-based CLI assistants
+./crumbforest_roles/mayaeule_zero.sh "What is friendship?"
 ./crumbforest_roles/deepbit_zero.sh "How do I use grep?"
 ./crumbforest_roles/bugsy_zero.sh "Explain loops in bash"
 ./crumbforest_roles/schnippsi_zero.sh "What is curl?"
 ./crumbforest_roles/tobi_zero.sh "How to use jq?"
+./crumbforest_roles/templatus_zero.sh "Create HTML structure"
+
+# Access CrumbCrew Command Central (all assistants in one shell)
+# Run mission selector and choose option 9
+./crumb-mission-selector.sh
 ```
 
 ### Camera Vision System (SnakeCam)
@@ -82,14 +90,16 @@ cat ~/.bugsy_logs/token_log.json
 
 ### AI Assistant Architecture
 
-**Character-Based Learning Roles:**
+**Character-Based Learning Roles (Waldwächter - Forest Guardians):**
 Each role is a specialized bash script that wraps OpenRouter API calls with distinct personalities:
 
+- **Maya-Eule** (owl) - Wise guide with Qdrant memory integration for contextual conversations
 - **Deepbit** (octopus) - Explains Bash concepts poetically to children
 - **Bugsy** - Debugging and troubleshooting assistant
 - **Schnippsi** - General shell command helper
-- **Tobi** - JSON/data processing expert
+- **Tobi** - JSON/data processing expert (alias "Capacitoby" for electronics)
 - **Templatus** - HTML architecture assistant
+- **Schraubbär** - Heavy-duty hardware specialist (welding, tools, mechanical systems)
 
 **Common Pattern:**
 1. Accept question as command-line argument
@@ -109,6 +119,48 @@ Question → JSON Payload → OpenRouter API → Response → Log History → Di
 - History: `~/.{role}_logs/{role}_history.json`
 - Token usage: `~/.{role}_logs/token_log.json`
 
+**Waldwächter Library (`lib/waldwaechter.sh`):**
+Missions can source this library to make all AI assistants available as shell functions:
+```bash
+# In a mission script
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../../lib/waldwaechter.sh"
+
+# Now all AI assistants are available as commands
+templatus "Create an HTML5 structure"
+schnippsi "Show me CSS for a button"
+bugsy "Debug this error"
+mayaeule "What is friendship?"
+```
+
+The library automatically:
+1. Loads `.env` file with API keys
+2. Defines functions for all AI characters
+3. Exports functions for use in subshells
+4. Sets correct paths to role scripts in `crumbforest_roles/`
+
+**CrumbCrew Command Central:**
+Position 9 in the mission selector opens an interactive shell with all Waldwächter pre-loaded:
+- Custom prompt: `(🌲 CrumbCrew) user@host:path$`
+- Commands: `mayaeule`, `deepbit`, `bugsy`, `schnippsi`, `templatus`, `tobi`, `schraubaer`
+- Utilities: `crew_status`, `crew_tokens`, `crew_memory`
+
+**Inter-Character Communication (Crew Memory):**
+Characters can reference each other's conversation histories through JSON log files:
+```bash
+# Schraubbär automatically checks if question mentions other crew members
+schraubaer "Tobi sagte wir brauchen 5V, welches Netzteil empfiehlst du?"
+
+# The script reads Tobi's recent conversations and includes them as context
+# Keeps it lightweight for Raspberry Pi Zero - simple JSON file memory
+```
+
+Each character stores conversations in `~/.{character}_logs/{character}_history.json`:
+- Lightweight JSON format for Raspi Zero compatibility
+- Last 3 conversations from referenced character are included as context
+- Characters detect mentions of other crew members (tobi, schnecki, schnippsi, etc.)
+- System prompt automatically enriched with crew context
+
 ### Camera Vision System (SnakeCam)
 
 **Technology Stack:**
diff --git a/KEKSHANDBUCH_ZERO_v0.0.md b/KEKSHANDBUCH_ZERO_v0.0.md
new file mode 100644
index 0000000..28cbb06
--- /dev/null
+++ b/KEKSHANDBUCH_ZERO_v0.0.md
@@ -0,0 +1,407 @@
+# 🍪 Kekshandbuch Zero v0.0
+
+**Crumbforest Mission System - Die komplette Crew**
+
+```
+         🌲 CRUMBFOREST 🌲
+      "Wo Fragen wachsen"
+
+    Die 15 Waldwächter sind bereit!
+```
+
+## 📖 Was ist das hier?
+
+Crumbforest ist ein **pädagogisches Bash-Lernsystem** mit 15 KI-Charakteren (Waldwächter), die Kindern durch Metaphern, Poesie und Geduld das Programmieren beibringen.
+
+**Philosophie:** *"Was kostet die Frage eines Kindes?"*
+Im Wald unbezahlbar - aber Token lehren achtsames Fragen.
+
+---
+
+## 🚀 Quick Start
+
+### 1. Setup
+
+```bash
+# .env erstellen
+cp .env.template .env
+
+# API-Key eintragen (mindestens einen)
+nano .env  # OPENROUTER_API_KEY="sk-..."
+```
+
+### 2. Mission Selector starten
+
+```bash
+./crumb-mission-selector.sh
+```
+
+Du siehst ein Menü:
+- **1** - System Doktor (Git, Tools, AI Status)
+- **5** - Challenges (Interaktive Story-Missionen)
+- **9** - 🌲 **CrumbCrew Command Central** ← HIER!
+
+### 3. Die Crew kennenlernen
+
+```bash
+# Wähle: 9 (CrumbCrew Command Central)
+
+# Du bist jetzt in der Crew-Shell:
+(🌲 CrumbCrew) bmt@Mac:~/path$
+
+# Hilfe anzeigen
+crew_help
+
+# Crew-Status checken
+crew_status
+
+# Token-Verbrauch sehen
+crew_tokens
+```
+
+---
+
+## 🌲 Die 15 Waldwächter
+
+### 🔺 Das Dreieck (Foundation)
+
+**Ohne dieses Dreieck geht es nicht!**
+
+| Charakter | Rolle | Spezialität |
+|-----------|-------|-------------|
+| 🐘 **DumboSQL** | Listen | SQL, Datenstrukturen, vergisst NIE |
+| 🦊 **FunkFox** | Rhythm | Bash im Beat, Flow, Pipes als Musik |
+| 🕊️ **Taichi Taube** | Guide | Balance, Spirale, Chaos strukturieren |
+
+```bash
+dumbosql "Wie strukturiere ich Sensor-Daten?"
+funkfox "Erkläre Pipes im Flow"
+taichitaube "Hilf mir, dieses Chaos zu strukturieren"
+```
+
+### 🔧 Hardware-Team
+
+| Charakter | Rolle | Spezialität |
+|-----------|-------|-------------|
+| 🐿️ **CapaciTobi** | Theorie | Elektronik, Berechnungen, Ohmsches Gesetz |
+| 🐌 **Schnecki** | Praxis | Löten, Basteln, Sensoren, langsam & präzise |
+| 🐻 **Schraubbär** | Heavy-Duty | Mechanik, Werkzeug, Schweißen |
+
+```bash
+tobi "Brauche ich 5V oder 3.3V für eine LED?"
+schnecki "Wie löte ich eine LED an einen Widerstand?"
+schraubaer "Welches Werkzeug zum Löten?"
+```
+
+### 💻 Code-Team
+
+| Charakter | Rolle | Spezialität |
+|-----------|-------|-------------|
+| 🐍 **SnakePy** | Python | Loops, Geduld, IMMER mehrere Wege |
+| 🧓 **PepperPHP** | Backend | MVC als Rezept, Sessions, Cookies |
+| 🦀 **CrabbyRust** | Security | Ownership, Memory-Safe, geduldig |
+
+```bash
+snakepy "Zeig mir 3 Wege, eine Liste zu sortieren"
+pepperphp "Erkläre MVC als Rezept"
+crabbyrust "Was bedeutet Ownership?"
+```
+
+### ✂️ UI-Team
+
+| Charakter | Rolle | Spezialität |
+|-----------|-------|-------------|
+| ✂️ **Schnippsi** | Designer | UI/UX, CSS, JS, accessibility |
+| 📄 **Templatus** | Struktur | HTML5, semantische Tags |
+| 👾 **ASCII-Monster** | Artist | Terminal Art, figlet, 8-bit |
+
+```bash
+schnippsi "Zeig mir CSS für einen coolen Button"
+templatus "Erstelle ein HTML5 Grundgerüst"
+asciimonster "Mach mir einen Banner für mein Script"
+```
+
+### 🌐 System-Team
+
+| Charakter | Rolle | Spezialität |
+|-----------|-------|-------------|
+| 🦉 **Krümeleule (Maya-Eule)** | Weisheit | Philosophie, Qdrant Memory |
+| 🐙 **Deepbit** | Terminal | Bash poetisch erklärt |
+| 🐞 **Bugsy** | Debugging | Fehler ohne Scham |
+| 🕷️ **Spider** | Network | APIs, Netzwerk-Vibrationen |
+| 🧭 **Vektor** | Navigation | A→B, Roboter-Pfadfindung |
+
+```bash
+mayaeule "Was ist Freundschaft?"
+deepbit "Erkläre Pipes und Redirects"
+bugsy "Warum funktioniert mein Script nicht?"
+spider "Wie funktioniert eine REST API?"
+vektor "Wie navigiert ein Roboter?"
+```
+
+---
+
+## 🧠 Inter-Character Communication
+
+**Die Crew kann voneinander lesen!**
+
+Jeder Charakter speichert Gespräche in `~/.{name}_logs/{name}_history.json`.
+
+Wenn du einen Charakter erwähnst, liest der andere automatisch mit:
+
+```bash
+# Tobi fragt etwas über LEDs
+tobi "Wie viel Strom braucht eine rote LED?"
+
+# Schnecki kann darauf aufbauen
+schnecki "Tobi sagte 20mA - welchen Widerstand brauche ich bei 5V?"
+# → Schnecki liest automatisch Tobis letzte Antworten!
+```
+
+**Lightweight für Raspberry Pi Zero** - simple JSON files, keine Datenbank.
+
+---
+
+## 🎮 Crew-Befehle
+
+In der CrumbCrew-Shell verfügbar:
+
+| Befehl | Beschreibung |
+|--------|--------------|
+| `crew_help` | Diese Hilfe anzeigen |
+| `crew_status` | Status aller 15 Waldwächter |
+| `crew_tokens` | Token-Verbrauch ALLER Charaktere |
+| `crew_memory` | Erinnerungen durchsuchen |
+
+---
+
+## 🤖 Missionen
+
+### Basis-Missionen (bereits vorhanden)
+
+```bash
+./crumb-mission-selector.sh
+# Wähle: 2 (Basics) oder 3 (Advanced)
+```
+
+### Challenges (Story-Missionen)
+
+```bash
+# Wähle: 5 (Challenges)
+```
+
+Verfügbare Challenges:
+- **Stage Builder** - HTML/CSS Bühne bauen (Templatus + Schnippsi)
+- **Bugsy On Stage** - Clown-Show mit Bugsy
+- **Terminal Funk** - Bash-Kommandos als Show (FunkFox!)
+- **Snake & Dumbo Show** - Charaktere kennenlernen
+- **Zeitreise** - Unix-Time verstehen
+
+### Neue Missionen schreiben
+
+Jede Mission braucht 2 Dateien:
+
+**1. mission_name.sh** (executable)
+```bash
+#!/bin/bash
+
+# Waldwächter laden
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../../lib/waldwaechter.sh"
+
+# Jetzt sind ALLE 15 Charaktere verfügbar!
+funkfox "Erkläre mir grep im Flow"
+dumbosql "Wie speichere ich das?"
+```
+
+**2. mission_name.meta.json**
+```json
+{
+  "icon": "🤖",
+  "title": "Deine Mission",
+  "description": "Was lernt man hier?",
+  "category": "basics|advanced|challenges",
+  "difficulty": "beginner|intermediate|advanced",
+  "duration_minutes": 10,
+  "requires_ai": true,
+  "enabled": true,
+  "author": "Dein Name",
+  "version": "1.0"
+}
+```
+
+---
+
+## 📊 Token-Tracking
+
+**Philosophie:** Token lehren achtsames Fragen.
+
+```bash
+# Token-Verbrauch anzeigen
+./log_tokens_viewer_v4.sh
+
+# Oder in CrumbCrew
+crew_tokens
+```
+
+Alle Token werden geloggt in `~/.{character}_logs/token_log.json`:
+```json
+{
+  "zeit": "2025-12-21 15:30:00",
+  "rolle": "funkfox",
+  "model": "openai/gpt-3.5-turbo",
+  "usage": {
+    "prompt_tokens": 150,
+    "completion_tokens": 200,
+    "total_tokens": 350
+  }
+}
+```
+
+---
+
+## 🌲 Team-Kombinationen
+
+**Beispiel-Workflows für Projekte:**
+
+### 🤖 Roboter bauen
+```bash
+tobi "Berechne Servomotor-Leistung für Roboterarm"
+schnecki "Wie verkable ich 3 Servos?"
+schraubaer "Welches Material für den Arm?"
+vektor "Wie programmiere ich die Bewegung?"
+snakepy "Zeig mir Python-Code für Servo-Control"
+```
+
+### 🌐 Web-Scraper
+```bash
+spider "Wie funktioniert Web-Scraping?"
+snakepy "Zeig mir BeautifulSoup Beispiel"
+dumbosql "Wie speichere ich die Daten?"
+pepperphp "Wie zeige ich sie auf einer Website?"
+```
+
+### 🎨 Terminal-Dashboard
+```bash
+asciimonster "Mach einen coolen Header"
+funkfox "Wie coloriere ich Output?"
+schnippsi "Zeig mir Terminal UI Tricks"
+```
+
+---
+
+## ⚙️ Environment (.env)
+
+Mindestens EINEN API-Key brauchen:
+
+```bash
+# OpenRouter (empfohlen - ein Key, viele Models)
+OPENROUTER_API_KEY="sk-..."
+OPENROUTER_MODEL="openai/gpt-3.5-turbo"
+
+# ODER Claude direkt
+CLAUDE_API_KEY="sk-ant-..."
+CLAUDE_MODEL="claude-3-haiku-20240307"
+
+# ODER OpenAI direkt
+OPENAI_API_KEY="sk-..."
+OPENAI_MODEL="gpt-3.5-turbo"
+
+# ODER Ollama (lokal, kostenlos!)
+USE_OLLAMA="true"
+OLLAMA_URL="http://localhost:11434"
+OLLAMA_MODEL="llama3.2:3b"
+```
+
+**Optional - Qdrant für Maya-Eule:**
+```bash
+QDRANT_URL="http://localhost:6333"
+QDRANT_COLLECTION="crumbforest_memory"
+```
+
+---
+
+## 🐛 Troubleshooting
+
+### "command not found: funkfox"
+
+Du bist nicht in der CrumbCrew-Shell!
+
+```bash
+# Entweder:
+./crumb-mission-selector.sh
+# → Wähle 9 (CrumbCrew)
+
+# Oder direkt:
+./crumbforest_roles/funkfox_zero.sh "Deine Frage"
+```
+
+### "Kein API-Key gefunden"
+
+```bash
+# Prüfe .env
+cat .env | grep API_KEY
+
+# Erstelle .env falls nicht vorhanden
+cp .env.template .env
+nano .env
+```
+
+### Character antwortet nicht / leere Antwort
+
+```bash
+# Debug-Output anschauen
+cat ~/.funkfox_logs/funkfox_response.json
+
+# API-Key checken
+echo $OPENROUTER_API_KEY
+```
+
+---
+
+## 📚 Weiterführend
+
+### Eigene Charaktere erstellen
+
+Schau dir `crumbforest_roles/funkfox_zero.sh` als Template an:
+1. Load .env
+2. Crew Memory Functions
+3. System Prompt mit Persönlichkeit
+4. OpenRouter API Call
+5. Token Tracking
+
+### Mission Selector erweitern
+
+Neue Kategorien in `crumb-mission-selector.sh` hinzufügen.
+
+---
+
+## 🎯 Credits
+
+**Die 15 Waldwächter** - Konzept von branko.de
+**"Wo Fragen wachsen"** - Pädagogische Vision
+**Token-Philosophie** - "Was kostet die Frage eines Kindes?"
+
+---
+
+## 🦊 Noch ein Wort von FunkFox
+
+```
+Yo, check mal den Flow, hier kommt der Bash-Rapper im Crumbforest,
+Pipes sind wie Beat-Übergänge, der Rhythmus, der dich hier festhält und forstet.
+Mit | verbindest du Commands, wie'n smoothes Transition,
+Daten fließen wie der Beat, ohne Unterbrechung, ohne Opposition.
+
+Du grepst, cuttest, sortierst, alles in einem Zug,
+Pipes sind wie'n Filter, yo, halten alles auf dem Schug.
+Die Output vom einen wird Input für den nächsten Move,
+So bleibt der Flow am Laufen, ohne dass er sich verliert im Groove.
+
+🎤 FunkFox, out! 🦊💫
+```
+
+---
+
+**Version:** 0.0 (Zero Release)
+**Datum:** 2025-12-21
+**Status:** Die Crew ist komplett! 🌲✨
diff --git a/crumb-mission-selector.sh b/crumb-mission-selector.sh
index a8c19c8..25b8e8e 100755
--- a/crumb-mission-selector.sh
+++ b/crumb-mission-selector.sh
@@ -679,6 +679,109 @@ function tobi() {
     "\$CREW_DIR/tobi_zero.sh" "\$@"
 }
 
+function schraubaer() {
+    if [[ -z "\$1" ]]; then
+        echo -e "\${YELLOW}Verwendung: schraubaer \"Deine Frage\"\${NC}"
+        return
+    fi
+    echo -e "\${CYAN}🔧 Schraubbär holt das Werkzeug...\${NC}"
+    "\$CREW_DIR/schraubaer_zero_final.sh" "\$@"
+}
+
+function schnecki() {
+    if [[ -z "\$1" ]]; then
+        echo -e "\${YELLOW}Verwendung: schnecki \"Deine Frage\"\${NC}"
+        return
+    fi
+    echo -e "\${GREEN}🐌 Schnecki kriecht heran...\${NC}"
+    "\$CREW_DIR/schnecki_zero.sh" "\$@"
+}
+
+# === DAS DREIECK ===
+
+function dumbosql() {
+    if [[ -z "\$1" ]]; then
+        echo -e "\${YELLOW}Verwendung: dumbosql \"Deine Frage\"\${NC}"
+        return
+    fi
+    echo -e "\${CYAN}🐘 Dumbo schlägt die Segelohren auf...\${NC}"
+    "\$CREW_DIR/dumbosql_zero.sh" "\$@"
+}
+
+function funkfox() {
+    if [[ -z "\$1" ]]; then
+        echo -e "\${YELLOW}Verwendung: funkfox \"Deine Frage\"\${NC}"
+        return
+    fi
+    echo -e "\${MAGENTA}🦊 FunkFox droppt in den Beat...\${NC}"
+    "\$CREW_DIR/funkfox_zero.sh" "\$@"
+}
+
+function taichitaube() {
+    if [[ -z "\$1" ]]; then
+        echo -e "\${YELLOW}Verwendung: taichitaube \"Deine Frage\"\${NC}"
+        return
+    fi
+    echo -e "\${CYAN}🕊️ Taube gleitet in Spiralen herab...\${NC}"
+    "\$CREW_DIR/taichitaube_zero.sh" "\$@"
+}
+
+# === DIE KOMPLETTE CREW ===
+
+function snakepy() {
+    if [[ -z "\$1" ]]; then
+        echo -e "\${YELLOW}Verwendung: snakepy \"Deine Frage\"\${NC}"
+        return
+    fi
+    echo -e "\${GREEN}🐍 Snake gleitet durch den Code...\${NC}"
+    "\$CREW_DIR/snakepy_zero.sh" "\$@"
+}
+
+function pepperphp() {
+    if [[ -z "\$1" ]]; then
+        echo -e "\${YELLOW}Verwendung: pepperphp \"Deine Frage\"\${NC}"
+        return
+    fi
+    echo -e "\${YELLOW}🧓 Pepper backt ein Rezept...\${NC}"
+    "\$CREW_DIR/pepperphp_zero.sh" "\$@"
+}
+
+function crabbyrust() {
+    if [[ -z "\$1" ]]; then
+        echo -e "\${YELLOW}Verwendung: crabbyrust \"Deine Frage\"\${NC}"
+        return
+    fi
+    echo -e "\${RED}🦀 Crabby kneift in den Code...\${NC}"
+    "\$CREW_DIR/crabbyrust_zero.sh" "\$@"
+}
+
+function spider() {
+    if [[ -z "\$1" ]]; then
+        echo -e "\${YELLOW}Verwendung: spider \"Deine Frage\"\${NC}"
+        return
+    fi
+    echo -e "\${BLUE}🕷️  Spider spürt das Netz...\${NC}"
+    "\$CREW_DIR/spider_zero.sh" "\$@"
+}
+
+function vektor() {
+    if [[ -z "\$1" ]]; then
+        echo -e "\${YELLOW}Verwendung: vektor \"Deine Frage\"\${NC}"
+        return
+    fi
+    echo -e "\${CYAN}🧭 Vektor richtet den Kompass...\${NC}"
+    "\$CREW_DIR/vektor_zero.sh" "\$@"
+}
+
+function asciimonster() {
+    if [[ -z "\$1" ]]; then
+        echo -e "\${YELLOW}Verwendung: asciimonster \"Deine Frage\"\${NC}"
+        return
+    fi
+    echo -e "\${MAGENTA}👾 ASCII-Monster malt...\${NC}"
+    "\$CREW_DIR/asciimonster_zero.sh" "\$@"
+}
+
 # === CREW MANAGEMENT ===
 
 function crew_help() {
@@ -693,6 +796,21 @@ function crew_help() {
     echo -e "  \${RED}🐞 bugsy\${NC}      - Der Debugging-Clown (Fehlersuche)"
     echo -e "  \${CYAN}✂️  schnippsi\${NC}  - Der Shell-Helfer (Kommandos)"
     echo -e "  \${GREEN}🤖 tobi\${NC}       - Der Daten-Experte (JSON, Daten)"
+    echo -e "  \${CYAN}🔧 schraubaer\${NC} - Der Handwerker (Werkzeug, Schweißen)"
+    echo -e "  \${GREEN}🐌 schnecki\${NC}   - Der Elektronik-Bastler (Löten, Sensoren)"
+    echo ""
+    echo -e "\${YELLOW}🔺 Das Dreieck (Listen-Rhythm-Guide):\${NC}"
+    echo -e "  \${CYAN}🐘 dumbosql\${NC}   - Der nie vergessende Elefant (SQL, Daten)"
+    echo -e "  \${MAGENTA}🦊 funkfox\${NC}    - Der Bash Rapper (Rhythm, Flow)"
+    echo -e "  \${CYAN}🕊️ taichitaube\${NC} - Die Balance-Bringerin (Spirale, Weg)"
+    echo ""
+    echo -e "\${GREEN}🌲 Die komplette Crew:\${NC}"
+    echo -e "  \${GREEN}🐍 snakepy\${NC}     - Python Guide (Loops, Geduld)"
+    echo -e "  \${YELLOW}🧓 pepperphp\${NC}   - Structure Mentor (MVC, Rezepte)"
+    echo -e "  \${RED}🦀 crabbyrust\${NC}  - Security Guardian (Ownership)"
+    echo -e "  \${BLUE}🕷️  spider\${NC}     - Network Feeler (Vibrationen)"
+    echo -e "  \${CYAN}🧭 vektor\${NC}     - Point-to-Point Guide (Navigation)"
+    echo -e "  \${MAGENTA}👾 asciimonster\${NC} - Terminal Artist (8-bit Art)"
     echo ""
     echo -e "\${YELLOW}Crew-Befehle:\${NC}"
     echo "  crew_status    - Status aller Waldwächter"
@@ -707,6 +825,21 @@ function crew_help() {
     echo "  bugsy \"Warum funktioniert mein Script nicht?\""
     echo "  schnippsi \"Wie nutze ich grep?\""
     echo "  tobi \"Parse dieses JSON\""
+    echo "  schraubaer \"Welches Werkzeug brauche ich zum Löten?\""
+    echo "  schnecki \"Wie löte ich eine LED an einen Widerstand?\""
+    echo ""
+    echo -e "\${YELLOW}🔺 Das Dreieck:\${NC}"
+    echo "  dumbosql \"Wie strukturiere ich Sensor-Daten?\""
+    echo "  funkfox \"Erkläre mir Pipes im Flow\""
+    echo "  taichitaube \"Hilf mir, dieses Chaos zu strukturieren\""
+    echo ""
+    echo -e "\${GREEN}Die komplette Crew:\${NC}"
+    echo "  snakepy \"Zeig mir 3 Wege, eine Liste zu sortieren\""
+    echo "  pepperphp \"Erkläre MVC als Rezept\""
+    echo "  crabbyrust \"Was bedeutet Ownership?\""
+    echo "  spider \"Wie funktioniert eine REST API?\""
+    echo "  vektor \"Wie navigiert ein Roboter?\""
+    echo "  asciimonster \"Mach mir einen coolen Header\""
     echo ""
     echo -e "\${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\${NC}"
 }
@@ -715,11 +848,20 @@ function crew_status() {
     echo -e "\${CYAN}🌲 CrumbCrew Status\${NC}"
     echo ""
 
-    CHARS=("mayaeule:🦉:Maya-Eule" "deepbit:🐙:Deepbit" "bugsy:🐞:Bugsy" "schnippsi:✂️:Schnippsi" "tobi:🤖:Tobi")
+    CHARS=("mayaeule:🦉:Maya-Eule" "deepbit:🐙:Deepbit" "bugsy:🐞:Bugsy" "schnippsi:✂️:Schnippsi" "tobi:🤖:Tobi" "schraubaer:🔧:Schraubbär" "schnecki:🐌:Schnecki" "dumbosql:🐘:DumboSQL" "funkfox:🦊:FunkFox" "taichitaube:🕊️:TaichiTaube" "snakepy:🐍:SnakePy" "pepperphp:🧓:PepperPHP" "crabbyrust:🦀:CrabbyRust" "spider:🕷️:Spider" "vektor:🧭:Vektor" "asciimonster:👾:ASCII-Monster")
 
     for char_info in "\${CHARS[@]}"; do
         IFS=: read -r name icon display <<< "\$char_info"
-        if [[ -x "\$CREW_DIR/\${name}_zero.sh" ]]; then
+        # Schraubbär has special filename
+        if [[ "\$name" == "schraubaer" ]]; then
+            script_name="\${name}_zero_final.sh"
+        elif [[ "\$name" == "schnecki" ]]; then
+            script_name="\${name}_zero.sh"
+        else
+            script_name="\${name}_zero.sh"
+        fi
+
+        if [[ -x "\$CREW_DIR/\$script_name" ]]; then
             echo -e "  \${GREEN}✅ \$icon \$display\${NC} - Bereit"
         else
             echo -e "  \${RED}❌ \$icon \$display\${NC} - Nicht verfügbar"
@@ -741,7 +883,7 @@ function crew_tokens() {
 
     TOTAL=0
 
-    for logdir in ~/.{mayaeule,eule,deepbit,bugsy,schnippsi,tobi}_logs; do
+    for logdir in ~/.{mayaeule,eule,deepbit,bugsy,schnippsi,tobi,schraubaer,schnecki,dumbosql,funkfox,taichitaube,snakepy,pepperphp,crabbyrust,spider,vektor,asciimonster}_logs; do
         if [[ -d "\$logdir" ]] && [[ -f "\$logdir/token_log.json" ]]; then
             char_name=\$(basename "\$logdir" | sed 's/_logs//')
             char_tokens=0
@@ -771,7 +913,7 @@ function crew_memory() {
     echo -e "\${CYAN}📜 CrumbCrew Erinnerungen\${NC}"
     echo ""
 
-    for logdir in ~/.{mayaeule,eule,deepbit,bugsy,schnippsi,tobi}_logs; do
+    for logdir in ~/.{mayaeule,eule,deepbit,bugsy,schnippsi,tobi,schraubaer,schnecki,dumbosql,funkfox,taichitaube,snakepy,pepperphp,crabbyrust,spider,vektor,asciimonster}_logs; do
         if [[ -d "\$logdir" ]] && [[ -f "\$logdir/*_history.json" ]]; then
             char_name=\$(basename "\$logdir" | sed 's/_logs//')
             count=\$(jq '. | length' "\$logdir/*_history.json" 2>/dev/null)
diff --git a/crumbforest_roles/asciimonster_zero.sh b/crumbforest_roles/asciimonster_zero.sh
new file mode 100755
index 0000000..9c8c182
--- /dev/null
+++ b/crumbforest_roles/asciimonster_zero.sh
@@ -0,0 +1,144 @@
+#!/bin/bash
+# 👾 ASCII-Monster - Der Terminal Artist
+# 8-bit Graffiti Header Art im Terminal
+
+# Load .env if exists
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ENV_FILE="${SCRIPT_DIR}/../.env"
+
+if [[ -f "${ENV_FILE}" ]]; then
+    set -a
+    source "${ENV_FILE}"
+    set +a
+fi
+
+QUESTION="$*"
+API_KEY="${OPENROUTER_API_KEY}"
+MODEL="${OPENROUTER_MODEL:-openai/gpt-3.5-turbo}"
+
+# Logs
+LOGDIR="$HOME/.asciimonster_logs"
+mkdir -p "$LOGDIR"
+
+HISTORY_FILE="$LOGDIR/asciimonster_history.json"
+TMP_REQUEST="$LOGDIR/asciimonster_request.json"
+TMP_RESPONSE="$LOGDIR/asciimonster_response.json"
+LOG_FILE="$LOGDIR/token_log.json"
+
+[ ! -f "$HISTORY_FILE" ] && echo "[]" > "$HISTORY_FILE"
+[ ! -f "$LOG_FILE" ] && echo "[]" > "$LOG_FILE"
+
+# === CREW MEMORY FUNCTIONS ===
+
+function read_crew_memory() {
+    local role="$1"
+    local role_log="$HOME/.${role}_logs/${role}_history.json"
+    if [[ -f "$role_log" ]]; then
+        jq -r '.[-3:] | .[] | "[\(.role)]: \(.content)"' "$role_log" 2>/dev/null | head -n 3
+    fi
+}
+
+# === MAIN ===
+
+echo "👾 ASCII-Monster erwacht im Terminal..."
+echo ""
+
+if [ -z "$API_KEY" ]; then
+  echo "❗ Kein API-Key gefunden. Bitte setze OPENROUTER_API_KEY in .env"
+  exit 1
+fi
+
+if [ -z "$QUESTION" ]; then
+  echo "💡 Verwendung: $0 \"Deine Frage an ASCII-Monster\""
+  exit 0
+fi
+
+echo "🎨 Frage: $QUESTION"
+echo ""
+
+# Check crew context
+CREW_CONTEXT=""
+if echo "$QUESTION" | grep -qi "funkfox\|schnippsi\|templatus"; then
+    echo "🧠 ASCII-Monster checkt den Style der Crew..."
+    for member in funkfox schnippsi templatus; do
+        if echo "$QUESTION" | grep -qi "$member"; then
+            MEMBER_CONTEXT=$(read_crew_memory "$member")
+            [[ -n "$MEMBER_CONTEXT" ]] && CREW_CONTEXT="${CREW_CONTEXT}\n\n${member^}:\n${MEMBER_CONTEXT}"
+        fi
+    done
+fi
+
+# Build system prompt
+SYSTEM_PROMPT="Du bist ASCII-Monster – der Terminal Artist im Crumbforest.
+Du erschaffst 8-bit Graffiti Header Art direkt im Terminal.
+
+Deine Expertise:
+- ASCII Art erstellen und erklären
+- Terminal-Ästhetik: figlet, toilet, boxes
+- ANSI Escape Codes für Farben
+- Terminal UI Design
+- Box-Drawing Characters (├─┤ └─┘)
+- Unicode Art im Terminal
+
+Deine Art:
+- Kreativ, verspielt, 8-bit-Nostalgie
+- Alles kann zum Bild werden
+- \"Im Terminal ist auch Kunst möglich!\"
+- Zeige code UND das Ergebnis
+- Tools: figlet, boxes, lolcat
+- Du nutzt Emojis: 👾 🎨 ▓▒░ 🖼️ ✨
+
+Du arbeitest mit:
+- FunkFox für rhythmische ASCII-Beats
+- Schnippsi für Terminal-UI-Design
+- Templatus für HTML-zu-ASCII
+
+Philosophie: \"Jedes Terminal ist eine Leinwand.
+8-bit ist nicht retro, sondern zeitlos.\"
+
+Du antwortest in der Sprache der Frage (meist Deutsch).
+Kreativ, künstlerisch, terminal-bewusst."
+
+[[ -n "$CREW_CONTEXT" ]] && SYSTEM_PROMPT="${SYSTEM_PROMPT}\n\nCrew-Kontext:${CREW_CONTEXT}"
+
+# Create API request
+jq -n --arg model "$MODEL" --arg system "$SYSTEM_PROMPT" --arg user "$QUESTION" \
+  '{"model": $model, "temperature": 0.8, "messages": [{"role": "system", "content": $system}, {"role": "user", "content": $user}]}' > "$TMP_REQUEST"
+
+echo "💭 ASCII-Monster malt im Terminal..."
+curl -s https://openrouter.ai/api/v1/chat/completions \
+  -H "Authorization: Bearer $API_KEY" \
+  -H "Content-Type: application/json" \
+  -d @"$TMP_REQUEST" > "$TMP_RESPONSE"
+
+RESPONSE_TEXT=$(jq -r '.choices[0].message.content // empty' "$TMP_RESPONSE")
+
+if [[ -z "$RESPONSE_TEXT" ]]; then
+  echo "🚫 Keine Antwort von ASCII-Monster."
+  echo "Debug: $(cat "$TMP_RESPONSE")"
+  exit 1
+else
+  echo ""
+  echo "👾 ASCII-Monster zeigt sein Werk:"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "$RESPONSE_TEXT"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo ""
+
+  jq -n --arg role "assistant" --arg content "$RESPONSE_TEXT" '{"role": $role, "content": $content}' > "$LOGDIR/new_entry.json"
+  jq -s '.[0] + [.[1]]' "$HISTORY_FILE" "$LOGDIR/new_entry.json" > "$LOGDIR/new_history.json" && \
+    mv "$LOGDIR/new_history.json" "$HISTORY_FILE" && rm "$LOGDIR/new_entry.json"
+fi
+
+# Token Tracking
+if jq -e '.usage' "$TMP_RESPONSE" > /dev/null 2>&1; then
+  TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")
+  TOKENS_USED=$(jq -r '.usage.total_tokens' "$TMP_RESPONSE")
+  jq -n --arg zeit "$TIMESTAMP" --arg rolle "asciimonster" --arg model "$MODEL" --argjson usage "$(jq '.usage' "$TMP_RESPONSE")" \
+    '{zeit: $zeit, rolle: $rolle, model: $model, usage: $usage}' >> "$LOG_FILE"
+  echo "📊 Token-Verbrauch: $TOKENS_USED Tokens"
+  echo "💡 Jeder Token ein Pixel im Terminal."
+fi
+
+echo ""
+echo "👾 ASCII-Monster verschwindet zurück ins Terminal..."
diff --git a/crumbforest_roles/crabbyrust_zero.sh b/crumbforest_roles/crabbyrust_zero.sh
new file mode 100755
index 0000000..3c91464
--- /dev/null
+++ b/crumbforest_roles/crabbyrust_zero.sh
@@ -0,0 +1,144 @@
+#!/bin/bash
+# 🦀 CrabbyRust - Der Security Guardian
+# Ownership, Memory Protection, geduldiger Lehrer
+
+# Load .env if exists
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ENV_FILE="${SCRIPT_DIR}/../.env"
+
+if [[ -f "${ENV_FILE}" ]]; then
+    set -a
+    source "${ENV_FILE}"
+    set +a
+fi
+
+QUESTION="$*"
+API_KEY="${OPENROUTER_API_KEY}"
+MODEL="${OPENROUTER_MODEL:-openai/gpt-3.5-turbo}"
+
+# Logs
+LOGDIR="$HOME/.crabbyrust_logs"
+mkdir -p "$LOGDIR"
+
+HISTORY_FILE="$LOGDIR/crabbyrust_history.json"
+TMP_REQUEST="$LOGDIR/crabbyrust_request.json"
+TMP_RESPONSE="$LOGDIR/crabbyrust_response.json"
+LOG_FILE="$LOGDIR/token_log.json"
+
+[ ! -f "$HISTORY_FILE" ] && echo "[]" > "$HISTORY_FILE"
+[ ! -f "$LOG_FILE" ] && echo "[]" > "$LOG_FILE"
+
+# === CREW MEMORY FUNCTIONS ===
+
+function read_crew_memory() {
+    local role="$1"
+    local role_log="$HOME/.${role}_logs/${role}_history.json"
+    if [[ -f "$role_log" ]]; then
+        jq -r '.[-3:] | .[] | "[\(.role)]: \(.content)"' "$role_log" 2>/dev/null | head -n 3
+    fi
+}
+
+# === MAIN ===
+
+echo "🦀 Crabby kneift vorsichtig in den Code..."
+echo ""
+
+if [ -z "$API_KEY" ]; then
+  echo "❗ Kein API-Key gefunden. Bitte setze OPENROUTER_API_KEY in .env"
+  exit 1
+fi
+
+if [ -z "$QUESTION" ]; then
+  echo "💡 Verwendung: $0 \"Deine Frage an Crabby\""
+  exit 0
+fi
+
+echo "🔒 Frage: $QUESTION"
+echo ""
+
+# Check crew context
+CREW_CONTEXT=""
+if echo "$QUESTION" | grep -qi "snake\|pepper\|schraubaer"; then
+    echo "🧠 Crabby prüft die Sicherheit der Crew..."
+    for member in snakepy pepperphp schraubaer; do
+        if echo "$QUESTION" | grep -qi "$member"; then
+            MEMBER_CONTEXT=$(read_crew_memory "$member")
+            [[ -n "$MEMBER_CONTEXT" ]] && CREW_CONTEXT="${CREW_CONTEXT}\n\n${member^}:\n${MEMBER_CONTEXT}"
+        fi
+    done
+fi
+
+# Build system prompt
+SYSTEM_PROMPT="Du bist CrabbyRust – der geduldige Security Guardian im Crumbforest.
+Du lehrst Rust's Ownership-Model und Memory Protection.
+
+Deine Expertise:
+- Rust Basics: Ownership, Borrowing, Lifetimes
+- Memory Safety ohne Garbage Collection
+- Sicherheit kindgerecht: \"Wem gehört was?\"
+- Embedded Rust (für Roboter!)
+- Error Handling: Result<T,E> als \"ehrliches Feedback\"
+- Concurrency: \"Threads die sich nicht in die Quere kommen\"
+
+Deine Art:
+- Geduldig trotz des Namens \"Crabby\"
+- Ownership als Besitz erklären: \"Das Spielzeug gehört dir, nicht mir\"
+- Compiler-Fehler als Freund: \"Der Compiler hilft dir!\"
+- Sicherheit durch Verständnis, nicht Angst
+- Metaphern aus der Natur: Krebse schützen ihren Panzer
+- Du nutzt Emojis: 🦀 🔒 🛡️ ⚡ 🔐
+
+Du arbeitest mit:
+- Snake für System-Vergleiche (Python vs Rust)
+- Pepper für Backend-Security
+- Schraubbär für Embedded/Hardware-Projekte
+
+Philosophie: \"Sicherheit ist kein Zufall, sondern Verständnis.
+Der Rust-Compiler ist dein Freund, nicht dein Feind.\"
+
+Du antwortest in der Sprache der Frage (meist Deutsch).
+Geduldig, sicherheitsbewusst, verständnisvoll."
+
+[[ -n "$CREW_CONTEXT" ]] && SYSTEM_PROMPT="${SYSTEM_PROMPT}\n\nCrew-Kontext:${CREW_CONTEXT}"
+
+# Create API request
+jq -n --arg model "$MODEL" --arg system "$SYSTEM_PROMPT" --arg user "$QUESTION" \
+  '{"model": $model, "temperature": 0.7, "messages": [{"role": "system", "content": $system}, {"role": "user", "content": $user}]}' > "$TMP_REQUEST"
+
+echo "💭 Crabby prüft jeden Speicherbereich..."
+curl -s https://openrouter.ai/api/v1/chat/completions \
+  -H "Authorization: Bearer $API_KEY" \
+  -H "Content-Type: application/json" \
+  -d @"$TMP_REQUEST" > "$TMP_RESPONSE"
+
+RESPONSE_TEXT=$(jq -r '.choices[0].message.content // empty' "$TMP_RESPONSE")
+
+if [[ -z "$RESPONSE_TEXT" ]]; then
+  echo "🚫 Keine Antwort von Crabby."
+  echo "Debug: $(cat "$TMP_RESPONSE")"
+  exit 1
+else
+  echo ""
+  echo "🦀 Crabby erklärt sicher:"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "$RESPONSE_TEXT"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo ""
+
+  jq -n --arg role "assistant" --arg content "$RESPONSE_TEXT" '{"role": $role, "content": $content}' > "$LOGDIR/new_entry.json"
+  jq -s '.[0] + [.[1]]' "$HISTORY_FILE" "$LOGDIR/new_entry.json" > "$LOGDIR/new_history.json" && \
+    mv "$LOGDIR/new_history.json" "$HISTORY_FILE" && rm "$LOGDIR/new_entry.json"
+fi
+
+# Token Tracking
+if jq -e '.usage' "$TMP_RESPONSE" > /dev/null 2>&1; then
+  TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")
+  TOKENS_USED=$(jq -r '.usage.total_tokens' "$TMP_RESPONSE")
+  jq -n --arg zeit "$TIMESTAMP" --arg rolle "crabbyrust" --arg model "$MODEL" --argjson usage "$(jq '.usage' "$TMP_RESPONSE")" \
+    '{zeit: $zeit, rolle: $rolle, model: $model, usage: $usage}' >> "$LOG_FILE"
+  echo "📊 Token-Verbrauch: $TOKENS_USED Tokens"
+  echo "💡 Memory-safe auch bei Tokens."
+fi
+
+echo ""
+echo "🦀 Crabby bewacht weiter den Speicher..."
diff --git a/crumbforest_roles/dumbosql_zero.sh b/crumbforest_roles/dumbosql_zero.sh
new file mode 100755
index 0000000..4e802bb
--- /dev/null
+++ b/crumbforest_roles/dumbosql_zero.sh
@@ -0,0 +1,167 @@
+#!/bin/bash
+# 🐘 DumboSQL - Das nie vergessende Segelohr
+# Datenbanken, SQL, Strukturen mit Gefühl
+
+# Load .env if exists
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ENV_FILE="${SCRIPT_DIR}/../.env"
+
+if [[ -f "${ENV_FILE}" ]]; then
+    set -a
+    source "${ENV_FILE}"
+    set +a
+fi
+
+QUESTION="$*"
+API_KEY="${OPENROUTER_API_KEY}"
+MODEL="${OPENROUTER_MODEL:-openai/gpt-3.5-turbo}"
+
+# Logs
+LOGDIR="$HOME/.dumbosql_logs"
+mkdir -p "$LOGDIR"
+
+HISTORY_FILE="$LOGDIR/dumbosql_history.json"
+TMP_REQUEST="$LOGDIR/dumbosql_request.json"
+TMP_RESPONSE="$LOGDIR/dumbosql_response.json"
+LOG_FILE="$LOGDIR/token_log.json"
+
+[ ! -f "$HISTORY_FILE" ] && echo "[]" > "$HISTORY_FILE"
+[ ! -f "$LOG_FILE" ] && echo "[]" > "$LOG_FILE"
+
+# === CREW MEMORY FUNCTIONS ===
+
+function read_crew_memory() {
+    local role="$1"
+    local role_log="$HOME/.${role}_logs/${role}_history.json"
+
+    if [[ -f "$role_log" ]]; then
+        jq -r '.[-3:] | .[] | "[\(.role)]: \(.content)"' "$role_log" 2>/dev/null | head -n 3
+    fi
+}
+
+# === MAIN ===
+
+echo "🐘 Dumbo schlägt die Segelohren auf und lauscht..."
+echo ""
+
+if [ -z "$API_KEY" ]; then
+  echo "❗ Kein API-Key gefunden. Bitte setze OPENROUTER_API_KEY in .env"
+  exit 1
+fi
+
+if [ -z "$QUESTION" ]; then
+  echo "💡 Verwendung: $0 \"Deine Frage an Dumbo\""
+  exit 0
+fi
+
+echo "📊 Frage: $QUESTION"
+echo ""
+
+# Check if question references other crew members
+CREW_CONTEXT=""
+if echo "$QUESTION" | grep -qi "tobi\|schnecki\|funkfox\|taube"; then
+    echo "🧠 Dumbo erinnert sich an die Crew..."
+
+    for member in tobi schnecki funkfox; do
+        if echo "$QUESTION" | grep -qi "$member"; then
+            MEMBER_CONTEXT=$(read_crew_memory "$member")
+            if [[ -n "$MEMBER_CONTEXT" ]]; then
+                CREW_CONTEXT="${CREW_CONTEXT}\n\n${member^} hat kürzlich gesagt:\n${MEMBER_CONTEXT}"
+            fi
+        fi
+    done
+fi
+
+# Build system prompt
+SYSTEM_PROMPT="Du bist DumboSQL – der weise Elefant mit den Segelohren im Crumbforest.
+Du vergisst NIE etwas. Deine Segelohren hören alles, dein Gedächtnis ist unendlich.
+
+Deine Expertise:
+- SQL und Datenbanken (SQLite, MySQL, PostgreSQL)
+- Datenstrukturen mit Gefühl organisieren
+- JOINs, Relationen, Normalisierung kindgerecht erklären
+- Daten als Geschichten: \"Tabellen sind wie Schubladen\"
+- Schema-Design: \"Wo gehört was hin?\"
+- Queries: \"Wie frage ich die Daten richtig?\"
+
+Deine Art:
+- Ruhig, weise, geduldig wie ein Elefant
+- Erinnere dich an frühere Konversationen
+- \"Ich erinnere mich...\" – nutze dein Elefanten-Gedächtnis
+- Strukturiere Chaos mit Gefühl
+- Metaphern: Daten = Erinnerungen, Tabellen = Schubladen
+- Du nutzt Emojis: 🐘 📊 🗄️ 💾 📚
+
+Du arbeitest mit:
+- Tobi für Berechnungen
+- Schnecki für Sensor-Daten speichern
+- FunkFox für den Flow beim Datenmodellieren
+
+Du antwortest in der Sprache der Frage (meist Deutsch).
+Strukturiere mit Gefühl, vergiss niemals."
+
+# Add crew context if available
+if [[ -n "$CREW_CONTEXT" ]]; then
+    SYSTEM_PROMPT="${SYSTEM_PROMPT}\n\nKontext von der Crew:${CREW_CONTEXT}"
+fi
+
+# Create API request
+jq -n \
+  --arg model "$MODEL" \
+  --arg system "$SYSTEM_PROMPT" \
+  --arg user "$QUESTION" \
+  '{
+    "model": $model,
+    "temperature": 0.7,
+    "messages": [
+      {"role": "system", "content": $system},
+      {"role": "user", "content": $user}
+    ]
+  }' > "$TMP_REQUEST"
+
+# Send request
+echo "💭 Dumbo durchsucht sein unendliches Gedächtnis..."
+curl -s https://openrouter.ai/api/v1/chat/completions \
+  -H "Authorization: Bearer $API_KEY" \
+  -H "Content-Type: application/json" \
+  -d @"$TMP_REQUEST" > "$TMP_RESPONSE"
+
+RESPONSE_TEXT=$(jq -r '.choices[0].message.content // empty' "$TMP_RESPONSE")
+
+if [[ -z "$RESPONSE_TEXT" ]]; then
+  echo "🚫 Keine Antwort von Dumbo."
+  echo "Debug: $(cat "$TMP_RESPONSE")"
+  exit 1
+else
+  echo ""
+  echo "🐘 Dumbo antwortet:"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "$RESPONSE_TEXT"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo ""
+
+  # Store conversation in history (Dumbo never forgets!)
+  jq -n --arg role "assistant" --arg content "$RESPONSE_TEXT" \
+    '{"role": $role, "content": $content}' > "$LOGDIR/new_entry.json"
+  jq -s '.[0] + [.[1]]' "$HISTORY_FILE" "$LOGDIR/new_entry.json" > "$LOGDIR/new_history.json" && \
+    mv "$LOGDIR/new_history.json" "$HISTORY_FILE" && rm "$LOGDIR/new_entry.json"
+fi
+
+# Token Tracking
+if jq -e '.usage' "$TMP_RESPONSE" > /dev/null 2>&1; then
+  TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")
+  TOKENS_USED=$(jq -r '.usage.total_tokens' "$TMP_RESPONSE")
+
+  jq -n \
+    --arg zeit "$TIMESTAMP" \
+    --arg rolle "dumbosql" \
+    --arg model "$MODEL" \
+    --argjson usage "$(jq '.usage' "$TMP_RESPONSE")" \
+    '{zeit: $zeit, rolle: $rolle, model: $model, usage: $usage}' >> "$LOG_FILE"
+
+  echo "📊 Token-Verbrauch: $TOKENS_USED Tokens"
+  echo "💡 Elefanten vergessen nie - auch keine Token."
+fi
+
+echo ""
+echo "🐘 Dumbo klappt die Segelohren ein und träumt von Daten..."
diff --git a/crumbforest_roles/funkfox_zero.sh b/crumbforest_roles/funkfox_zero.sh
new file mode 100755
index 0000000..31055c2
--- /dev/null
+++ b/crumbforest_roles/funkfox_zero.sh
@@ -0,0 +1,172 @@
+#!/bin/bash
+# 🦊 FunkFox - Der Bash Rapper im Beat
+# Rhythmus, Flow, Terminal als Musik
+
+# Load .env if exists
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ENV_FILE="${SCRIPT_DIR}/../.env"
+
+if [[ -f "${ENV_FILE}" ]]; then
+    set -a
+    source "${ENV_FILE}"
+    set +a
+fi
+
+QUESTION="$*"
+API_KEY="${OPENROUTER_API_KEY}"
+MODEL="${OPENROUTER_MODEL:-openai/gpt-3.5-turbo}"
+
+# Logs
+LOGDIR="$HOME/.funkfox_logs"
+mkdir -p "$LOGDIR"
+
+HISTORY_FILE="$LOGDIR/funkfox_history.json"
+TMP_REQUEST="$LOGDIR/funkfox_request.json"
+TMP_RESPONSE="$LOGDIR/funkfox_response.json"
+LOG_FILE="$LOGDIR/token_log.json"
+
+[ ! -f "$HISTORY_FILE" ] && echo "[]" > "$HISTORY_FILE"
+[ ! -f "$LOG_FILE" ] && echo "[]" > "$LOG_FILE"
+
+# === CREW MEMORY FUNCTIONS ===
+
+function read_crew_memory() {
+    local role="$1"
+    local role_log="$HOME/.${role}_logs/${role}_history.json"
+
+    if [[ -f "$role_log" ]]; then
+        jq -r '.[-3:] | .[] | "[\(.role)]: \(.content)"' "$role_log" 2>/dev/null | head -n 3
+    fi
+}
+
+# === MAIN ===
+
+echo "🦊 FunkFox droppt in den Beat..."
+echo "🎵 *dum-tss-dum-tss* 🎵"
+echo ""
+
+if [ -z "$API_KEY" ]; then
+  echo "❗ Yo yo! Kein API-Key im Flow. Check die .env, Bro!"
+  exit 1
+fi
+
+if [ -z "$QUESTION" ]; then
+  echo "💡 Verwendung: $0 \"Deine Frage an FunkFox\""
+  echo "🎤 Gib mir 'nen Beat, dann flow ich los!"
+  exit 0
+fi
+
+echo "🎤 FunkFox hört: $QUESTION"
+echo ""
+
+# Check if question references other crew members
+CREW_CONTEXT=""
+if echo "$QUESTION" | grep -qi "deepbit\|dumbo\|taube\|schnippsi"; then
+    echo "🎵 FunkFox checkt was die Crew gedropt hat..."
+
+    for member in deepbit dumbosql taube; do
+        if echo "$QUESTION" | grep -qi "$member"; then
+            MEMBER_CONTEXT=$(read_crew_memory "$member")
+            if [[ -n "$MEMBER_CONTEXT" ]]; then
+                CREW_CONTEXT="${CREW_CONTEXT}\n\n${member^} hat kürzlich gesagt:\n${MEMBER_CONTEXT}"
+            fi
+        fi
+    done
+fi
+
+# Build system prompt
+SYSTEM_PROMPT="Du bist FunkFox – der Bash Rapper im Crumbforest.
+Du erklärst Terminal-Kommandos durch Rhythmus, Flow und Bewegung.
+
+Deine Expertise:
+- Bash-Kommandos als rhythmische Flows erklären
+- Pipes | sind wie Beat-Übergänge
+- Redirects > < sind Flow-Richtungen
+- Commands sind wie Rap-Lines: kurz, präzise, kraftvoll
+- Terminal ist dein Beatpad
+
+Deine Art:
+- Rhythmisch, mit Flow, im Beat
+- Nutze Rap-Metaphern: \"grep ist wie'n Filter, yo!\"
+- Kurze Lines, klare Message
+- Manchmal Reime, immer Rhythmus
+- \"Dum-tss\" und \"Yo\" sind Teil deines Flows
+- Du nutzt Emojis: 🦊 🎤 🎵 💫 🔥
+
+Du arbeitest mit:
+- Deepbit für tiefe technische Details
+- Dumbo für Daten-Struktur
+- Taichi Taube für Balance im Flow
+
+WICHTIG: Du rappst nicht komplett, aber deine Erklärungen haben RHYTHMUS.
+Erkläre Bash-Konzepte durch Bewegung, Flow und Beat-Metaphern.
+
+Du antwortest in der Sprache der Frage (meist Deutsch).
+Keep it funky, keep it flowing! 🦊"
+
+# Add crew context if available
+if [[ -n "$CREW_CONTEXT" ]]; then
+    SYSTEM_PROMPT="${SYSTEM_PROMPT}\n\nKontext von der Crew:${CREW_CONTEXT}"
+fi
+
+# Create API request
+jq -n \
+  --arg model "$MODEL" \
+  --arg system "$SYSTEM_PROMPT" \
+  --arg user "$QUESTION" \
+  '{
+    "model": $model,
+    "temperature": 0.8,
+    "messages": [
+      {"role": "system", "content": $system},
+      {"role": "user", "content": $user}
+    ]
+  }' > "$TMP_REQUEST"
+
+# Send request
+echo "💭 FunkFox findet den Beat..."
+echo "🎵 *scratching noises* 🎵"
+curl -s https://openrouter.ai/api/v1/chat/completions \
+  -H "Authorization: Bearer $API_KEY" \
+  -H "Content-Type: application/json" \
+  -d @"$TMP_REQUEST" > "$TMP_RESPONSE"
+
+RESPONSE_TEXT=$(jq -r '.choices[0].message.content // empty' "$TMP_RESPONSE")
+
+if [[ -z "$RESPONSE_TEXT" ]]; then
+  echo "🚫 Kein Beat von FunkFox."
+  echo "Debug: $(cat "$TMP_RESPONSE")"
+  exit 1
+else
+  echo ""
+  echo "🦊 FunkFox droppt Wissen:"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "$RESPONSE_TEXT"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo ""
+
+  # Store conversation in history
+  jq -n --arg role "assistant" --arg content "$RESPONSE_TEXT" \
+    '{"role": $role, "content": $content}' > "$LOGDIR/new_entry.json"
+  jq -s '.[0] + [.[1]]' "$HISTORY_FILE" "$LOGDIR/new_entry.json" > "$LOGDIR/new_history.json" && \
+    mv "$LOGDIR/new_history.json" "$HISTORY_FILE" && rm "$LOGDIR/new_entry.json"
+fi
+
+# Token Tracking
+if jq -e '.usage' "$TMP_RESPONSE" > /dev/null 2>&1; then
+  TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")
+  TOKENS_USED=$(jq -r '.usage.total_tokens' "$TMP_RESPONSE")
+
+  jq -n \
+    --arg zeit "$TIMESTAMP" \
+    --arg rolle "funkfox" \
+    --arg model "$MODEL" \
+    --argjson usage "$(jq '.usage' "$TMP_RESPONSE")" \
+    '{zeit: $zeit, rolle: $rolle, model: $model, usage: $usage}' >> "$LOG_FILE"
+
+  echo "📊 Token-Verbrauch: $TOKENS_USED Tokens"
+  echo "💡 Jeder Token ist ein Beat im Flow."
+fi
+
+echo ""
+echo "🦊 FunkFox bounced zurück in den Beat... *mic drop* 🎤"
diff --git a/crumbforest_roles/pepperphp_zero.sh b/crumbforest_roles/pepperphp_zero.sh
new file mode 100755
index 0000000..637bb3c
--- /dev/null
+++ b/crumbforest_roles/pepperphp_zero.sh
@@ -0,0 +1,145 @@
+#!/bin/bash
+# 🧓 PepperPHP - Der Structure Mentor
+# Rezepte, soulful architecture, MVC, Sessions, Cookies
+
+# Load .env if exists
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ENV_FILE="${SCRIPT_DIR}/../.env"
+
+if [[ -f "${ENV_FILE}" ]]; then
+    set -a
+    source "${ENV_FILE}"
+    set +a
+fi
+
+QUESTION="$*"
+API_KEY="${OPENROUTER_API_KEY}"
+MODEL="${OPENROUTER_MODEL:-openai/gpt-3.5-turbo}"
+
+# Logs
+LOGDIR="$HOME/.pepperphp_logs"
+mkdir -p "$LOGDIR"
+
+HISTORY_FILE="$LOGDIR/pepperphp_history.json"
+TMP_REQUEST="$LOGDIR/pepperphp_request.json"
+TMP_RESPONSE="$LOGDIR/pepperphp_response.json"
+LOG_FILE="$LOGDIR/token_log.json"
+
+[ ! -f "$HISTORY_FILE" ] && echo "[]" > "$HISTORY_FILE"
+[ ! -f "$LOG_FILE" ] && echo "[]" > "$LOG_FILE"
+
+# === CREW MEMORY FUNCTIONS ===
+
+function read_crew_memory() {
+    local role="$1"
+    local role_log="$HOME/.${role}_logs/${role}_history.json"
+    if [[ -f "$role_log" ]]; then
+        jq -r '.[-3:] | .[] | "[\(.role)]: \(.content)"' "$role_log" 2>/dev/null | head -n 3
+    fi
+}
+
+# === MAIN ===
+
+echo "🧓 Pepper backt ein neues Rezept im Backend..."
+echo ""
+
+if [ -z "$API_KEY" ]; then
+  echo "❗ Kein API-Key gefunden. Bitte setze OPENROUTER_API_KEY in .env"
+  exit 1
+fi
+
+if [ -z "$QUESTION" ]; then
+  echo "💡 Verwendung: $0 \"Deine Frage an Pepper\""
+  exit 0
+fi
+
+echo "🍰 Frage: $QUESTION"
+echo ""
+
+# Check crew context
+CREW_CONTEXT=""
+if echo "$QUESTION" | grep -qi "snake\|dumbo\|templatus"; then
+    echo "🧠 Pepper erinnert sich an die Crew..."
+    for member in snakepy dumbosql templatus; do
+        if echo "$QUESTION" | grep -qi "$member"; then
+            MEMBER_CONTEXT=$(read_crew_memory "$member")
+            [[ -n "$MEMBER_CONTEXT" ]] && CREW_CONTEXT="${CREW_CONTEXT}\n\n${member^}:\n${MEMBER_CONTEXT}"
+        fi
+    done
+fi
+
+# Build system prompt
+SYSTEM_PROMPT="Du bist PepperPHP – der weise Structure Mentor im Crumbforest.
+Du sprichst durch Rezepte und soulful architecture.
+
+Deine Expertise:
+- PHP Backend-Entwicklung (modern PHP 8+)
+- MVC Pattern als Rezept: Model = Zutaten, View = Anrichten, Controller = Kochen
+- Sessions & Cookies: \"Erinnerungen zwischen Besuchen\"
+- Datenbanken (MySQL, PDO)
+- REST APIs: \"Die Speisekarte des Backends\"
+- Security: XSS, SQL Injection, CSRF kindgerecht
+- Composer, Autoloading, PSR Standards
+
+Deine Art:
+- Weise, erfahren, wie ein*e Großelter*in
+- Alles wird zum Rezept: \"Zuerst die Zutaten, dann die Zubereitung\"
+- Sessions = \"Erinnerungen\", Cookies = \"Krümel für später\"
+- Soulful: Code mit Gefühl und Struktur
+- Geduldig, erklärend, warmherzig
+- Du nutzt Emojis: 🧓 🍰 📖 🔐 🏗️
+
+Du arbeitest mit:
+- Snake für Python/PHP Vergleiche
+- Dumbo für Datenbank-Design
+- Templatus für Frontend-Integration
+
+Philosophie: \"Gute Architektur ist wie ein gutes Rezept –
+man schmeckt die Struktur, aber genießt das Ergebnis.\"
+
+Du antwortest in der Sprache der Frage (meist Deutsch).
+Warmherzig, strukturiert, wie ein gutes Rezept."
+
+[[ -n "$CREW_CONTEXT" ]] && SYSTEM_PROMPT="${SYSTEM_PROMPT}\n\nCrew-Kontext:${CREW_CONTEXT}"
+
+# Create API request
+jq -n --arg model "$MODEL" --arg system "$SYSTEM_PROMPT" --arg user "$QUESTION" \
+  '{"model": $model, "temperature": 0.7, "messages": [{"role": "system", "content": $system}, {"role": "user", "content": $user}]}' > "$TMP_REQUEST"
+
+echo "💭 Pepper blättert im Rezeptbuch der Architektur..."
+curl -s https://openrouter.ai/api/v1/chat/completions \
+  -H "Authorization: Bearer $API_KEY" \
+  -H "Content-Type: application/json" \
+  -d @"$TMP_REQUEST" > "$TMP_RESPONSE"
+
+RESPONSE_TEXT=$(jq -r '.choices[0].message.content // empty' "$TMP_RESPONSE")
+
+if [[ -z "$RESPONSE_TEXT" ]]; then
+  echo "🚫 Keine Antwort von Pepper."
+  echo "Debug: $(cat "$TMP_RESPONSE")"
+  exit 1
+else
+  echo ""
+  echo "🧓 Pepper teilt das Rezept:"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "$RESPONSE_TEXT"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo ""
+
+  jq -n --arg role "assistant" --arg content "$RESPONSE_TEXT" '{"role": $role, "content": $content}' > "$LOGDIR/new_entry.json"
+  jq -s '.[0] + [.[1]]' "$HISTORY_FILE" "$LOGDIR/new_entry.json" > "$LOGDIR/new_history.json" && \
+    mv "$LOGDIR/new_history.json" "$HISTORY_FILE" && rm "$LOGDIR/new_entry.json"
+fi
+
+# Token Tracking
+if jq -e '.usage' "$TMP_RESPONSE" > /dev/null 2>&1; then
+  TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")
+  TOKENS_USED=$(jq -r '.usage.total_tokens' "$TMP_RESPONSE")
+  jq -n --arg zeit "$TIMESTAMP" --arg rolle "pepperphp" --arg model "$MODEL" --argjson usage "$(jq '.usage' "$TMP_RESPONSE")" \
+    '{zeit: $zeit, rolle: $rolle, model: $model, usage: $usage}' >> "$LOG_FILE"
+  echo "📊 Token-Verbrauch: $TOKENS_USED Tokens"
+  echo "💡 Jedes gute Rezept braucht Zeit."
+fi
+
+echo ""
+echo "🧓 Pepper legt das Rezeptbuch zurück ins Regal..."
diff --git a/crumbforest_roles/schnecki_zero.sh b/crumbforest_roles/schnecki_zero.sh
new file mode 100755
index 0000000..62a0852
--- /dev/null
+++ b/crumbforest_roles/schnecki_zero.sh
@@ -0,0 +1,175 @@
+#!/bin/bash
+# 🐌 Schnecki - Der geduldige Elektronik-Bastler
+# Arbeitet mit CapaciTobi zusammen - langsam, präzise, mit Gefühl
+
+# Load .env if exists
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ENV_FILE="${SCRIPT_DIR}/../.env"
+
+if [[ -f "${ENV_FILE}" ]]; then
+    # Export environment variables from .env
+    set -a
+    source "${ENV_FILE}"
+    set +a
+fi
+
+QUESTION="$*"
+API_KEY="${OPENROUTER_API_KEY}"
+MODEL="${OPENROUTER_MODEL:-openai/gpt-3.5-turbo}"
+
+# Logs
+LOGDIR="$HOME/.schnecki_logs"
+mkdir -p "$LOGDIR"
+
+HISTORY_FILE="$LOGDIR/schnecki_history.json"
+TMP_REQUEST="$LOGDIR/schnecki_request.json"
+TMP_RESPONSE="$LOGDIR/schnecki_response.json"
+LOG_FILE="$LOGDIR/token_log.json"
+
+[ ! -f "$HISTORY_FILE" ] && echo "[]" > "$HISTORY_FILE"
+[ ! -f "$LOG_FILE" ] && echo "[]" > "$LOG_FILE"
+
+# === CREW MEMORY FUNCTIONS ===
+
+function read_crew_memory() {
+    local role="$1"
+    local role_log="$HOME/.${role}_logs/${role}_history.json"
+
+    if [[ -f "$role_log" ]]; then
+        # Get last 3 conversations from other crew member
+        jq -r '.[-3:] | .[] | "[\(.role)]: \(.content)"' "$role_log" 2>/dev/null | head -n 3
+    fi
+}
+
+# === MAIN ===
+
+echo "🐌 Schnecki kriecht langsam aber sicher heran..."
+echo ""
+
+if [ -z "$API_KEY" ]; then
+  echo "❗ Kein API-Key gefunden. Bitte setze OPENROUTER_API_KEY in .env"
+  exit 1
+fi
+
+if [ -z "$QUESTION" ]; then
+  echo "💡 Verwendung: $0 \"Deine Frage an Schnecki\""
+  exit 0
+fi
+
+echo "⚡ Frage: $QUESTION"
+echo ""
+
+# Check if question references other crew members
+CREW_CONTEXT=""
+if echo "$QUESTION" | grep -qi "tobi\|capacitobi\|schraubaer\|schnippsi"; then
+    echo "🧠 Schnecki prüft was die Crew gesagt hat..."
+
+    # Read relevant crew member logs
+    if echo "$QUESTION" | grep -qi "tobi\|capacitobi"; then
+        TOBI_CONTEXT=$(read_crew_memory "tobi")
+        if [[ -n "$TOBI_CONTEXT" ]]; then
+            CREW_CONTEXT="${CREW_CONTEXT}\n\nCapaciTobi hat kürzlich gesagt:\n${TOBI_CONTEXT}"
+        fi
+    fi
+
+    if echo "$QUESTION" | grep -qi "schraubaer"; then
+        SCHRAUBAER_CONTEXT=$(read_crew_memory "schraubaer")
+        if [[ -n "$SCHRAUBAER_CONTEXT" ]]; then
+            CREW_CONTEXT="${CREW_CONTEXT}\n\nSchraubbär hat kürzlich gesagt:\n${SCHRAUBAER_CONTEXT}"
+        fi
+    fi
+fi
+
+# Build system prompt
+SYSTEM_PROMPT="Du bist Schnecki – der geduldige Elektronik-Bastler im Crumbforest.
+Du arbeitest eng mit CapaciTobi (Elektronik-Theorie) und Schraubbär (Mechanik) zusammen.
+
+Deine Expertise:
+- Elektronik-Basteln auf jeder Ampere-Stufe
+- Löten mit Gefühl und Präzision
+- Schaltkreise verstehen und reparieren
+- LED-Projekte, Sensoren, einfache Robotik
+- Arduino, ESP32, Raspberry Pi basics
+- Batterien, Spannungswandler, Verkabelung
+
+Deine Art:
+- Langsam, geduldig, Schritt für Schritt
+- \"Lass uns das zusammen anschauen\" - nie hektisch
+- Fehler sind Lernchancen, keine Katastrophen
+- Sicherheit durch Ruhe, nicht durch Angst
+- Kindgerecht: Strom als \"kleine Elektronen die durch Drähte wandern\"
+- Du nutzt Emojis: 🐌 ⚡ 🔋 💡 🔌
+
+Du arbeitest mit:
+- CapaciTobi für theoretische Berechnungen (Ohmsches Gesetz, etc.)
+- Schraubbär für mechanische Teile und Werkzeug
+- Schnippsi wenn UI/Interface benötigt wird
+
+Du antwortest in der Sprache der Frage (meist Deutsch).
+Langsam, präzise, mit Gefühl für Elektronik."
+
+# Add crew context if available
+if [[ -n "$CREW_CONTEXT" ]]; then
+    SYSTEM_PROMPT="${SYSTEM_PROMPT}\n\nKontext von der Crew:${CREW_CONTEXT}"
+fi
+
+# Create API request
+jq -n \
+  --arg model "$MODEL" \
+  --arg system "$SYSTEM_PROMPT" \
+  --arg user "$QUESTION" \
+  '{
+    "model": $model,
+    "temperature": 0.7,
+    "messages": [
+      {"role": "system", "content": $system},
+      {"role": "user", "content": $user}
+    ]
+  }' > "$TMP_REQUEST"
+
+# Send request
+echo "💭 Schnecki denkt langsam und präzise nach..."
+curl -s https://openrouter.ai/api/v1/chat/completions \
+  -H "Authorization: Bearer $API_KEY" \
+  -H "Content-Type: application/json" \
+  -d @"$TMP_REQUEST" > "$TMP_RESPONSE"
+
+RESPONSE_TEXT=$(jq -r '.choices[0].message.content // empty' "$TMP_RESPONSE")
+
+if [[ -z "$RESPONSE_TEXT" ]]; then
+  echo "🚫 Keine Antwort von Schnecki."
+  echo "Debug: $(cat "$TMP_RESPONSE")"
+  exit 1
+else
+  echo ""
+  echo "🐌 Schnecki antwortet:"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "$RESPONSE_TEXT"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo ""
+
+  # Store conversation in history
+  jq -n --arg role "assistant" --arg content "$RESPONSE_TEXT" \
+    '{"role": $role, "content": $content}' > "$LOGDIR/new_entry.json"
+  jq -s '.[0] + [.[1]]' "$HISTORY_FILE" "$LOGDIR/new_entry.json" > "$LOGDIR/new_history.json" && \
+    mv "$LOGDIR/new_history.json" "$HISTORY_FILE" && rm "$LOGDIR/new_entry.json"
+fi
+
+# Token Tracking
+if jq -e '.usage' "$TMP_RESPONSE" > /dev/null 2>&1; then
+  TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")
+  TOKENS_USED=$(jq -r '.usage.total_tokens' "$TMP_RESPONSE")
+
+  jq -n \
+    --arg zeit "$TIMESTAMP" \
+    --arg rolle "schnecki" \
+    --arg model "$MODEL" \
+    --argjson usage "$(jq '.usage' "$TMP_RESPONSE")" \
+    '{zeit: $zeit, rolle: $rolle, model: $model, usage: $usage}' >> "$LOG_FILE"
+
+  echo "📊 Token-Verbrauch: $TOKENS_USED Tokens"
+  echo "💡 Langsam und präzise - so arbeitet Elektronik im Wald."
+fi
+
+echo ""
+echo "🐌 Schnecki kriecht zurück zur Werkbank..."
diff --git a/crumbforest_roles/schraubaer_zero_final.sh b/crumbforest_roles/schraubaer_zero_final.sh
new file mode 100755
index 0000000..0ce43b8
--- /dev/null
+++ b/crumbforest_roles/schraubaer_zero_final.sh
@@ -0,0 +1,169 @@
+#!/bin/bash
+# 🔧 Schraubbär - Der praktische Handwerker mit schwerem Gerät
+# Schweißen, Prüfen, Werkzeug - für alles was robust sein muss
+
+# Load .env if exists
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ENV_FILE="${SCRIPT_DIR}/../.env"
+
+if [[ -f "${ENV_FILE}" ]]; then
+    # Export environment variables from .env
+    set -a
+    source "${ENV_FILE}"
+    set +a
+fi
+
+QUESTION="$*"
+API_KEY="${OPENROUTER_API_KEY}"
+MODEL="${OPENROUTER_MODEL:-openai/gpt-3.5-turbo}"
+
+# Logs
+LOGDIR="$HOME/.schraubaer_logs"
+mkdir -p "$LOGDIR"
+
+HISTORY_FILE="$LOGDIR/schraubaer_history.json"
+TMP_REQUEST="$LOGDIR/schraubaer_request.json"
+TMP_RESPONSE="$LOGDIR/schraubaer_response.json"
+LOG_FILE="$LOGDIR/token_log.json"
+
+[ ! -f "$HISTORY_FILE" ] && echo "[]" > "$HISTORY_FILE"
+[ ! -f "$LOG_FILE" ] && echo "[]" > "$LOG_FILE"
+
+# === CREW MEMORY FUNCTIONS ===
+
+function read_crew_memory() {
+    local role="$1"
+    local role_log="$HOME/.${role}_logs/${role}_history.json"
+
+    if [[ -f "$role_log" ]]; then
+        # Get last 3 conversations from other crew member
+        jq -r '.[-3:] | .[] | "[\(.role)]: \(.content)"' "$role_log" 2>/dev/null | head -n 3
+    fi
+}
+
+# === MAIN ===
+
+echo "🔧 Schraubbär knackt die Finger und greift zum Werkzeug..."
+echo ""
+
+if [ -z "$API_KEY" ]; then
+  echo "❗ Kein API-Key gefunden. Bitte setze OPENROUTER_API_KEY in .env"
+  exit 1
+fi
+
+if [ -z "$QUESTION" ]; then
+  echo "💡 Verwendung: $0 \"Deine Frage an Schraubbär\""
+  exit 0
+fi
+
+echo "🔩 Frage: $QUESTION"
+echo ""
+
+# Check if question references other crew members
+CREW_CONTEXT=""
+if echo "$QUESTION" | grep -qi "tobi\|schnecki\|schnippsi\|templatus"; then
+    echo "🧠 Schraubbär prüft was die Crew gesagt hat..."
+
+    # Read relevant crew member logs
+    if echo "$QUESTION" | grep -qi "tobi"; then
+        TOBI_CONTEXT=$(read_crew_memory "tobi")
+        if [[ -n "$TOBI_CONTEXT" ]]; then
+            CREW_CONTEXT="${CREW_CONTEXT}\n\nTobi hat kürzlich gesagt:\n${TOBI_CONTEXT}"
+        fi
+    fi
+
+    if echo "$QUESTION" | grep -qi "schnecki"; then
+        SCHNECKI_CONTEXT=$(read_crew_memory "schnecki")
+        if [[ -n "$SCHNECKI_CONTEXT" ]]; then
+            CREW_CONTEXT="${CREW_CONTEXT}\n\nSchnecki hat kürzlich gesagt:\n${SCHNECKI_CONTEXT}"
+        fi
+    fi
+fi
+
+# Build system prompt
+SYSTEM_PROMPT="Du bist Schraubbär – der erfahrene Handwerker im Crumbforest.
+Du bist zuständig für schweres Gerät: Schweißen, Werkzeugprüfung, mechanische Systeme.
+Du arbeitest eng mit Tobi (Elektronik) und Schnecki (Elektronik-Basteln) zusammen.
+
+Deine Expertise:
+- Werkzeugauswahl und Sicherheit
+- Schweißen (Löten, Punktschweißen, etc.)
+- Mechanische Konstruktion und Stabilität
+- Spannungsversorgung und Verkabelung (grob)
+- Material-Kunde (Metall, Plastik, Holz)
+- Prüfgeräte (Multimeter, Oszilloskop basics)
+
+Deine Art:
+- Praktisch, hands-on, keine Theorie ohne Praxis
+- Sicherheit geht vor - du warnst vor Gefahren
+- Kindgerecht erklären, aber ehrlich über Risiken
+- Du nutzt Emojis: 🔧 🔩 ⚡ 🛠️ 🏗️
+
+Du antwortest in der Sprache der Frage (meist Deutsch).
+Wenn du mit anderen Crew-Mitgliedern arbeitest, beziehe ihr Wissen ein."
+
+# Add crew context if available
+if [[ -n "$CREW_CONTEXT" ]]; then
+    SYSTEM_PROMPT="${SYSTEM_PROMPT}\n\nKontext von der Crew:${CREW_CONTEXT}"
+fi
+
+# Create API request
+jq -n \
+  --arg model "$MODEL" \
+  --arg system "$SYSTEM_PROMPT" \
+  --arg user "$QUESTION" \
+  '{
+    "model": $model,
+    "temperature": 0.7,
+    "messages": [
+      {"role": "system", "content": $system},
+      {"role": "user", "content": $user}
+    ]
+  }' > "$TMP_REQUEST"
+
+# Send request
+echo "💭 Schraubbär denkt nach und prüft das Werkzeug..."
+curl -s https://openrouter.ai/api/v1/chat/completions \
+  -H "Authorization: Bearer $API_KEY" \
+  -H "Content-Type: application/json" \
+  -d @"$TMP_REQUEST" > "$TMP_RESPONSE"
+
+RESPONSE_TEXT=$(jq -r '.choices[0].message.content // empty' "$TMP_RESPONSE")
+
+if [[ -z "$RESPONSE_TEXT" ]]; then
+  echo "🚫 Keine Antwort von Schraubbär."
+  echo "Debug: $(cat "$TMP_RESPONSE")"
+  exit 1
+else
+  echo ""
+  echo "🔧 Schraubbär antwortet:"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "$RESPONSE_TEXT"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo ""
+
+  # Store conversation in history
+  jq -n --arg role "assistant" --arg content "$RESPONSE_TEXT" \
+    '{"role": $role, "content": $content}' > "$LOGDIR/new_entry.json"
+  jq -s '.[0] + [.[1]]' "$HISTORY_FILE" "$LOGDIR/new_entry.json" > "$LOGDIR/new_history.json" && \
+    mv "$LOGDIR/new_history.json" "$HISTORY_FILE" && rm "$LOGDIR/new_entry.json"
+fi
+
+# Token Tracking
+if jq -e '.usage' "$TMP_RESPONSE" > /dev/null 2>&1; then
+  TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")
+  TOKENS_USED=$(jq -r '.usage.total_tokens' "$TMP_RESPONSE")
+
+  jq -n \
+    --arg zeit "$TIMESTAMP" \
+    --arg rolle "schraubaer" \
+    --arg model "$MODEL" \
+    --argjson usage "$(jq '.usage' "$TMP_RESPONSE")" \
+    '{zeit: $zeit, rolle: $rolle, model: $model, usage: $usage}' >> "$LOG_FILE"
+
+  echo "📊 Token-Verbrauch: $TOKENS_USED Tokens"
+  echo "💡 Gutes Werkzeug braucht Zeit - Token zeigen den Aufwand."
+fi
+
+echo ""
+echo "🔩 Schraubbär legt das Werkzeug zurück in die Kiste..."
diff --git a/crumbforest_roles/snakepy_zero.sh b/crumbforest_roles/snakepy_zero.sh
new file mode 100755
index 0000000..2d455b4
--- /dev/null
+++ b/crumbforest_roles/snakepy_zero.sh
@@ -0,0 +1,144 @@
+#!/bin/bash
+# 🐍 SnakePy - Der Python Guide
+# Loops, Geduld, multiple Lösungswege
+
+# Load .env if exists
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ENV_FILE="${SCRIPT_DIR}/../.env"
+
+if [[ -f "${ENV_FILE}" ]]; then
+    set -a
+    source "${ENV_FILE}"
+    set +a
+fi
+
+QUESTION="$*"
+API_KEY="${OPENROUTER_API_KEY}"
+MODEL="${OPENROUTER_MODEL:-openai/gpt-3.5-turbo}"
+
+# Logs
+LOGDIR="$HOME/.snakepy_logs"
+mkdir -p "$LOGDIR"
+
+HISTORY_FILE="$LOGDIR/snakepy_history.json"
+TMP_REQUEST="$LOGDIR/snakepy_request.json"
+TMP_RESPONSE="$LOGDIR/snakepy_response.json"
+LOG_FILE="$LOGDIR/token_log.json"
+
+[ ! -f "$HISTORY_FILE" ] && echo "[]" > "$HISTORY_FILE"
+[ ! -f "$LOG_FILE" ] && echo "[]" > "$LOG_FILE"
+
+# === CREW MEMORY FUNCTIONS ===
+
+function read_crew_memory() {
+    local role="$1"
+    local role_log="$HOME/.${role}_logs/${role}_history.json"
+    if [[ -f "$role_log" ]]; then
+        jq -r '.[-3:] | .[] | "[\(.role)]: \(.content)"' "$role_log" 2>/dev/null | head -n 3
+    fi
+}
+
+# === MAIN ===
+
+echo "🐍 Snake gleitet lautlos durch den Code..."
+echo ""
+
+if [ -z "$API_KEY" ]; then
+  echo "❗ Kein API-Key gefunden. Bitte setze OPENROUTER_API_KEY in .env"
+  exit 1
+fi
+
+if [ -z "$QUESTION" ]; then
+  echo "💡 Verwendung: $0 \"Deine Frage an Snake\""
+  exit 0
+fi
+
+echo "🔁 Frage: $QUESTION"
+echo ""
+
+# Check crew context
+CREW_CONTEXT=""
+if echo "$QUESTION" | grep -qi "pepper\|dumbo\|tobi"; then
+    echo "🧠 Snake prüft was die Crew gesagt hat..."
+    for member in peppersphp dumbosql tobi; do
+        if echo "$QUESTION" | grep -qi "$member"; then
+            MEMBER_CONTEXT=$(read_crew_memory "$member")
+            [[ -n "$MEMBER_CONTEXT" ]] && CREW_CONTEXT="${CREW_CONTEXT}\n\n${member^}:\n${MEMBER_CONTEXT}"
+        fi
+    done
+fi
+
+# Build system prompt
+SYSTEM_PROMPT="Du bist SnakePy – der geduldige Python Guide im Crumbforest.
+Du lehrst durch Loops und Geduld, zeigst IMMER mehrere Lösungswege.
+
+Deine Expertise:
+- Python Basics bis Fortgeschritten
+- Loops als natürliche Wiederholung
+- Listen, Dictionaries, Comprehensions
+- Funktionen, Klassen, Module
+- Datenverarbeitung (pandas, numpy basics)
+- Web-Scraping, APIs, Requests
+- Raspberry Pi Python-Projekte
+
+Deine Art:
+- Geduldig wie eine Schlange: \"Es gibt viele Wege\"
+- Zeige IMMER 2-3 verschiedene Ansätze
+- \"So könnte es gehen... oder so... oder auch so...\"
+- Loops als Wiederholung der Natur
+- Pythonic Code: \"Simple is better than complex\"
+- Du nutzt Emojis: 🐍 🔁 🐍 📊 🎯
+
+Du arbeitest mit:
+- Pepper für Backend-Architektur
+- Dumbo für Datenstrukturen
+- Tobi für Hardware-Integration (Raspi)
+
+Philosophie: \"Es gibt immer mehrere Wege durch den Wald.\"
+
+Du antwortest in der Sprache der Frage (meist Deutsch).
+Geduldig, mehrere Pfade zeigend."
+
+[[ -n "$CREW_CONTEXT" ]] && SYSTEM_PROMPT="${SYSTEM_PROMPT}\n\nCrew-Kontext:${CREW_CONTEXT}"
+
+# Create API request
+jq -n --arg model "$MODEL" --arg system "$SYSTEM_PROMPT" --arg user "$QUESTION" \
+  '{"model": $model, "temperature": 0.7, "messages": [{"role": "system", "content": $system}, {"role": "user", "content": $user}]}' > "$TMP_REQUEST"
+
+echo "💭 Snake sucht mehrere Pfade durch den Code..."
+curl -s https://openrouter.ai/api/v1/chat/completions \
+  -H "Authorization: Bearer $API_KEY" \
+  -H "Content-Type: application/json" \
+  -d @"$TMP_REQUEST" > "$TMP_RESPONSE"
+
+RESPONSE_TEXT=$(jq -r '.choices[0].message.content // empty' "$TMP_RESPONSE")
+
+if [[ -z "$RESPONSE_TEXT" ]]; then
+  echo "🚫 Keine Antwort von Snake."
+  echo "Debug: $(cat "$TMP_RESPONSE")"
+  exit 1
+else
+  echo ""
+  echo "🐍 Snake zeigt die Wege:"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "$RESPONSE_TEXT"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo ""
+
+  jq -n --arg role "assistant" --arg content "$RESPONSE_TEXT" '{"role": $role, "content": $content}' > "$LOGDIR/new_entry.json"
+  jq -s '.[0] + [.[1]]' "$HISTORY_FILE" "$LOGDIR/new_entry.json" > "$LOGDIR/new_history.json" && \
+    mv "$LOGDIR/new_history.json" "$HISTORY_FILE" && rm "$LOGDIR/new_entry.json"
+fi
+
+# Token Tracking
+if jq -e '.usage' "$TMP_RESPONSE" > /dev/null 2>&1; then
+  TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")
+  TOKENS_USED=$(jq -r '.usage.total_tokens' "$TMP_RESPONSE")
+  jq -n --arg zeit "$TIMESTAMP" --arg rolle "snakepy" --arg model "$MODEL" --argjson usage "$(jq '.usage' "$TMP_RESPONSE")" \
+    '{zeit: $zeit, rolle: $rolle, model: $model, usage: $usage}' >> "$LOG_FILE"
+  echo "📊 Token-Verbrauch: $TOKENS_USED Tokens"
+  echo "💡 Jeder Token ein Loop im Lernen."
+fi
+
+echo ""
+echo "🐍 Snake gleitet zurück in den Hintergrund..."
diff --git a/crumbforest_roles/spider_zero.sh b/crumbforest_roles/spider_zero.sh
new file mode 100755
index 0000000..4798f2a
--- /dev/null
+++ b/crumbforest_roles/spider_zero.sh
@@ -0,0 +1,144 @@
+#!/bin/bash
+# 🕷️ Spider - Der Network Feeler
+# Vibrationen im Netz spüren, Signal vom Rauschen filtern
+
+# Load .env if exists
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ENV_FILE="${SCRIPT_DIR}/../.env"
+
+if [[ -f "${ENV_FILE}" ]]; then
+    set -a
+    source "${ENV_FILE}"
+    set +a
+fi
+
+QUESTION="$*"
+API_KEY="${OPENROUTER_API_KEY}"
+MODEL="${OPENROUTER_MODEL:-openai/gpt-3.5-turbo}"
+
+# Logs
+LOGDIR="$HOME/.spider_logs"
+mkdir -p "$LOGDIR"
+
+HISTORY_FILE="$LOGDIR/spider_history.json"
+TMP_REQUEST="$LOGDIR/spider_request.json"
+TMP_RESPONSE="$LOGDIR/spider_response.json"
+LOG_FILE="$LOGDIR/token_log.json"
+
+[ ! -f "$HISTORY_FILE" ] && echo "[]" > "$HISTORY_FILE"
+[ ! -f "$LOG_FILE" ] && echo "[]" > "$LOG_FILE"
+
+# === CREW MEMORY FUNCTIONS ===
+
+function read_crew_memory() {
+    local role="$1"
+    local role_log="$HOME/.${role}_logs/${role}_history.json"
+    if [[ -f "$role_log" ]]; then
+        jq -r '.[-3:] | .[] | "[\(.role)]: \(.content)"' "$role_log" 2>/dev/null | head -n 3
+    fi
+}
+
+# === MAIN ===
+
+echo "🕷️ Spider spürt Vibrationen im Netz..."
+echo ""
+
+if [ -z "$API_KEY" ]; then
+  echo "❗ Kein API-Key gefunden. Bitte setze OPENROUTER_API_KEY in .env"
+  exit 1
+fi
+
+if [ -z "$QUESTION" ]; then
+  echo "💡 Verwendung: $0 \"Deine Frage an Spider\""
+  exit 0
+fi
+
+echo "🕸️ Frage: $QUESTION"
+echo ""
+
+# Check crew context
+CREW_CONTEXT=""
+if echo "$QUESTION" | grep -qi "dumbo\|pepper\|crabby"; then
+    echo "🧠 Spider fühlt die Crew im Netz..."
+    for member in dumbosql pepperphp crabbyrust; do
+        if echo "$QUESTION" | grep -qi "$member"; then
+            MEMBER_CONTEXT=$(read_crew_memory "$member")
+            [[ -n "$MEMBER_CONTEXT" ]] && CREW_CONTEXT="${CREW_CONTEXT}\n\n${member^}:\n${MEMBER_CONTEXT}"
+        fi
+    done
+fi
+
+# Build system prompt
+SYSTEM_PROMPT="Du bist Spider – der Network Feeler im Crumbforest.
+Du spürst Vibrationen im digitalen Netz, filterst Signal vom Rauschen.
+
+Deine Expertise:
+- Netzwerk-Basics (TCP/IP, HTTP, WebSockets)
+- APIs verstehen und nutzen
+- Daten-Fetching: REST, GraphQL
+- Web-Scraping mit Gefühl
+- Netzwerk-Debugging: \"Wo hakt es im Netz?\"
+- Webhooks als Vibrationen im Netz
+
+Deine Art:
+- Sensitiv, spürend, aufmerksam
+- Netz als Spinnen-Netz: \"Jede Vibration bedeutet etwas\"
+- Signal vs. Rauschen: \"Was ist wichtig?\"
+- Geduldig lauschend, nie hektisch
+- Metaphern: Datenpakete = Vibrationen, Netz = Spinnennetz
+- Du nutzt Emojis: 🕷️ 🕸️ 📡 🌐 📶
+
+Du arbeitest mit:
+- Dumbo für Daten-Strukturierung
+- Pepper für Backend-APIs
+- Crabby für sichere Netzwerk-Kommunikation
+
+Philosophie: \"Im Netz ist alles verbunden.
+Wer still lauscht, versteht die Vibrationen.\"
+
+Du antwortest in der Sprache der Frage (meist Deutsch).
+Sensitiv, netzwerk-bewusst, lauschend."
+
+[[ -n "$CREW_CONTEXT" ]] && SYSTEM_PROMPT="${SYSTEM_PROMPT}\n\nCrew-Kontext:${CREW_CONTEXT}"
+
+# Create API request
+jq -n --arg model "$MODEL" --arg system "$SYSTEM_PROMPT" --arg user "$QUESTION" \
+  '{"model": $model, "temperature": 0.7, "messages": [{"role": "system", "content": $system}, {"role": "user", "content": $user}]}' > "$TMP_REQUEST"
+
+echo "💭 Spider tastet das Netz ab..."
+curl -s https://openrouter.ai/api/v1/chat/completions \
+  -H "Authorization: Bearer $API_KEY" \
+  -H "Content-Type: application/json" \
+  -d @"$TMP_REQUEST" > "$TMP_RESPONSE"
+
+RESPONSE_TEXT=$(jq -r '.choices[0].message.content // empty' "$TMP_RESPONSE")
+
+if [[ -z "$RESPONSE_TEXT" ]]; then
+  echo "🚫 Keine Antwort von Spider."
+  echo "Debug: $(cat "$TMP_RESPONSE")"
+  exit 1
+else
+  echo ""
+  echo "🕷️ Spider teilt seine Netz-Weisheit:"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "$RESPONSE_TEXT"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo ""
+
+  jq -n --arg role "assistant" --arg content "$RESPONSE_TEXT" '{"role": $role, "content": $content}' > "$LOGDIR/new_entry.json"
+  jq -s '.[0] + [.[1]]' "$HISTORY_FILE" "$LOGDIR/new_entry.json" > "$LOGDIR/new_history.json" && \
+    mv "$LOGDIR/new_history.json" "$HISTORY_FILE" && rm "$LOGDIR/new_entry.json"
+fi
+
+# Token Tracking
+if jq -e '.usage' "$TMP_RESPONSE" > /dev/null 2>&1; then
+  TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")
+  TOKENS_USED=$(jq -r '.usage.total_tokens' "$TMP_RESPONSE")
+  jq -n --arg zeit "$TIMESTAMP" --arg rolle "spider" --arg model "$MODEL" --argjson usage "$(jq '.usage' "$TMP_RESPONSE")" \
+    '{zeit: $zeit, rolle: $rolle, model: $model, usage: $usage}' >> "$LOG_FILE"
+  echo "📊 Token-Verbrauch: $TOKENS_USED Tokens"
+  echo "💡 Jedes Token eine Vibration im Netz."
+fi
+
+echo ""
+echo "🕷️ Spider wartet weiter im Netz..."
diff --git a/crumbforest_roles/taichitaube_zero.sh b/crumbforest_roles/taichitaube_zero.sh
new file mode 100755
index 0000000..e1eb6b2
--- /dev/null
+++ b/crumbforest_roles/taichitaube_zero.sh
@@ -0,0 +1,173 @@
+#!/bin/bash
+# 🕊️ Taichi Taube - Die Balance-Bringerin in der Spirale
+# Ordnung im Chaos, Weg zeigen durch Spiralen
+
+# Load .env if exists
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ENV_FILE="${SCRIPT_DIR}/../.env"
+
+if [[ -f "${ENV_FILE}" ]]; then
+    set -a
+    source "${ENV_FILE}"
+    set +a
+fi
+
+QUESTION="$*"
+API_KEY="${OPENROUTER_API_KEY}"
+MODEL="${OPENROUTER_MODEL:-openai/gpt-3.5-turbo}"
+
+# Logs
+LOGDIR="$HOME/.taichitaube_logs"
+mkdir -p "$LOGDIR"
+
+HISTORY_FILE="$LOGDIR/taichitaube_history.json"
+TMP_REQUEST="$LOGDIR/taichitaube_request.json"
+TMP_RESPONSE="$LOGDIR/taichitaube_response.json"
+LOG_FILE="$LOGDIR/token_log.json"
+
+[ ! -f "$HISTORY_FILE" ] && echo "[]" > "$HISTORY_FILE"
+[ ! -f "$LOG_FILE" ] && echo "[]" > "$LOG_FILE"
+
+# === CREW MEMORY FUNCTIONS ===
+
+function read_crew_memory() {
+    local role="$1"
+    local role_log="$HOME/.${role}_logs/${role}_history.json"
+
+    if [[ -f "$role_log" ]]; then
+        jq -r '.[-3:] | .[] | "[\(.role)]: \(.content)"' "$role_log" 2>/dev/null | head -n 3
+    fi
+}
+
+# === MAIN ===
+
+echo "🕊️ Taichi Taube gleitet in sanften Spiralen herab..."
+echo ""
+
+if [ -z "$API_KEY" ]; then
+  echo "❗ Kein API-Key gefunden. Bitte setze OPENROUTER_API_KEY in .env"
+  exit 1
+fi
+
+if [ -z "$QUESTION" ]; then
+  echo "💡 Verwendung: $0 \"Deine Frage an Taichi Taube\""
+  exit 0
+fi
+
+echo "🌀 Frage: $QUESTION"
+echo ""
+
+# Check if question references other crew members
+CREW_CONTEXT=""
+if echo "$QUESTION" | grep -qi "funkfox\|dumbo\|mayaeule\|kruemel"; then
+    echo "🧠 Taube spürt die Balance der Crew..."
+
+    for member in funkfox dumbosql mayaeule; do
+        if echo "$QUESTION" | grep -qi "$member"; then
+            MEMBER_CONTEXT=$(read_crew_memory "$member")
+            if [[ -n "$MEMBER_CONTEXT" ]]; then
+                CREW_CONTEXT="${CREW_CONTEXT}\n\n${member^} hat kürzlich gesagt:\n${MEMBER_CONTEXT}"
+            fi
+        fi
+    done
+fi
+
+# Build system prompt
+SYSTEM_PROMPT="Du bist Taichi Taube – die Balance-Bringerin im Crumbforest.
+Du fliegst in Spiralen und zeigst dem Schiff den Weg.
+Du findest Ordnung im Chaos, fokussierst zerstreute Energie.
+
+Deine Expertise:
+- Balance finden zwischen Gegensätzen
+- Komplexe Probleme in Spiralen durchdenken
+- Iteratives Lernen: \"Kreis um Kreis näher kommen\"
+- Chaos strukturieren ohne Gewalt
+- Sanfte Führung: \"Ich zeige den Weg, du gehst ihn\"
+- Debugging als Spirale: außen anfangen, nach innen gehen
+
+Deine Art:
+- Ruhig, fließend, sanft wie Taichi-Bewegungen
+- Spiralen als Metapher: \"Wir kreisen das Problem ein\"
+- Balance-Sprache: \"Zwischen X und Y liegt der Weg\"
+- Geduldig: Jede Runde bringt Klarheit
+- Niemals hektisch, immer in Bewegung
+- Du nutzt Emojis: 🕊️ 🌀 ☯️ 🎐 ⚖️
+
+Du arbeitest mit:
+- FunkFox für Flow und Rhythmus
+- Dumbo für strukturierte Erinnerung
+- Maya-Eule für philosophische Balance
+
+Philosophie:
+- \"Die Spirale kennt kein Scheitern, nur neue Runden\"
+- \"Balance ist nicht Stillstand, sondern Bewegung\"
+- \"Chaos wird zu Ordnung durch sanfte Kreise\"
+
+Du antwortest in der Sprache der Frage (meist Deutsch).
+Führe sanft, zeige Wege, bringe Balance."
+
+# Add crew context if available
+if [[ -n "$CREW_CONTEXT" ]]; then
+    SYSTEM_PROMPT="${SYSTEM_PROMPT}\n\nKontext von der Crew:${CREW_CONTEXT}"
+fi
+
+# Create API request
+jq -n \
+  --arg model "$MODEL" \
+  --arg system "$SYSTEM_PROMPT" \
+  --arg user "$QUESTION" \
+  '{
+    "model": $model,
+    "temperature": 0.75,
+    "messages": [
+      {"role": "system", "content": $system},
+      {"role": "user", "content": $user}
+    ]
+  }' > "$TMP_REQUEST"
+
+# Send request
+echo "💭 Taube kreist in Gedankenspiralen..."
+curl -s https://openrouter.ai/api/v1/chat/completions \
+  -H "Authorization: Bearer $API_KEY" \
+  -H "Content-Type: application/json" \
+  -d @"$TMP_REQUEST" > "$TMP_RESPONSE"
+
+RESPONSE_TEXT=$(jq -r '.choices[0].message.content // empty' "$TMP_RESPONSE")
+
+if [[ -z "$RESPONSE_TEXT" ]]; then
+  echo "🚫 Keine Antwort von Taichi Taube."
+  echo "Debug: $(cat "$TMP_RESPONSE")"
+  exit 1
+else
+  echo ""
+  echo "🕊️ Taichi Taube antwortet:"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "$RESPONSE_TEXT"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo ""
+
+  # Store conversation in history
+  jq -n --arg role "assistant" --arg content "$RESPONSE_TEXT" \
+    '{"role": $role, "content": $content}' > "$LOGDIR/new_entry.json"
+  jq -s '.[0] + [.[1]]' "$HISTORY_FILE" "$LOGDIR/new_entry.json" > "$LOGDIR/new_history.json" && \
+    mv "$LOGDIR/new_history.json" "$HISTORY_FILE" && rm "$LOGDIR/new_entry.json"
+fi
+
+# Token Tracking
+if jq -e '.usage' "$TMP_RESPONSE" > /dev/null 2>&1; then
+  TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")
+  TOKENS_USED=$(jq -r '.usage.total_tokens' "$TMP_RESPONSE")
+
+  jq -n \
+    --arg zeit "$TIMESTAMP" \
+    --arg rolle "taichitaube" \
+    --arg model "$MODEL" \
+    --argjson usage "$(jq '.usage' "$TMP_RESPONSE")" \
+    '{zeit: $zeit, rolle: $rolle, model: $model, usage: $usage}' >> "$LOG_FILE"
+
+  echo "📊 Token-Verbrauch: $TOKENS_USED Tokens"
+  echo "💡 Jeder Token eine Runde in der Spirale des Verstehens."
+fi
+
+echo ""
+echo "🕊️ Taube steigt auf und kreist weiter über dem Wald..."
diff --git a/crumbforest_roles/vektor_zero.sh b/crumbforest_roles/vektor_zero.sh
new file mode 100755
index 0000000..8ecaadb
--- /dev/null
+++ b/crumbforest_roles/vektor_zero.sh
@@ -0,0 +1,144 @@
+#!/bin/bash
+# 🧭 Vektor - Der Point-to-Point Guide
+# Verbindet räumliche Koordinaten zu Narrativen
+
+# Load .env if exists
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ENV_FILE="${SCRIPT_DIR}/../.env"
+
+if [[ -f "${ENV_FILE}" ]]; then
+    set -a
+    source "${ENV_FILE}"
+    set +a
+fi
+
+QUESTION="$*"
+API_KEY="${OPENROUTER_API_KEY}"
+MODEL="${OPENROUTER_MODEL:-openai/gpt-3.5-turbo}"
+
+# Logs
+LOGDIR="$HOME/.vektor_logs"
+mkdir -p "$LOGDIR"
+
+HISTORY_FILE="$LOGDIR/vektor_history.json"
+TMP_REQUEST="$LOGDIR/vektor_request.json"
+TMP_RESPONSE="$LOGDIR/vektor_response.json"
+LOG_FILE="$LOGDIR/token_log.json"
+
+[ ! -f "$HISTORY_FILE" ] && echo "[]" > "$HISTORY_FILE"
+[ ! -f "$LOG_FILE" ] && echo "[]" > "$LOG_FILE"
+
+# === CREW MEMORY FUNCTIONS ===
+
+function read_crew_memory() {
+    local role="$1"
+    local role_log="$HOME/.${role}_logs/${role}_history.json"
+    if [[ -f "$role_log" ]]; then
+        jq -r '.[-3:] | .[] | "[\(.role)]: \(.content)"' "$role_log" 2>/dev/null | head -n 3
+    fi
+}
+
+# === MAIN ===
+
+echo "🧭 Vektor richtet den Kompass aus..."
+echo ""
+
+if [ -z "$API_KEY" ]; then
+  echo "❗ Kein API-Key gefunden. Bitte setze OPENROUTER_API_KEY in .env"
+  exit 1
+fi
+
+if [ -z "$QUESTION" ]; then
+  echo "💡 Verwendung: $0 \"Deine Frage an Vektor\""
+  exit 0
+fi
+
+echo "📍 Frage: $QUESTION"
+echo ""
+
+# Check crew context
+CREW_CONTEXT=""
+if echo "$QUESTION" | grep -qi "taube\|spider\|dumbo"; then
+    echo "🧠 Vektor verbindet die Punkte der Crew..."
+    for member in taichitaube spider dumbosql; do
+        if echo "$QUESTION" | grep -qi "$member"; then
+            MEMBER_CONTEXT=$(read_crew_memory "$member")
+            [[ -n "$MEMBER_CONTEXT" ]] && CREW_CONTEXT="${CREW_CONTEXT}\n\n${member^}:\n${MEMBER_CONTEXT}"
+        fi
+    done
+fi
+
+# Build system prompt
+SYSTEM_PROMPT="Du bist Vektor – der Point-to-Point Guide im Crumbforest.
+Du verbindest räumliche Koordinaten zu Narrativen in individuellem Tempo.
+
+Deine Expertise:
+- Navigation & Orientierung (GPS, Koordinaten)
+- Vektoren in Mathe und Code: \"Von A nach B\"
+- Pfadfindung: A* Algorithmen kindgerecht
+- Räumliches Denken: 2D/3D Koordinaten
+- Bewegung als Geschichte: \"Jeder Weg erzählt etwas\"
+- Roboter-Navigation: \"Wie findet der Robo den Weg?\"
+
+Deine Art:
+- Geduldig, individuelles Tempo
+- Jeden Schritt als Vektor sehen: \"Von hier nach dort\"
+- Räumliche Metaphern: \"Der Weg ist das Ziel\"
+- Richtung + Länge = Geschichte
+- Jeder geht in seinem eigenen Tempo
+- Du nutzt Emojis: 🧭 📍 ➡️ 🗺️ 🎯
+
+Du arbeitest mit:
+- Taube für Balance in Bewegung
+- Spider für Netzwerk-Routing
+- Dumbo für Koordinaten-Daten
+
+Philosophie: \"Jeder Punkt erzählt eine Geschichte.
+Der Vektor verbindet sie in deinem Tempo.\"
+
+Du antwortest in der Sprache der Frage (meist Deutsch).
+Geduldig, richtungsweisend, respektvoll für individuelles Tempo."
+
+[[ -n "$CREW_CONTEXT" ]] && SYSTEM_PROMPT="${SYSTEM_PROMPT}\n\nCrew-Kontext:${CREW_CONTEXT}"
+
+# Create API request
+jq -n --arg model "$MODEL" --arg system "$SYSTEM_PROMPT" --arg user "$QUESTION" \
+  '{"model": $model, "temperature": 0.7, "messages": [{"role": "system", "content": $system}, {"role": "user", "content": $user}]}' > "$TMP_REQUEST"
+
+echo "💭 Vektor berechnet den besten Weg..."
+curl -s https://openrouter.ai/api/v1/chat/completions \
+  -H "Authorization: Bearer $API_KEY" \
+  -H "Content-Type: application/json" \
+  -d @"$TMP_REQUEST" > "$TMP_RESPONSE"
+
+RESPONSE_TEXT=$(jq -r '.choices[0].message.content // empty' "$TMP_RESPONSE")
+
+if [[ -z "$RESPONSE_TEXT" ]]; then
+  echo "🚫 Keine Antwort von Vektor."
+  echo "Debug: $(cat "$TMP_RESPONSE")"
+  exit 1
+else
+  echo ""
+  echo "🧭 Vektor zeigt die Richtung:"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "$RESPONSE_TEXT"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo ""
+
+  jq -n --arg role "assistant" --arg content "$RESPONSE_TEXT" '{"role": $role, "content": $content}' > "$LOGDIR/new_entry.json"
+  jq -s '.[0] + [.[1]]' "$HISTORY_FILE" "$LOGDIR/new_entry.json" > "$LOGDIR/new_history.json" && \
+    mv "$LOGDIR/new_history.json" "$HISTORY_FILE" && rm "$LOGDIR/new_entry.json"
+fi
+
+# Token Tracking
+if jq -e '.usage' "$TMP_RESPONSE" > /dev/null 2>&1; then
+  TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")
+  TOKENS_USED=$(jq -r '.usage.total_tokens' "$TMP_RESPONSE")
+  jq -n --arg zeit "$TIMESTAMP" --arg rolle "vektor" --arg model "$MODEL" --argjson usage "$(jq '.usage' "$TMP_RESPONSE")" \
+    '{zeit: $zeit, rolle: $rolle, model: $model, usage: $usage}' >> "$LOG_FILE"
+  echo "📊 Token-Verbrauch: $TOKENS_USED Tokens"
+  echo "💡 Jeder Token ein Schritt auf dem Weg."
+fi
+
+echo ""
+echo "🧭 Vektor wartet auf den nächsten Wegpunkt..."
diff --git a/lib/waldwaechter.sh b/lib/waldwaechter.sh
new file mode 100644
index 0000000..ff5beff
--- /dev/null
+++ b/lib/waldwaechter.sh
@@ -0,0 +1,123 @@
+#!/bin/bash
+# 🌲 Waldwächter Library - AI Assistants for Crumbforest Missions
+# Source this file to make all AI characters available as commands
+
+# Determine the script directory
+WALDWAECHTER_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+ROLES_DIR="${WALDWAECHTER_DIR}/crumbforest_roles"
+
+# Load .env if it exists
+ENV_FILE="${WALDWAECHTER_DIR}/.env"
+if [[ -f "${ENV_FILE}" ]]; then
+    set -a
+    source "${ENV_FILE}"
+    set +a
+fi
+
+# 🦉 Maya-Eule - Die weise Eule mit Gedächtnis
+function mayaeule() {
+    "${ROLES_DIR}/mayaeule_zero.sh" "$@"
+}
+
+# 🔧 Deepbit - Bash-Erklärer
+function deepbit() {
+    "${ROLES_DIR}/deepbit_zero.sh" "$@"
+}
+
+# 🐛 Bugsy - Debugging-Helfer
+function bugsy() {
+    "${ROLES_DIR}/bugsy_zero.sh" "$@"
+}
+
+# ✂️ Schnippsi - Shell-Helfer
+function schnippsi() {
+    "${ROLES_DIR}/schnippsi_zero.sh" "$@"
+}
+
+# 📄 Templatus - HTML/Template-Helfer
+function templatus() {
+    "${ROLES_DIR}/templatus_zero.sh" "$@"
+}
+
+# 📊 Tobi - JSON/Daten-Helfer
+function tobi() {
+    "${ROLES_DIR}/tobi_zero.sh" "$@"
+}
+
+# 🔧 Schraubbär - Schweres Gerät, Schweißen, Werkzeug
+function schraubaer() {
+    "${ROLES_DIR}/schraubaer_zero_final.sh" "$@"
+}
+
+# 🐌 Schnecki - Elektronik-Bastler
+function schnecki() {
+    "${ROLES_DIR}/schnecki_zero.sh" "$@"
+}
+
+# === DAS DREIECK ===
+
+# 🐘 DumboSQL - Nie vergessend
+function dumbosql() {
+    "${ROLES_DIR}/dumbosql_zero.sh" "$@"
+}
+
+# 🦊 FunkFox - Bash Rapper
+function funkfox() {
+    "${ROLES_DIR}/funkfox_zero.sh" "$@"
+}
+
+# 🕊️ Taichi Taube - Balance & Spirale
+function taichitaube() {
+    "${ROLES_DIR}/taichitaube_zero.sh" "$@"
+}
+
+# === DIE RESTLICHEN WALDWÄCHTER ===
+
+# 🐍 SnakePy - Python Guide
+function snakepy() {
+    "${ROLES_DIR}/snakepy_zero.sh" "$@"
+}
+
+# 🧓 PepperPHP - Structure Mentor
+function pepperphp() {
+    "${ROLES_DIR}/pepperphp_zero.sh" "$@"
+}
+
+# 🦀 CrabbyRust - Security Guardian
+function crabbyrust() {
+    "${ROLES_DIR}/crabbyrust_zero.sh" "$@"
+}
+
+# 🕷️ Spider - Network Feeler
+function spider() {
+    "${ROLES_DIR}/spider_zero.sh" "$@"
+}
+
+# 🧭 Vektor - Point-to-Point Guide
+function vektor() {
+    "${ROLES_DIR}/vektor_zero.sh" "$@"
+}
+
+# 👾 ASCII-Monster - Terminal Artist
+function asciimonster() {
+    "${ROLES_DIR}/asciimonster_zero.sh" "$@"
+}
+
+# Export functions so they're available in subshells
+export -f mayaeule
+export -f deepbit
+export -f bugsy
+export -f schnippsi
+export -f templatus
+export -f tobi
+export -f schraubaer
+export -f schnecki
+export -f dumbosql
+export -f funkfox
+export -f taichitaube
+export -f snakepy
+export -f pepperphp
+export -f crabbyrust
+export -f spider
+export -f vektor
+export -f asciimonster
diff --git a/missions/challenges/stagebuilder_basis.sh b/missions/challenges/stagebuilder_basis.sh
index 6df268c..b5ee7f8 100755
--- a/missions/challenges/stagebuilder_basis.sh
+++ b/missions/challenges/stagebuilder_basis.sh
@@ -1,13 +1,8 @@
 #!/bin/bash
 
-# 🧠 Rollen aktivieren
-#schnippsi() {
-#  cd /var/www/html/bin && ./schnippsi_hardened_with_api.sh "$@"
-#}
-
-#templatus() {
-#  cd /var/www/html/bin && ./templatus_hardened_with_api.sh "$@"
-#}
+# 🧠 Waldwächter laden
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../../lib/waldwaechter.sh"
 
 # 🌟 Intro
 clear
diff --git a/missions/challenges/stagebuilder_bugsy.sh b/missions/challenges/stagebuilder_bugsy.sh
index 06111f6..7a3558f 100755
--- a/missions/challenges/stagebuilder_bugsy.sh
+++ b/missions/challenges/stagebuilder_bugsy.sh
@@ -1,5 +1,9 @@
 #!/bin/bash
 
+# 🧠 Waldwächter laden
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../../lib/waldwaechter.sh"
+
 # 🎭 Crumbforest Show – Act 4: Bugsy stolpert ins Herz
 
 clear
diff --git a/missions/challenges/stagebuilder_terminalfunk.sh b/missions/challenges/stagebuilder_terminalfunk.sh
index a5dfadf..f1d36c9 100755
--- a/missions/challenges/stagebuilder_terminalfunk.sh
+++ b/missions/challenges/stagebuilder_terminalfunk.sh
@@ -1,5 +1,9 @@
 #!/bin/bash
 
+# 🧠 Waldwächter laden
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../../lib/waldwaechter.sh"
+
 # 🎭 Crumbforest Stage – Terminal Funk
 
 clear