feat(brain): API-Heuristik — Cross-Session-Counter fuer Skill-Drift

Variante B: scaffold-reflex Regel allein reicht nicht weil jede Chat-
Anfrage eine eigene claude-CLI-Session ist. ARIA sieht in der aktuellen
Session nicht dass sie gestern auch schon 10x dieselbe API gecurled hat.
Beobachtung: 5+ Spotify-Bash-Calls hintereinander, kein Skill angelegt.

Loesung: Brain trackt server-side aus dem persistierten agent_stream.jsonl.
Bei jedem chat() wird der Log gescanned (cache 5min), Bash-curl-Calls
nach Hostname aggregiert. Hosts mit >=3 Calls in 24h ohne passenden
Skill landen als '## API-Heuristik'-Block im System-Prompt mit konkretem
skill_scaffold-Vorschlag.

Neue Module:
- aria-brain/api_heuristic.py:
  - compute_hints(existing_skills, force): Aggregiert + filtert
  - build_section(hints): formatiert als kompakten Markdown-Block
  - Smart suggestions mapping (api.spotify.com → oauth-api template etc.)
  - Ignoriert interne Hosts (aria-brain, localhost, docker-bridge)
  - 5-min Cache damit nicht jeder Turn die JSONL parst

- aria-brain/prompts.py: build_system_prompt nimmt api_heuristic_section
  als optionalen Block direkt nach Skills-Section.

- aria-brain/agent.py: vor build_system_prompt Heuristik berechnen mit
  aktueller Skill-Liste, Block durchreichen.

- 11. seed_rule scaffold-reflex umgeschrieben: kein 'in einer Session'
  mehr (das ergab keinen Sinn — jeder Turn neue Session). Stattdessen:
  '## API-Heuristik'-Block ist Dein Cross-Session-Gedaechtnis. Wenn da
  was steht: scaffolden BEVOR Du Bash machst.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

README.md

@@ -324,6 +324,111 @@ aria-brain → Antwort → Bridge → RVS → App
 
 ---
 
+## Skills — Architektur
+
+Skills sind ARIAs wiederverwendbare Faehigkeiten. Jeder Skill ist ein
+Python-Programm in seinem eigenen `local-venv`. ARIA legt sie selbst via
+`skill_create` an, fixt Bugs mit `skill_update`, rollt zur Not zurueck
+mit `skill_rollback`.
+
+### Skill-Layout
+
+```
+/data/skills/<name>/
+  skill.json              # Manifest (Metadata + config_schema + version_history)
+  run.py                  # Entry-Point (Python via venv-python)
+  requirements.txt        # pip-Pakete fuer die venv
+  README.md               # Beschreibung
+  venv/                   # automatisch erzeugt
+  logs/<ts>.json          # Run-Logs (append-only)
+  versions/v_<ts>/        # archivierte Vorgaengerstaende (vor jedem update_skill)
+```
+
+### Drei-Stufen-Daten-Modell
+
+Skills muessen **niemals** Credentials hardcoden. Drei saubere Wege:
+
+1. **OAuth2-Tokens** (Spotify, Google, GitHub, Reddit, …): Brain haelt
+   Client-Credentials und macht den Auth-Flow. Skill ruft
+   `GET {BRAIN_INTERNAL_URL}/oauth/<service>/token` und bekommt einen
+   frischen access_token (Auto-Refresh < 60 s Restzeit).
+2. **Statische Werte** (API-Keys, User-IDs, Default-Geraete): Skill
+   deklariert ein `config_schema` in `skill.json`, Stefan setzt die
+   Werte in Diagnostic / App, Skill bekommt sie zur Laufzeit als
+   `CFG_<UPPER_NAME>` ENV.
+3. **Brain-Daten** (Memories, Skills-Liste, Standort etc.): jeder Skill
+   kann gegen `BRAIN_INTERNAL_URL` Endpoints wie `/memory/search`,
+   `/memory/pinned`, `/skills/list` rufen — z.B. ein Wetter-Skill kann
+   Stefans Standort aus Memories holen statt ihn als Arg zu erwarten.
+
+### Versionierung mit Rollback
+
+`update_skill` archiviert den aktuellen Stand vor jeder strukturellen
+Aenderung (entry_code, readme, pip_packages, config_schema, args) nach
+`versions/v_<ts>/`. ARIA-Tools `skill_list_versions` + `skill_rollback`
+(+ HTTP `/skills/{name}/versions` + `/rollback`) erlauben Wiederherstellung.
+Vor jedem Rollback wird der aktuelle Stand als „safety-snapshot" gesichert
+— der Rollback selbst ist also nicht destruktiv.
+
+UI sowohl in Diagnostic (Skill-Detail → 📦 Versionen) als auch in der App
+(SkillBrowser → Detail-Modal).
+
+### Anti-Skill-Friedhof
+
+ARIA hat frueher gerne 9 Spotify-Skills mit Suffixen `-v2`, `-aria`,
+`-ctl`, `-fixed` gebaut statt einen sauberen zu pflegen.
+`skills.create_skill()` rejected jetzt hart:
+
+- Versions-Suffixe (`-v\d+`, `_v\d+`, `-new`, `-fixed`, `-old`,
+  `-alt`, `-copy`, `-final`, `-clean`)
+- Prefix-Kollisionen (`spotify` existiert → `spotify-aria` rejected)
+
+Plus die Skill-Regeln (siehe naechster Abschnitt) erinnern ARIA bei jedem
+Chat-Turn an die richtigen Patterns.
+
+### Skill-Regeln (seed_rules)
+
+`aria-brain/seed_rules.py` enthaelt 11 `type=rule, pinned=true,
+source=seed`-Memories, die bei jedem Brain-Start idempotent in die
+Vector-DB geschrieben werden (`migration_key`-basiert). Sie tauchen in
+jedem Chat-Turn im Hot-Memory-Block auf:
+
+- **list-before-create** — IMMER `skill_list` vor `skill_create`
+- **no-version-suffix** — keine `-v2`/`_v3`-Namen, Versionsverwaltung ist intern
+- **update-not-recreate** — defekten Skill mit `skill_update` fixen, nicht neu bauen
+- **no-hardcoded-credentials** — OAuth-Tokens via `oauth_get_token`, keine client_secrets im Code
+- **config-schema-for-settings** — statische Werte via `config_schema`, nicht hardcoded
+- **brain-internal-url** — `BRAIN_INTERNAL_URL` Endpoints inkl. `/oauth/<s>/token`, `/memory/search`, `/memory/pinned`, `/skills/list`
+- **oauth-reauth-reflex** — bei 401: ZUERST `oauth_get_token` (Auto-Refresh), nur bei dessen Fehler `oauth_authorize`
+- **no-skill-drift** — kein Drift vom Skill zu Ad-hoc-Bash-Befehlen. Skill kaputt? `skill_logs` + `skill_update`. Niemals nur SAGEN „ich baue dir einen Skill", wenn `skill_create` nicht wirklich gefeuert wird
+- **runtime-topology** (architektur) — ARIA laeuft als `claude`-CLI-Subprocess IM aria-proxy Container (alpine — kein python3/jq), NICHT im aria-brain. `/data/skills/` und `BRAIN_INTERNAL_URL` existieren dort nicht. Brain-Resources via Brain-Tools (`oauth_get_token`, `memory_search`, `run_<skill>` …), nicht via Bash. SSH zur VM-Host via `ssh aria@host` (Key liegt im Proxy)
+- **scaffold-reflex** — Brain trackt cross-session welche externen Hosts via Bash-curl wiederholt (≥3× in 24h) ohne passenden Skill aufgerufen wurden. Ergebnis landet als `## API-Heuristik`-Block im System-Prompt mit konkretem `skill_scaffold(...)`-Vorschlag → ARIA scaffolded statt zu curlen. Data-Source: `agent_stream.jsonl`, Cache 5 min
+- **external-api-auth-strategy** — OAuth2 → `oauth_get_token`, sonst `config_schema`, NIEMALS hardcoden
+
+### Skill-Scaffold (Templates)
+
+Statt jedes Mal einen kompletten Skill aus dem Nichts zu generieren,
+ruft ARIA `skill_scaffold(name, template, params)` — Brain expandiert
+ein passendes Skelett. Massiv niedrigere Hürde gegen Skill-Drift.
+
+Drei mitgelieferte Templates (`aria-brain/skill_templates.py`):
+
+| Template | Wofür | params |
+|---|---|---|
+| `oauth-api` | Spotify, GitHub, Reddit, Google, Discord — Token aus Brain mit Auto-Refresh | `{service: "spotify", base_url?}` |
+| `apikey-api` | OpenWeather, OpenAI, Twilio — statischer Key in `config_schema` → `CFG_<NAME>` ENV | `{api_name, key_env, auth_header?, auth_prefix?, base_url}` |
+| `file-process` | PDF/Bild/JSON-Wandler — Input aus `/shared/uploads/`, Output zurueck. `process()`-Stub, danach `skill_update` mit echtem Code | `{output_ext}` |
+
+HTTP: `POST /skills/scaffold` + `GET /skills/templates` (Liste mit Param-Doku).
+Nach Scaffold optional `skill_update` falls Custom-Logik gebraucht wird.
+
+Im Gegensatz zu `aria-data/brain-import/` (User-Saatgut, gitignored,
+manueller Diagnostic-Klick) gehoeren seed_rules zum Brain-Code und werden
+mit jedem Deploy ausgerollt. Editieren = `SEED_RULES`-Liste anpassen,
+Brain neu starten.
+
+---
+
 ## Diagnostic — Selbstcheck-UI und Einstellungen
 
 Erreichbar unter `http://<VM-IP>:3001`. Teilt das Netzwerk mit der Bridge.
@@ -352,7 +457,10 @@ Erreichbar unter `http://<VM-IP>:3001`. Teilt das Netzwerk mit der Bridge.
 - **Voice Export/Import**: einzelne Stimmen als `.tar.gz` zwischen Gameboxen mitnehmen
 - **Settings Export/Import**: `voice_config.json` + `highlight_triggers.json` als JSON-Bundle
 - **Claude Login**: Browser-Terminal zum Einloggen in den Proxy
-- **ARIA Live**: read-only Mirror der Claude-Code-Session — alle Tool-Calls + Inputs + Outputs live in einer Monospace-Liste, farbcodiert. Plus ⛔ **Not-Aus**-Button der per RVS einen `cancel_request` mit `hard:true` ausloest → aria-bridge ruft den proxy-internen `/cancel-all` Side-Channel → alle Claude-Subprocesses werden sofort gekillt
+- **ARIA Live**: read-only Mirror der Claude-Code-Session — alle Tool-Calls + Inputs + Outputs live in einer Monospace-Liste, farbcodiert. **Persistenz**: jeder `agent_stream`-Event wird parallel in `/shared/logs/agent_stream.jsonl` (soft-cap 50 MB) geschrieben, Live-View laedt beim Tab-Oeffnen / Page-Reload die letzten 200 Eintraege — Browser-Standby wirft nichts mehr weg. Plus ⛔ **Not-Aus**-Button der per RVS einen `cancel_request` mit `hard:true` ausloest → aria-bridge ruft den proxy-internen `/cancel-all` Side-Channel → alle Claude-Subprocesses werden sofort gekillt
+- **Debug-API ohne SSH** (Diagnostic-Server, Port 3001):
+  - `GET /api/chat-backup?lines=N` — letzte N Zeilen aus `chat_backup.jsonl` (Default 200, max 5000) als geparstes JSON. Hilfreich um nachzuvollziehen was ARIA tatsaechlich gemacht hat.
+  - `GET /api/agent-stream?lines=N` — gleiche Mechanik fuer den persistierten Live-Stream (Tool-Calls + Inputs + Outputs).
 - **OAuth-Callback-Pipeline**: Caddy davor terminiert TLS via Let's Encrypt, RVS hat einen HTTP-Listener auf demselben Port wie der WebSocket. Provider (Spotify/Dropbox/Discord/...) redirecten den User an `https://{RVS_HOST}/oauth/callback/{service}` → RVS broadcastet als `oauth_callback`-WS-Message → aria-bridge forwarded an Brain → Brain matched `state`, tauscht `code` gegen Token, persistiert in `/shared/config/oauth_tokens.json`. Token-Refresh laeuft automatisch. ARIA hat vier Brain-Tools: **`oauth_register_provider`** (legt URLs eines neuen Providers wie Dropbox/Discord/Notion/... on-demand in `oauth_apps.json` an — Credentials bleiben Stefans Job), `oauth_authorize`, `oauth_get_token`, `oauth_revoke`
 
 ---
@@ -929,6 +1037,12 @@ docker exec aria-brain curl localhost:8080/memory/stats
 - [x] **ARIA Live (Diagnostic) + Not-Aus**: read-only Mirror der Claude-Code-Session ersetzt den SSH-Tab. Tool-Calls + Inputs + Outputs (truncated 4 KB) live, farbcodiert. Roter ⛔ Not-Aus-Button schickt `cancel_request` mit `hard:true` → Bridge ruft den proxy-internen `/cancel-all` Side-Channel (Port 3457) → alle Claude-Subprocesses sofort tot. Plus: Idle-Watchdog im Proxy (20 min Inaktivitaet → Subprocess-Kill) + httpx-Timeout-Split im Brain (connect 10s / read 24h) damit lange Pentests durchlaufen
 - [x] **OAuth2-Pipeline ueber RVS-Callback**: Caddy mit Let's Encrypt vor dem RVS, HTTP-Route `/oauth/callback/{service}` broadcastet als `oauth_callback`-WS-Message, aria-bridge forwarded an Brain, Token landet in `/shared/config/oauth_tokens.json` (mode 0600). ARIAs `oauth_register_provider`-Tool legt neue Provider on-demand an (URLs/scopes, nicht Credentials). Diagnostic + App haben beide Provider-Verwaltung inklusive Custom-Provider-Anlage
 - [x] **Skill-Mgmt-Tools fuer ARIA**: `skill_update` (Code/README/pip_packages mit venv-Rebuild) + `skill_delete` — verhindert Skill-Friedhof mit `-v2`/`-fixed`-Suffixen. Plus App-seitiger SkillBrowser (Run + Live-Output + Logs der letzten 20 Runs) in Settings → 🛠️ Skills
+- [x] **Skill-Architektur P0-P4**:
+  - `seed_rules` (9 pinned rule-Memories) werden bei jedem Brain-Boot idempotent in die DB geschrieben (`source=seed`, `migration_key`-basiert). Decken Skill-Friedhof, OAuth-Auth-Strategie, no-skill-drift, BRAIN_INTERNAL_URL ab
+  - Anti-Friedhof-Check in `create_skill`: rejected Versions-Suffixe + Prefix-Kollisionen hart
+  - Neuer Brain-HTTP-Endpoint `/oauth/<service>/token` + `BRAIN_INTERNAL_URL` ENV-Var fuer Skills — Skill ruft Brain fuer frischen Token statt client_secret hardzucoden
+  - `config_schema` in skill.json + zentrales `/shared/config/skill_configs.json` + `CFG_<NAME>` ENV beim Run + `skill_set_config` Brain-Tool + UI in Diagnostic & App (TextInput / Switch / password-Felder mit `***SET***`-Masking)
+  - Versionierung: jeder `skill_update` archiviert vorherigen Stand nach `versions/v_<ts>/` (ohne venv/logs). `skill_list_versions` + `skill_rollback` Brain-Tools (mit Safety-Snapshot + auto venv-Rebuild). UI mit Rollback-Button in Diagnostic & App
 - [x] **Bridge-Hang-Schutz + Voice-Speed persistent**: 3-Schichten-Watchdog (TCP-Keepalive + Asyncio-Watchdog + File-Based Liveness mit Self-Kill), TLS-Fallback klebt nicht mehr beim Reconnect. `xttsSpeed` jetzt im voice_config.json persistiert — greift auch bei Diagnostic-Chats und nach Bridge-Restart
 - [x] **Bubble-Aktionen in der App**: Long-Press oder ⎘-Icon auf einer Chat-Bubble → Aktions-Menu mit "📋 Ganzen Text teilen" plus pro extrahierte URL/E-Mail/Telefonnummer eine eigene Teilen-Option (System-Share-Sheet → Zwischenablage / Apps / Browser)
 

android/App.tsx

@@ -6,7 +6,7 @@
  */
 
 import React, { useEffect } from 'react';
-import { PermissionsAndroid, Platform, StatusBar, StyleSheet } from 'react-native';
+import { AppState, AppStateStatus, PermissionsAndroid, Platform, StatusBar, StyleSheet } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import { NavigationContainer, DefaultTheme } from '@react-navigation/native';
 import { createBottomTabNavigator } from '@react-navigation/bottom-tabs';
@@ -107,8 +107,26 @@ const App: React.FC = () => {
       console.warn('[App] GPS-Tracking restore fehlgeschlagen:', err?.message || err);
     });
 
+    // AppState-Listener: nach Hintergrund-Rueckkehr aktiv die WS-
+    // Verbindung neu aufbauen. Hintergrund: Android kann den TCP-Socket
+    // im Background killen, JS-State zeigt aber noch OPEN → Stefan musste
+    // manuell in Settings auf "Verbinden" tippen, oft mehrfach. Mit dem
+    // force-Reconnect bei "active" greift das automatisch.
+    let lastAppState: AppStateStatus = AppState.currentState;
+    const appStateSub = AppState.addEventListener('change', (next) => {
+      const wasBg = lastAppState !== 'active';
+      lastAppState = next;
+      if (next === 'active' && wasBg) {
+        console.log('[App] Foreground-Resume — force-reconnect zum RVS');
+        try { rvs.connect(true); } catch (e: any) {
+          console.warn('[App] force-reconnect fehlgeschlagen:', e?.message || e);
+        }
+      }
+    });
+
     // Beim Beenden: Verbindung sauber trennen
     return () => {
+      appStateSub.remove();
       rvs.disconnect();
     };
   }, []);

android/android/app/build.gradle

@@ -79,8 +79,8 @@ android {
         applicationId "com.ariacockpit"
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 10602
-        versionName "0.1.6.2"
+        versionCode 10603
+        versionName "0.1.6.3"
         // Fallback fuer Libraries mit Product Flavors
         missingDimensionStrategy 'react-native-camera', 'general'
     }

android/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aria-cockpit",
-  "version": "0.1.6.2",
+  "version": "0.1.6.3",
   "private": true,
   "scripts": {
     "android": "react-native run-android",

android/src/components/SkillBrowser.tsx

@@ -24,7 +24,7 @@ import {
   View,
 } from 'react-native';
 
-import brainApi, { Skill } from '../services/brainApi';
+import brainApi, { Skill, SkillConfigField, SkillVersion } from '../services/brainApi';
 
 const COL_ACTIVE = '#34C759';
 const COL_INACTIVE = '#555570';
@@ -177,8 +177,30 @@ const SkillDetailModal: React.FC<DetailProps> = ({ skill, onClose, onReload }) =
   const [logs, setLogs] = useState<any[] | null>(null);
   const [loadingLogs, setLoadingLogs] = useState(false);
 
+  // P3: Skill-Config (statische Werte je Skill, z.B. API-Keys)
+  const [cfgSchema, setCfgSchema] = useState<SkillConfigField[]>([]);
+  const [cfgValues, setCfgValues] = useState<Record<string, any>>({});
+  const [cfgDraft, setCfgDraft] = useState<Record<string, string>>({});
+  const [cfgSaving, setCfgSaving] = useState(false);
+
+  // P4: Versionen + Rollback
+  const [versions, setVersions] = useState<SkillVersion[]>([]);
+  const [versionsLoading, setVersionsLoading] = useState(false);
+
   const args = Array.isArray(skill.args) ? skill.args : [];
 
+  // Config + Versionen beim Mount laden
+  useEffect(() => {
+    brainApi.getSkillConfig(skill.name)
+      .then(r => { setCfgSchema(r.schema || []); setCfgValues(r.values || {}); })
+      .catch(() => {});
+    setVersionsLoading(true);
+    brainApi.listSkillVersions(skill.name)
+      .then(setVersions)
+      .catch(() => setVersions([]))
+      .finally(() => setVersionsLoading(false));
+  }, [skill.name]);
+
   const setArg = (name: string, value: string) =>
     setArgValues(prev => ({ ...prev, [name]: value }));
 
@@ -225,6 +247,85 @@ const SkillDetailModal: React.FC<DetailProps> = ({ skill, onClose, onReload }) =
     );
   };
 
+  const saveConfig = () => {
+    // secret-Felder die als '***SET***' angezeigt sind und vom User NICHT
+    // angefasst wurden, bleiben auf dem alten Wert. cfgDraft enthaelt nur
+    // explizit getippte Werte; alles andere uebernehmen wir aus cfgValues.
+    const next: Record<string, any> = { ...cfgValues };
+    for (const f of cfgSchema) {
+      const draft = cfgDraft[f.name];
+      const isSecret = f.secret || f.type === 'password';
+      if (draft === undefined) continue;
+      if (isSecret && draft === '') continue;  // leer = unveraendert
+      if (draft === '') { delete next[f.name]; continue; }
+      if (f.type === 'number') {
+        const n = Number(draft); next[f.name] = isNaN(n) ? draft : n;
+      } else if (f.type === 'boolean') {
+        next[f.name] = draft === 'true' || draft === '1';
+      } else {
+        next[f.name] = draft;
+      }
+    }
+    // Maskierte Werte (***SET***) niemals zurueckschreiben
+    for (const k of Object.keys(next)) if (next[k] === '***SET***') delete next[k];
+    setCfgSaving(true);
+    brainApi.setSkillConfig(skill.name, next)
+      .then(() => {
+        // frisch laden um neuen masked-State zu zeigen
+        return brainApi.getSkillConfig(skill.name);
+      })
+      .then(r => { setCfgSchema(r.schema || []); setCfgValues(r.values || {}); setCfgDraft({}); })
+      .catch(e => Alert.alert('Speichern fehlgeschlagen', String(e?.message || e)))
+      .finally(() => setCfgSaving(false));
+  };
+
+  const reloadVersions = () => {
+    setVersionsLoading(true);
+    brainApi.listSkillVersions(skill.name)
+      .then(setVersions)
+      .catch(() => {})
+      .finally(() => setVersionsLoading(false));
+  };
+
+  const doRollback = (versionId: string) => {
+    Alert.alert(
+      'Rollback?',
+      `Skill "${skill.name}" auf ${versionId} zuruecksetzen?\n\nDer aktuelle Stand wird vorher automatisch gesichert (safety-snapshot).`,
+      [
+        { text: 'Abbrechen', style: 'cancel' },
+        {
+          text: 'Rollback', style: 'destructive',
+          onPress: () => {
+            brainApi.rollbackSkill(skill.name, versionId)
+              .then(r => {
+                Alert.alert('Rollback OK', `Safety-Snapshot: ${r.safety_snapshot}`);
+                reloadVersions(); onReload();
+              })
+              .catch(e => Alert.alert('Rollback fehlgeschlagen', String(e?.message || e)));
+          },
+        },
+      ],
+    );
+  };
+
+  const removeVersion = (versionId: string) => {
+    Alert.alert(
+      'Version loeschen?',
+      `${versionId} dauerhaft entfernen?`,
+      [
+        { text: 'Abbrechen', style: 'cancel' },
+        {
+          text: 'Loeschen', style: 'destructive',
+          onPress: () => {
+            brainApi.deleteSkillVersion(skill.name, versionId)
+              .then(reloadVersions)
+              .catch(e => Alert.alert('Fehler', String(e?.message || e)));
+          },
+        },
+      ],
+    );
+  };
+
   return (
     <Modal visible animationType="slide" onRequestClose={onClose} transparent={false}>
       <View style={s.modal}>
@@ -274,6 +375,92 @@ const SkillDetailModal: React.FC<DetailProps> = ({ skill, onClose, onReload }) =
             </>
           ) : null}
 
+          {/* Config-Schema-Form (P3) */}
+          {cfgSchema.length > 0 ? (
+            <>
+              <Text style={[s.label, {marginTop: 18}]}>⚙ Konfiguration</Text>
+              {cfgSchema.map((f) => {
+                const isSecret = f.secret || f.type === 'password';
+                const cur = cfgValues[f.name];
+                const isSet = isSecret && cur === '***SET***';
+                const placeholder = isSet ? '••• gesetzt — leer lassen = unverändert'
+                                  : (f.default !== undefined && f.default !== null ? `Default: ${String(f.default)}` : (f.type || 'string'));
+                const valStr = cfgDraft[f.name] !== undefined
+                  ? cfgDraft[f.name]
+                  : (isSecret ? '' : (cur !== undefined && cur !== null && cur !== '***SET***' ? String(cur) : ''));
+                if (f.type === 'boolean') {
+                  const bv = cfgDraft[f.name] !== undefined
+                    ? (cfgDraft[f.name] === 'true')
+                    : (cur === true || cur === 'true');
+                  return (
+                    <View key={f.name} style={{marginBottom: 10, flexDirection: 'row', alignItems: 'center', gap: 10}}>
+                      <Switch value={bv} onValueChange={(v) => setCfgDraft(p => ({...p, [f.name]: v ? 'true' : 'false'}))}
+                              trackColor={{false: '#1E1E2E', true: '#0096FF'}} thumbColor="#fff" />
+                      <View style={{flex: 1}}>
+                        <Text style={{color: '#E0E0F0', fontSize: 13}}>{f.label || f.name}</Text>
+                        {f.description ? <Text style={{color: '#555570', fontSize: 11}}>{f.description}</Text> : null}
+                      </View>
+                    </View>
+                  );
+                }
+                return (
+                  <View key={f.name} style={{marginBottom: 10}}>
+                    <Text style={{color: '#8888AA', fontSize: 12, marginBottom: 4}}>
+                      {f.label || f.name}{isSecret ? ' 🔒' : ''}
+                      {f.description ? <Text style={{color: '#555570'}}> — {f.description}</Text> : null}
+                    </Text>
+                    <TextInput
+                      style={s.input}
+                      value={valStr}
+                      onChangeText={(v) => setCfgDraft(p => ({...p, [f.name]: v}))}
+                      placeholder={placeholder}
+                      placeholderTextColor="#444460"
+                      autoCapitalize="none"
+                      autoCorrect={false}
+                      secureTextEntry={isSecret}
+                      keyboardType={f.type === 'number' ? 'numeric' : 'default'}
+                    />
+                  </View>
+                );
+              })}
+              <TouchableOpacity
+                style={[s.btn, {backgroundColor: '#1A1A2E', borderColor: COL_ACTIVE, marginTop: 4}]}
+                onPress={saveConfig}
+                disabled={cfgSaving}
+              >
+                <Text style={{color: COL_ACTIVE, textAlign: 'center', fontWeight: '700'}}>
+                  {cfgSaving ? 'Speichere...' : '💾 Konfiguration speichern'}
+                </Text>
+              </TouchableOpacity>
+            </>
+          ) : null}
+
+          {/* Versionen (P4) */}
+          {versions.length > 0 ? (
+            <>
+              <Text style={[s.label, {marginTop: 18}]}>📦 Versionen ({versions.length})</Text>
+              {versions.map(v => (
+                <View key={v.version_id} style={[s.metaBox, {marginTop: 6, flexDirection: 'row', alignItems: 'center', gap: 6}]}>
+                  <View style={{flex: 1}}>
+                    <Text style={[s.meta, {fontFamily: 'monospace', color: '#E0E0F0'}]}>{v.version_id}</Text>
+                    <Text style={s.meta}>{v.archived_at ? new Date(v.archived_at).toLocaleString('de-DE') : '—'}</Text>
+                    {v.summary ? <Text style={[s.meta, {fontStyle: 'italic'}]} numberOfLines={2}>{v.summary}</Text> : null}
+                  </View>
+                  <TouchableOpacity onPress={() => doRollback(v.version_id)}
+                    style={[s.btn, {paddingHorizontal: 10, paddingVertical: 6, borderColor: COL_ARIA, backgroundColor: '#1A1A2E'}]}>
+                    <Text style={{color: COL_ARIA, fontSize: 12}}>↺</Text>
+                  </TouchableOpacity>
+                  <TouchableOpacity onPress={() => removeVersion(v.version_id)}
+                    style={[s.btn, {paddingHorizontal: 10, paddingVertical: 6, borderColor: '#FF6B6B', backgroundColor: '#1A1A2E'}]}>
+                    <Text style={{color: '#FF6B6B', fontSize: 12}}>🗑</Text>
+                  </TouchableOpacity>
+                </View>
+              ))}
+            </>
+          ) : versionsLoading ? (
+            <ActivityIndicator color="#0096FF" style={{marginTop: 14}} />
+          ) : null}
+
           <View style={{flexDirection: 'row', gap: 8, marginTop: 14}}>
             <TouchableOpacity
               style={[s.btn, {backgroundColor: skill.active ? '#0096FF' : '#1E1E2E', flex: 1}]}

android/src/services/brainApi.ts

@@ -158,6 +158,26 @@ export interface Skill {
   version?: string;
   author?: string;                // "aria" | "stefan"
   setup_error?: string;
+  // P3: konfigurierbare Werte (API-Keys, IDs etc.) — Stefan setzt sie hier,
+  // Skill bekommt sie als CFG_<NAME> ENV. Werte selbst kommen via /config.
+  config_schema?: SkillConfigField[];
+  // P4: Versions-Historie. Detail-Liste kommt via /versions.
+  version_history?: { version_id: string; archived_at?: string; summary?: string }[];
+}
+
+export interface SkillConfigField {
+  name: string;
+  type: 'string' | 'number' | 'boolean' | 'password';
+  label?: string;
+  secret?: boolean;
+  description?: string;
+  default?: any;
+}
+
+export interface SkillVersion {
+  version_id: string;
+  archived_at?: string;
+  summary?: string;
 }
 
 /** Trigger-Manifest wie aus Brain `/triggers/list` zurueckkommt. */
@@ -395,7 +415,46 @@ export const brainApi = {
 
   /** Letzte Run-Logs eines Skills. */
   getSkillLogs(name: string, limit: number = 20): Promise<any[]> {
-    return _send(`/skills/${encodeURIComponent(name)}/logs?limit=${limit}`);
+    return _send(`/skills/${encodeURIComponent(name)}/logs?limit=${limit}`)
+      .then((r: any) => Array.isArray(r) ? r : (r?.logs || []));
+  },
+
+  /** P3: Config-Schema + aktuelle Werte (secret-Felder gemaskt mit '***SET***'). */
+  getSkillConfig(name: string): Promise<{ schema: SkillConfigField[]; values: Record<string, any> }> {
+    return _send(`/skills/${encodeURIComponent(name)}/config`)
+      .then((r: any) => ({ schema: r?.schema || [], values: r?.values || {} }));
+  },
+
+  /** P3: Config-Werte komplett ueberschreiben. Werte greifen ab dem naechsten Run. */
+  setSkillConfig(name: string, values: Record<string, any>): Promise<{ ok: boolean; values: Record<string, any> }> {
+    return _send(`/skills/${encodeURIComponent(name)}/config`, {
+      method: 'POST',
+      body: { values },
+      timeoutMs: 10000,
+    });
+  },
+
+  /** P4: Liste archivierter Versionen, neueste zuerst. */
+  listSkillVersions(name: string): Promise<SkillVersion[]> {
+    return _send(`/skills/${encodeURIComponent(name)}/versions`)
+      .then((r: any) => r?.versions || []);
+  },
+
+  /** P4: Rollback auf eine fruehere Version. Aktueller Stand wird automatisch gesichert. */
+  rollbackSkill(name: string, versionId: string): Promise<{ ok: boolean; rolled_back_to: string; safety_snapshot: string }> {
+    return _send(`/skills/${encodeURIComponent(name)}/rollback`, {
+      method: 'POST',
+      body: { version_id: versionId },
+      timeoutMs: 60000,  // venv-Rebuild kann dauern
+    });
+  },
+
+  /** P4: Einzelne Version dauerhaft loeschen. */
+  deleteSkillVersion(name: string, versionId: string): Promise<{ ok: boolean; deleted: string }> {
+    return _send(`/skills/${encodeURIComponent(name)}/versions/${encodeURIComponent(versionId)}`, {
+      method: 'DELETE',
+      timeoutMs: 10000,
+    });
   },
 
   // ── OAuth ────────────────────────────────────────────────────────

android/src/services/rvs.ts

@@ -83,21 +83,39 @@ class RVSConnection {
 
   // --- Verbindung ---
 
-  /** Verbindung zum RVS aufbauen */
-  connect(): void {
+  /** Verbindung zum RVS aufbauen. force=true: bestehende Connection hart
+   * schliessen + neu verbinden (auch wenn JS denkt readyState=OPEN — kann
+   * nach Hintergrund-Pause ein Zombie-WS sein wo TCP tot ist aber JS-State
+   * noch OPEN zeigt; in dem Fall war "Bereits verbunden" ein No-Op und
+   * Stefan musste manuell zigmal klicken). */
+  connect(force: boolean = false): void {
     if (!this.config) {
       this.log('warn', 'Keine Verbindungskonfiguration vorhanden');
       return;
     }
 
-    if (this.ws?.readyState === WebSocket.OPEN) {
+    if (!force && this.ws?.readyState === WebSocket.OPEN) {
       this.log('info', 'Bereits verbunden');
       return;
     }
 
+    // Wenn ein WS-Objekt da ist (Zombie oder lebend), sauber abreissen
+    // bevor wir einen neuen aufbauen — sonst gibt's zwei parallele
+    // Verbindungen + doppelte Events.
+    if (this.ws) {
+      this.log('info', 'Bestehende WS-Verbindung wird geschlossen vor Neu-Connect');
+      try {
+        this.ws.onclose = null;  // verhindert dass scheduleReconnect doppelt feuert
+        this.ws.onerror = null;
+        this.ws.close();
+      } catch (_) {}
+      this.ws = null;
+    }
+
     this.shouldReconnect = true;
     this.reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
     this.usingTLSFallback = false;
+    this.clearTimers();
     this.log('info', `Verbindungsaufbau zu ${this.config.host}:${this.config.port} (TLS: ${this.config.useTLS ? 'ja' : 'nein'})`);
     this.establishConnection();
   }
@@ -212,6 +230,16 @@ class RVSConnection {
         this.ws = null;
         this.setState('disconnected');
 
+        // Sticky-Fallback-Reset: beim naechsten Reconnect wieder primary
+        // (wss://) versuchen statt fuer immer auf ws:// zu kleben. War
+        // der Hauptgrund warum die App nach Hintergrund-Rueckkehr nicht
+        // mehr verband — TLS-Handshake-Timeout in einem Reconnect → Fallback
+        // auf ws:// → Caddy refused → endlos im Fallback haengen.
+        if (this.usingTLSFallback) {
+          this.log('info', 'Reset TLS-Fallback fuer naechsten Reconnect (zurueck zu wss://)');
+          this.usingTLSFallback = false;
+        }
+
         if (this.shouldReconnect) {
           this.scheduleReconnect();
         }

aria-brain/agent.py

@@ -72,6 +72,18 @@ META_TOOLS = [
                 "Erstelle einen neuen Skill (wiederverwendbare Faehigkeit). "
                 "Skills sind IMMER Python — jeder Skill bekommt seine eigene venv "
                 "mit den pip_packages die er braucht.\n\n"
+                "PFLICHT VORHER:\n"
+                "  - `skill_list` aufrufen und pruefen ob ein passender Skill schon "
+                "existiert. Wenn ja: `skill_update` statt neu anlegen.\n"
+                "  - Name OHNE Versionssuffix waehlen (kein `-v2`, `_v3`, `-new`, "
+                "`-fixed`, `-aria`, `-ctl`). Versionsverwaltung ist intern, Du brauchst "
+                "nur einen klaren Namen.\n"
+                "  - Bei OAuth-Services (Spotify, Google, GitHub etc.): NIEMALS "
+                "client_id/client_secret/Tokens in den Code schreiben. Nutze "
+                "`oauth_get_token('<service>')` — das macht Auto-Refresh. Sonst muss "
+                "Stefan sich alle 60min manuell neu einloggen.\n"
+                "  - Bei konfigurierbaren Werten (User-IDs, Endpoints, Defaults): "
+                "ueber `config_schema` deklarieren, NICHT hardcoden.\n\n"
                 "HARTE REGEL — IMMER Skill anlegen wenn: die Loesung erfordert eine "
                 "pip-Library. Sonst muesste der Install bei jedem Container-Restart "
                 "neu laufen (Brain hat keinen persistenten State ausser /data/skills/).\n\n"
@@ -159,11 +171,126 @@ META_TOOLS = [
                     },
                     "description": {"type": "string", "description": "Neue Beschreibung (optional)"},
                     "active": {"type": "boolean", "description": "Aktivieren/deaktivieren (optional)"},
+                    "config_schema": {
+                        "type": "array",
+                        "items": {"type": "object"},
+                        "description": (
+                            "Optional neues config_schema fuer den Skill. Liste von "
+                            "Feldern [{name, type, label, secret?, description?, default?}]. "
+                            "type: string|number|boolean|password (password impliziert secret=true). "
+                            "Setzt Stefan in Diagnostic; Skill bekommt CFG_<NAME> ENV."
+                        ),
+                    },
                 },
                 "required": ["name"],
             },
         },
     },
+    {
+        "type": "function",
+        "function": {
+            "name": "skill_scaffold",
+            "description": (
+                "ERSTE WAHL fuer Skill-Bau wenn das Muster zu einem Template passt — "
+                "Brain expandiert das Skelett, Du sparst Dir das vollstaendige "
+                "Python-Programm zu generieren. Wenn Stefan eine externe API "
+                "mehrmals nutzt: SOFORT `skill_scaffold` statt jedes Mal "
+                "ad-hoc Bash-curl.\n\n"
+                "Verfuegbare Templates:\n"
+                "  - **oauth-api**: OAuth2-API (Spotify, GitHub, Reddit, Google, Discord, …). "
+                "Token kommt vom Brain mit Auto-Refresh. params: "
+                "`{service:'spotify', base_url?:'https://...'}`\n"
+                "  - **apikey-api**: API mit statischem Key (OpenWeather, OpenAI, Twilio). "
+                "Key liegt im skill.json config_schema → CFG_<NAME> ENV. params: "
+                "`{api_name:'OpenWeather', key_env:'OWM_API_KEY', auth_header?:'Authorization', auth_prefix?:'Bearer ', base_url:'https://...'}`\n"
+                "  - **file-process**: Skelett fuer Datei-In/Datei-Out (PDF, Bild, JSON umformen). "
+                "process()-Funktion ist Stub — danach `skill_update` mit echtem Code. params: "
+                "`{output_ext:'txt'}`\n\n"
+                "Nach Scaffold kannst Du das Skelett via `skill_update` weiter "
+                "anpassen falls noetig (mehr pip_packages, andere args, …). "
+                "Aber meistens reicht das Template direkt.\n\n"
+                "Wenn kein Template passt: erst pruefen ob Du wirklich ein "
+                "kustomes brauchst, sonst lieber Template + Update."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string",
+                             "description": "Skill-Name (kebab-case, ohne Versionssuffix)"},
+                    "template": {"type": "string",
+                                 "enum": ["oauth-api", "apikey-api", "file-process"],
+                                 "description": "Eines der drei Templates"},
+                    "params": {"type": "object",
+                               "description": "Template-spezifische Parameter (siehe description)"},
+                },
+                "required": ["name", "template"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "skill_set_config",
+            "description": (
+                "Setzt Config-Werte fuer einen Skill persistent (z.B. API-Keys, "
+                "User-IDs, Endpoint-URLs). Werte landen als CFG_<UPPER_NAME> ENV "
+                "im naechsten skill_run. Nutze das wenn Stefan dir im Chat einen "
+                "Wert nennt ('mein OpenWeather-Key ist abc123') — schreib den "
+                "NICHT in den Skill-Code, sondern hierher.\n\n"
+                "WICHTIG: values ueberschreibt komplett. Wenn Du nur einen Wert "
+                "aendern willst: erst per Diagnostic-UI oder Skill-Inspect die "
+                "aktuelle Liste ansehen und mit dem neuen Wert ergaenzen."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string", "description": "Skill-Name"},
+                    "values": {
+                        "type": "object",
+                        "description": "Map config-Feldname → Wert. Felder muessen im config_schema deklariert sein.",
+                    },
+                },
+                "required": ["name", "values"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "skill_list_versions",
+            "description": (
+                "Listet archivierte Versionen eines Skills (jeder skill_update "
+                "legt automatisch eine an). Returns [{version_id, archived_at, "
+                "summary}]. Brauchst Du fuer skill_rollback."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {"name": {"type": "string"}},
+                "required": ["name"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "skill_rollback",
+            "description": (
+                "Stellt eine fruehere Skill-Version wieder her. Vor dem Rollback "
+                "wird der aktuelle Stand automatisch archiviert — du verlierst "
+                "nichts. Nutze das wenn ein skill_update was kaputt gemacht hat "
+                "oder Stefan sagt 'mach den letzten Stand wieder her'. "
+                "version_id bekommst Du aus skill_list_versions."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string"},
+                    "version_id": {"type": "string", "description": "Format v_<timestamp>"},
+                },
+                "required": ["name", "version_id"],
+            },
+        },
+    },
     {
         "type": "function",
         "function": {
@@ -752,6 +879,18 @@ class Agent:
         oauth_host = os.environ.get("RVS_HOST", "").strip()
         oauth_port = os.environ.get("RVS_PORT_PUBLIC", os.environ.get("RVS_PORT", "443")).strip()
         oauth_tls = os.environ.get("RVS_TLS", "true").strip().lower() != "false"
+
+        # API-Heuristik: wenn ARIA gegen externe APIs wiederholt via Bash
+        # gecurled hat (cross-session, aus persistiertem agent_stream.jsonl),
+        # injiziert das einen Hinweis-Block der ihr scaffolden empfiehlt.
+        api_heuristic_section = ""
+        try:
+            import api_heuristic as _ah
+            hints = _ah.compute_hints(existing_skills=all_skills)
+            api_heuristic_section = _ah.build_section(hints)
+        except Exception as exc:
+            logger.warning("api_heuristic fehlgeschlagen: %s", exc)
+
         system_prompt = build_system_prompt(hot, cold, skills=all_skills,
                                             triggers=all_triggers,
                                             condition_vars=condition_vars,
@@ -760,7 +899,8 @@ class Agent:
                                             oauth_services=oauth_services,
                                             oauth_callback_host=oauth_host,
                                             oauth_callback_port=oauth_port,
-                                            oauth_callback_tls=oauth_tls)
+                                            oauth_callback_tls=oauth_tls,
+                                            api_heuristic_section=api_heuristic_section)
         messages = [ProxyMessage(role="system", content=system_prompt)]
         for t in self.conversation.window():
             messages.append(ProxyMessage(role=t.role, content=t.content))
@@ -844,6 +984,7 @@ class Agent:
                     readme=arguments.get("readme", ""),
                     args=arguments.get("args", []),
                     pip_packages=arguments.get("pip_packages", []),
+                    config_schema=arguments.get("config_schema") or None,
                     author="aria",
                 )
                 # Side-Channel-Event: Stefan soll sehen wenn ARIA was anlegt
@@ -858,6 +999,35 @@ class Agent:
                     },
                 })
                 return f"OK — Skill '{manifest['name']}' erstellt (active={manifest['active']})."
+            if name == "skill_scaffold":
+                skill_name = (arguments.get("name") or "").strip()
+                template = (arguments.get("template") or "").strip()
+                params = arguments.get("params") or {}
+                if not skill_name or not template:
+                    return "FEHLER: name + template erforderlich."
+                try:
+                    manifest = skills_mod.scaffold_skill(
+                        name=skill_name, template=template, params=params, author="aria",
+                    )
+                except ValueError as exc:
+                    return f"FEHLER: {exc}"
+                # Side-Channel-Event analog zu skill_create
+                self._pending_events.append({
+                    "type": "skill_created",
+                    "skill": {
+                        "name": manifest["name"],
+                        "description": manifest.get("description", ""),
+                        "execution": manifest.get("execution", ""),
+                        "active": manifest.get("active", True),
+                        "setup_error": manifest.get("setup_error"),
+                        "scaffolded_from": template,
+                    },
+                })
+                return (
+                    f"OK — Skill '{manifest['name']}' aus Template '{template}' angelegt. "
+                    f"active={manifest['active']}. "
+                    f"Falls noetig: skill_update fuer custom Code, skill_set_config fuer secrets."
+                )
             if name == "skill_list":
                 items = skills_mod.list_skills(active_only=False)
                 if not items:
@@ -876,6 +1046,8 @@ class Agent:
                         patch[k] = arguments[k]
                 if "pip_packages" in arguments and isinstance(arguments["pip_packages"], list):
                     patch["pip_packages"] = arguments["pip_packages"]
+                if "config_schema" in arguments and isinstance(arguments["config_schema"], list):
+                    patch["config_schema"] = arguments["config_schema"]
                 if not patch:
                     return "FEHLER: keine Felder zum Update angegeben."
                 try:
@@ -906,6 +1078,57 @@ class Agent:
                 except ValueError as exc:
                     return f"FEHLER: {exc}"
                 return f"OK — Skill '{skill_name}' geloescht."
+            if name == "skill_set_config":
+                skill_name = (arguments.get("name") or "").strip()
+                values = arguments.get("values")
+                if not skill_name or not isinstance(values, dict):
+                    return "FEHLER: name + values (dict) erforderlich."
+                try:
+                    skills_mod.set_skill_config(skill_name, values)
+                except ValueError as exc:
+                    return f"FEHLER: {exc}"
+                masked = skills_mod.get_skill_config_masked(skill_name)
+                return (
+                    f"OK — Config fuer Skill '{skill_name}' gesetzt. "
+                    f"Aktuelle Werte (secrets gemasked): {masked}"
+                )
+            if name == "skill_list_versions":
+                skill_name = (arguments.get("name") or "").strip()
+                if not skill_name:
+                    return "FEHLER: name ist Pflicht."
+                versions = skills_mod.list_skill_versions(skill_name)
+                if not versions:
+                    return f"Skill '{skill_name}' hat keine archivierten Versionen."
+                lines = [
+                    f"- {v.get('version_id')}  ({v.get('archived_at','?')})  {v.get('summary','')}"
+                    for v in versions
+                ]
+                return "Versionen (neueste zuerst):\n" + "\n".join(lines)
+            if name == "skill_rollback":
+                skill_name = (arguments.get("name") or "").strip()
+                version_id = (arguments.get("version_id") or "").strip()
+                if not skill_name or not version_id:
+                    return "FEHLER: name + version_id erforderlich."
+                try:
+                    res = skills_mod.rollback_skill(skill_name, version_id)
+                except ValueError as exc:
+                    return f"FEHLER: {exc}"
+                # Side-Channel-Event als skill_created getarnt — App/Diagnostic
+                # zeigen Rollback dann als sichtbare Aktion an
+                self._pending_events.append({
+                    "type": "skill_created",
+                    "skill": {
+                        "name": skill_name,
+                        "description": "(rollback)",
+                        "execution": "local-venv",
+                        "active": True,
+                        "updated": True,
+                    },
+                })
+                return (
+                    f"OK — Skill '{skill_name}' auf '{version_id}' zurueckgerollt. "
+                    f"Sicherheits-Snapshot des vorherigen Stands: {res.get('safety_snapshot')}"
+                )
             if name.startswith("run_"):
                 skill_name = name[len("run_"):]
                 res = skills_mod.run_skill(skill_name, args=arguments)

aria-brain/api_heuristic.py

@@ -0,0 +1,182 @@
+"""
+API-Heuristik — Cross-Session-Tracker fuer wiederkehrende externe API-Calls.
+
+Problem: ARIA driftet bei trivialen API-Calls zu Bash-curl statt Skills
+zu bauen. Die seed_rule "scaffold-reflex" greift nicht zuverlaessig weil
+jede Chat-Anfrage eine eigene Claude-CLI-Session ist — in der aktuellen
+Session sieht sie nicht dass dieselbe API gestern auch schon 10x via
+curl angerufen wurde.
+
+Loesung: Brain trackt server-side. Beim Bauen des System-Prompts wird
+`agent_stream.jsonl` der letzten 24h gescannt, Bash-curl-Calls werden
+nach Hostname aggregiert. Hosts ueber Schwelle bei denen noch kein
+matching Skill existiert landen als Hinweis-Block im System-Prompt —
+ARIA sieht "du machst 17x curl gegen api.spotify.com, scaffold bitte".
+
+Caching: Ergebnis 5 min gehalten, sonst grep wir bei jedem Turn die
+log-Datei. Bei <1 MB log file ist das eh schnell.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+import time
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+AGENT_STREAM_LOG = Path("/shared/logs/agent_stream.jsonl")
+
+# Schwellen / Lookback — bewusst niedrig gehalten weil "2x ist Pattern" stimmt
+LOOKBACK_HOURS = 24
+THRESHOLD = 3
+CACHE_TTL_SEC = 300
+
+# Hosts die wir IGNORIEREN — interne Endpoints / Defaults
+_IGNORED_HOSTS = {
+    "aria-brain", "brain", "localhost", "127.0.0.1", "0.0.0.0",
+    "api.example.com",  # template-default in skill_templates
+    "aria-bridge", "aria-rvs", "aria-qdrant", "aria-proxy", "aria-diagnostic",
+    "172.17.0.1",  # docker-host-bridge
+}
+
+# Bekannte Hosts → Template-Vorschlag fuer scaffold
+_SUGGESTIONS: dict[str, tuple[str, str, dict]] = {
+    "api.spotify.com": ("spotify", "oauth-api", {"service": "spotify"}),
+    "api.github.com": ("github", "oauth-api", {"service": "github", "base_url": "https://api.github.com"}),
+    "api.openai.com": ("openai", "apikey-api",
+                       {"api_name": "OpenAI", "key_env": "OPENAI_API_KEY",
+                        "base_url": "https://api.openai.com"}),
+    "api.openweathermap.org": ("openweather", "apikey-api",
+                               {"api_name": "OpenWeather", "key_env": "OWM_API_KEY",
+                                "base_url": "https://api.openweathermap.org"}),
+    "api.telegram.org": ("telegram", "apikey-api",
+                         {"api_name": "Telegram-Bot", "key_env": "TELEGRAM_BOT_TOKEN",
+                          "auth_header": "", "auth_prefix": "",
+                          "base_url": "https://api.telegram.org"}),
+    "graph.microsoft.com": ("microsoft", "oauth-api",
+                            {"service": "microsoft", "base_url": "https://graph.microsoft.com"}),
+    "discord.com": ("discord", "oauth-api",
+                    {"service": "discord", "base_url": "https://discord.com/api"}),
+    "api.notion.com": ("notion", "oauth-api",
+                       {"service": "notion", "base_url": "https://api.notion.com"}),
+    "reddit.com": ("reddit", "oauth-api",
+                   {"service": "reddit", "base_url": "https://oauth.reddit.com"}),
+    "oauth.reddit.com": ("reddit", "oauth-api",
+                         {"service": "reddit", "base_url": "https://oauth.reddit.com"}),
+}
+
+
+_cache: dict = {"computed_at": 0.0, "hints": []}
+
+
+def _extract_hosts_from_bash_input(input_str: str) -> list[str]:
+    """Hostnames aus URLs in einem Bash-Command. Sehr robust — sucht `https?://host`."""
+    if not input_str:
+        return []
+    return re.findall(r'https?://([a-zA-Z0-9.\-]+)', input_str)
+
+
+def _host_already_has_skill(host: str, skills: list[dict]) -> bool:
+    """Heuristik: Skill-Name enthaelt den 'wesentlichen' Teil des Hosts.
+
+    'api.spotify.com' → Stem 'spotify'. Wenn ein Skill 'spotify*' existiert: ja.
+    """
+    parts = [p for p in host.split(".") if p and p not in ("api", "www", "oauth")]
+    if not parts:
+        return False
+    stem = parts[0].lower()
+    for s in skills:
+        sname = (s.get("name") or "").lower()
+        if stem and stem in sname:
+            return True
+    return False
+
+
+def compute_hints(existing_skills: list[dict] | None = None, force: bool = False) -> list[dict]:
+    """Aggregiert Bash-curl-Calls der letzten LOOKBACK_HOURS aus dem
+    agent_stream.jsonl. Returns Liste von Hinweisen, geordnet nach Count
+    absteigend; nur Hosts ohne matching Skill, nur >= THRESHOLD Calls.
+
+    Hint-Format: {host, count, lookback_hours, suggestion: (name, template, params) | None}
+    """
+    skills = existing_skills or []
+    now = time.time()
+    if not force and (now - _cache["computed_at"]) < CACHE_TTL_SEC:
+        return _cache["hints"]
+
+    if not AGENT_STREAM_LOG.exists():
+        _cache.update(computed_at=now, hints=[])
+        return []
+
+    cutoff_ms = (now - LOOKBACK_HOURS * 3600) * 1000
+    counts: dict[str, int] = {}
+    try:
+        # Stream-Read damit grosse Files (50 MB cap) nicht in den Speicher kippen
+        with AGENT_STREAM_LOG.open(encoding="utf-8") as f:
+            for line in f:
+                if not line.strip():
+                    continue
+                try:
+                    e = json.loads(line)
+                except Exception:
+                    continue
+                if e.get("kind") != "tool_use":
+                    continue
+                if (e.get("name") or "") != "Bash":
+                    continue
+                if (e.get("ts") or 0) < cutoff_ms:
+                    continue
+                for host in _extract_hosts_from_bash_input(e.get("input") or ""):
+                    h = host.lower()
+                    if h in _IGNORED_HOSTS:
+                        continue
+                    counts[h] = counts.get(h, 0) + 1
+    except Exception as exc:
+        logger.warning("api_heuristic: konnte agent_stream nicht lesen: %s", exc)
+        return []
+
+    hints = []
+    for host, count in counts.items():
+        if count < THRESHOLD:
+            continue
+        if _host_already_has_skill(host, skills):
+            continue
+        hints.append({
+            "host": host,
+            "count": count,
+            "lookback_hours": LOOKBACK_HOURS,
+            "suggestion": _SUGGESTIONS.get(host),
+        })
+    hints.sort(key=lambda x: -x["count"])
+    _cache.update(computed_at=now, hints=hints)
+    return hints
+
+
+def build_section(hints: list[dict]) -> str:
+    """Formatiert einen kompakten System-Prompt-Block. Leer wenn nichts."""
+    if not hints:
+        return ""
+    lines = [
+        "## API-Heuristik (Cross-Session-Counter)",
+        "",
+        "Du hast in den letzten 24h diese externe(n) API(s) per Bash-curl "
+        "wiederholt angerufen, OHNE dass ein Skill dafuer existiert. Beim "
+        "naechsten Aufruf gegen einen dieser Hosts: BAUE ZUERST den Skill "
+        "via `skill_scaffold`, dann nutze ihn. Spart Stefan Wartezeit "
+        "und Dir Tool-Roundtrips.",
+        "",
+    ]
+    for h in hints[:5]:  # max 5 Eintraege damit Prompt nicht explodiert
+        sug = h.get("suggestion")
+        if sug:
+            name, tpl, params = sug
+            params_json = json.dumps(params, ensure_ascii=False)
+            sug_str = f"`skill_scaffold('{name}', '{tpl}', {params_json})`"
+        else:
+            sug_str = "`skill_scaffold` mit passendem Template (oauth-api / apikey-api)"
+        lines.append(f"- **{h['host']}** ({h['count']}x in 24h) → {sug_str}")
+    lines.append("")
+    return "\n".join(lines)

aria-brain/main.py

@@ -37,6 +37,7 @@ import triggers as triggers_mod
 import watcher as watcher_mod
 import background as background_mod
 import oauth as oauth_mod
+import seed_rules as seed_rules_mod
 
 logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(name)s: %(message)s")
 logger = logging.getLogger("aria-brain")
@@ -46,7 +47,13 @@ QDRANT_PORT = int(os.environ.get("QDRANT_PORT", "6333"))
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    """Beim Brain-Start: Trigger-Background-Loop anwerfen. Beim Shutdown: stoppen."""
+    """Beim Brain-Start: System-Seed-Regeln idempotent in DB schreiben,
+    Trigger-Background-Loop anwerfen. Beim Shutdown: Loop stoppen."""
+    try:
+        result = seed_rules_mod.apply(store(), embedder())
+        logger.info("Lifespan: seed_rules angewendet (%s)", result)
+    except Exception as exc:
+        logger.exception("Lifespan: seed_rules fehlgeschlagen — Brain startet trotzdem (%s)", exc)
     task = asyncio.create_task(background_mod.run_loop(agent))
     logger.info("Lifespan: Trigger-Loop gestartet")
     try:
@@ -750,6 +757,7 @@ class SkillCreate(BaseModel):
     requires: dict = Field(default_factory=dict)
     pip_packages: list = Field(default_factory=list)
     author: str = "stefan"
+    config_schema: list = Field(default_factory=list)
 
 
 class SkillRun(BaseModel):
@@ -762,6 +770,18 @@ class SkillPatch(BaseModel):
     description: str | None = None
     active: bool | None = None
     args: list | None = None
+    entry_code: str | None = None
+    readme: str | None = None
+    pip_packages: list | None = None
+    config_schema: list | None = None
+
+
+class SkillConfigSet(BaseModel):
+    values: dict
+
+
+class SkillRollback(BaseModel):
+    version_id: str
 
 
 @app.get("/skills/list")
@@ -778,6 +798,32 @@ def skills_get(name: str):
     return {"manifest": m, "readme": readme}
 
 
+class SkillScaffold(BaseModel):
+    name: str
+    template: str  # oauth-api | apikey-api | file-process
+    params: dict = Field(default_factory=dict)
+    author: str = "stefan"
+
+
+@app.get("/skills/templates")
+def skills_templates_list():
+    """Liste der verfuegbaren Templates — fuer UI und Dokumentation."""
+    import skill_templates as st
+    return {"templates": st.list_templates()}
+
+
+@app.post("/skills/scaffold")
+def skills_scaffold(body: SkillScaffold):
+    """Baut einen Skill aus einem Template (oauth-api / apikey-api / file-process)."""
+    try:
+        return skills_mod.scaffold_skill(
+            name=body.name, template=body.template,
+            params=body.params, author=body.author,
+        )
+    except ValueError as exc:
+        raise HTTPException(400, str(exc))
+
+
 @app.post("/skills/create")
 def skills_create(body: SkillCreate):
     try:
@@ -791,6 +837,7 @@ def skills_create(body: SkillCreate):
             requires=body.requires,
             pip_packages=body.pip_packages,
             author=body.author,
+            config_schema=body.config_schema,
         )
     except ValueError as exc:
         raise HTTPException(400, str(exc))
@@ -827,6 +874,57 @@ def skills_logs(name: str, limit: int = 50):
     return {"logs": skills_mod.list_logs(name, limit=limit)}
 
 
+# ── Skill-Configs (P3): statische Werte (API-Keys etc.) je Skill ───
+
+@app.get("/skills/{name}/config")
+def skills_config_get(name: str):
+    """Liefert config_schema + aktuelle Werte (secret-Felder gemaskt mit
+    '***SET***')."""
+    manifest = skills_mod.read_manifest(name)
+    if manifest is None:
+        raise HTTPException(404, f"Skill '{name}' nicht gefunden")
+    return {
+        "schema": manifest.get("config_schema") or [],
+        "values": skills_mod.get_skill_config_masked(name),
+    }
+
+
+@app.post("/skills/{name}/config")
+def skills_config_set(name: str, body: SkillConfigSet):
+    """Setzt Config-Werte (komplett ueberschreibend). Werte greifen ab dem
+    naechsten skill_run. Secret-Felder werden in der Antwort gemaskt."""
+    manifest = skills_mod.read_manifest(name)
+    if manifest is None:
+        raise HTTPException(404, f"Skill '{name}' nicht gefunden")
+    skills_mod.set_skill_config(name, body.values)
+    return {"ok": True, "values": skills_mod.get_skill_config_masked(name)}
+
+
+# ── Skill-Versions (P4): rollback ──────────────────────────────────
+
+@app.get("/skills/{name}/versions")
+def skills_versions_list(name: str):
+    if skills_mod.read_manifest(name) is None:
+        raise HTTPException(404, f"Skill '{name}' nicht gefunden")
+    return {"versions": skills_mod.list_skill_versions(name)}
+
+
+@app.post("/skills/{name}/rollback")
+def skills_rollback(name: str, body: SkillRollback):
+    try:
+        return skills_mod.rollback_skill(name, body.version_id)
+    except ValueError as exc:
+        raise HTTPException(404, str(exc))
+
+
+@app.delete("/skills/{name}/versions/{version_id}")
+def skills_versions_delete(name: str, version_id: str):
+    try:
+        return skills_mod.delete_skill_version(name, version_id)
+    except ValueError as exc:
+        raise HTTPException(404, str(exc))
+
+
 @app.get("/skills/{name}/export")
 def skills_export(name: str):
     try:
@@ -932,6 +1030,26 @@ async def oauth_revoke_endpoint(service: str):
     return {"ok": oauth_mod.revoke(service)}
 
 
+@app.get("/oauth/{service}/token")
+async def oauth_token_endpoint(service: str):
+    """Liefert das aktuelle access_token fuer einen Service (mit Auto-Refresh
+    wenn < 60s Restzeit). Nur fuer interne Skill-Aufrufe gedacht — Skills
+    sollen NIEMALS hardcoded client_secrets haben, sondern dieses Endpoint
+    pollen. Antwort: {access_token, expires_at, expires_in_sec}.
+    Bei nicht-autorisiert: 401 mit klarer Message."""
+    try:
+        rec = oauth_mod.get_token(service)
+    except RuntimeError as exc:
+        raise HTTPException(401, str(exc))
+    expires_at = int(rec.get("expires_at") or 0)
+    import time as _t
+    return {
+        "access_token": rec.get("access_token"),
+        "expires_at": expires_at,
+        "expires_in_sec": max(0, expires_at - int(_t.time())),
+    }
+
+
 class OAuthAuthorizeIn(BaseModel):
     service: str
     scopes: Optional[List[str]] = None

aria-brain/prompts.py

@@ -340,12 +340,18 @@ def build_system_prompt(
     oauth_callback_host: str = "",
     oauth_callback_port: str = "443",
     oauth_callback_tls: bool = True,
+    api_heuristic_section: str = "",
 ) -> str:
     """Kompletter System-Prompt: Hot + Cold + Skills + Triggers + FLUX + OAuth."""
     parts = [build_hot_memory_section(pinned), "", build_time_section()]
     if skills:
         parts.append("")
         parts.append(build_skills_section(skills))
+    if api_heuristic_section:
+        # Direkt nach Skills weil thematisch verwandt ("welche Skills gibt's, "
+        # welche Skills FEHLEN")
+        parts.append("")
+        parts.append(api_heuristic_section)
     if condition_vars:
         parts.append("")
         parts.append(build_triggers_section(triggers or [], condition_vars, condition_funcs))

aria-brain/seed_rules.py

@@ -0,0 +1,323 @@
+"""
+System-Seed-Regeln — werden bei jedem Brain-Boot idempotent in die
+Vector-DB geschrieben (pinned, source="seed").
+
+Im Gegensatz zu aria-data/brain-import/ (User-Saatgut, manuell via
+Diagnostic-Klick migriert) ist das hier System-Regeln, die zum Brain-Code
+gehoeren und mit jedem Deploy ausgerollt werden.
+
+Idempotenz: Punkte mit gleicher `migration_key` werden vor dem Schreiben
+geloescht. Editieren = Zeile aendern, Brain neu starten, fertig.
+"""
+
+from __future__ import annotations
+
+import logging
+import uuid
+from datetime import datetime, timezone
+from typing import List
+
+from memory import Embedder, VectorStore
+from memory.vector_store import COLLECTION
+from qdrant_client.http import models as qm
+
+logger = logging.getLogger(__name__)
+
+
+# Jede Regel = ein eigener Memory-Punkt. Klein halten, klar formulieren —
+# ARIA sieht das in jedem Chat-Turn als pinned Hot Memory.
+SEED_RULES: List[dict] = [
+    {
+        "migration_key": "seed/skill-rule/list-before-create",
+        "type": "rule",
+        "title": "Skill-Regel: skill_list vor skill_create",
+        "category": "skills",
+        "content": (
+            "Bevor du einen neuen Skill mit `skill_create` anlegst, ruf IMMER "
+            "zuerst `skill_list` auf. Schau dir die Namen und Descriptions an. "
+            "Wenn ein passender Skill existiert: verwende ihn oder verbessere "
+            "ihn mit `skill_update`. Lege keinen Duplikat-Skill an."
+        ),
+    },
+    {
+        "migration_key": "seed/skill-rule/no-version-suffix",
+        "type": "rule",
+        "title": "Skill-Regel: keine Versions-Suffixe im Namen",
+        "category": "skills",
+        "content": (
+            "Skill-Namen muessen permanent und beschreibend sein. NIEMALS "
+            "Suffixe wie `-v2`, `_v3`, `-new`, `-fixed`, `-aria`, `-ctl` "
+            "anhaengen, um eine neue Variante zu bauen. Wenn ein Skill kaputt "
+            "ist oder verbessert werden soll: `skill_update`. Versionsverwaltung "
+            "macht das System intern (Rollback ueber `skill_rollback`)."
+        ),
+    },
+    {
+        "migration_key": "seed/skill-rule/update-not-recreate",
+        "type": "rule",
+        "title": "Skill-Regel: kaputten Skill reparieren, nicht neu bauen",
+        "category": "skills",
+        "content": (
+            "Wenn ein vorhandener Skill nicht wie erwartet funktioniert, lies "
+            "zuerst Code + Logs (`skill_get`, `skill_logs`). Repariere ihn dann "
+            "mit `skill_update` (entry_code, readme oder pip_packages patchen). "
+            "Baue NIEMALS einen zweiten Skill mit aehnlichem Namen — das gibt "
+            "Skill-Friedhof und Stefan muss aufraeumen."
+        ),
+    },
+    {
+        "migration_key": "seed/skill-rule/no-hardcoded-credentials",
+        "type": "rule",
+        "title": "Skill-Regel: keine hardcoded Credentials",
+        "category": "skills",
+        "content": (
+            "Schreibe NIEMALS API-Keys, Tokens, Passwoerter, client_id oder "
+            "client_secret direkt in den Skill-Code. Fuer OAuth-Services "
+            "(Spotify, Google, GitHub etc.) nutze das Brain-Tool "
+            "`oauth_get_token('<service>')` — das macht Auto-Refresh und "
+            "haelt den Token frisch. Stefan muss sich sonst alle 60 Minuten "
+            "manuell neu einloggen, das nervt."
+        ),
+    },
+    {
+        "migration_key": "seed/skill-rule/config-schema-for-settings",
+        "type": "rule",
+        "title": "Skill-Regel: konfigurierbare Werte ueber config_schema",
+        "category": "skills",
+        "content": (
+            "Wenn dein Skill konfigurierbare Werte braucht (User-IDs, "
+            "Default-Geraete, Endpoints, nicht-OAuth-API-Keys), deklariere "
+            "sie im `config_schema`-Feld der skill.json. Stefan setzt sie "
+            "dann in der Diagnostic-UI; der Skill bekommt die Werte zur "
+            "Laufzeit als Environment-Variable `CFG_<NAME>`. NICHT als "
+            "Argument, NICHT hardcoded."
+        ),
+    },
+    {
+        "migration_key": "seed/skill-rule/brain-internal-url",
+        "type": "rule",
+        "title": "Skill-Regel: BRAIN_INTERNAL_URL ist deine Brain-Schnittstelle",
+        "category": "skills",
+        "content": (
+            "Jeder Skill bekommt die ENV-Variable BRAIN_INTERNAL_URL "
+            "(Default http://localhost:8080). Damit kann der Skill das Brain "
+            "aufrufen — kein hardcoden noetig:\n"
+            "  - GET {BRAIN_INTERNAL_URL}/oauth/<service>/token  -> access_token "
+            "(mit Auto-Refresh) fuer jeden OAuth-Service\n"
+            "  - GET {BRAIN_INTERNAL_URL}/memory/search?q=...&k=5  -> "
+            "Stefans Memories semantisch durchsuchen\n"
+            "  - GET {BRAIN_INTERNAL_URL}/memory/pinned  -> Hot Memory (Identitaet, Regeln)\n"
+            "  - GET {BRAIN_INTERNAL_URL}/skills/list  -> verfuegbare Skills\n"
+            "Mehr Endpoints siehe Brain main.py. Lies die URL IMMER aus "
+            "os.environ['BRAIN_INTERNAL_URL'] — hardcoden waere kaputt sobald "
+            "der Port wechselt. Beispiel: ein Wetter-Skill kann Stefans "
+            "Standort per /memory/search holen statt ihn als Arg zu erwarten."
+        ),
+    },
+    {
+        "migration_key": "seed/skill-rule/oauth-reauth-reflex",
+        "type": "rule",
+        "title": "Skill-Regel: OAuth-Re-Auth-Reflex (Refresh statt Re-Login)",
+        "category": "skills",
+        "content": (
+            "Wenn ein API-Call gegen einen OAuth-Service 401 / 'unauthorized' / "
+            "'token expired' zurueckgibt: RUFE ZUERST "
+            "`oauth_get_token('<service>')`. Brain holt entweder den noch "
+            "gueltigen Token oder refresht ihn automatisch ueber den "
+            "gespeicherten refresh_token. In 99% der Faelle reicht das.\n"
+            "\n"
+            "Nur wenn `oauth_get_token` selbst einen Fehler wirft "
+            "('refresh failed', 'no refresh_token', 'service nicht "
+            "konfiguriert'): DANN `oauth_authorize` und Stefan zum Login "
+            "schicken. Vorher NIEMALS.\n"
+            "\n"
+            "Anti-Pattern (Stefan musste so 3x manuell einloggen weil ich "
+            "das falsch gemacht hatte): bei jedem 401 reflexartig "
+            "oauth_authorize zu rufen. Das ist das aergerlichste was Du "
+            "ihm antun kannst — er muss aus dem Auto raus, Handy "
+            "rauskramen, klicken. Refresh haendelt das Brain transparent, "
+            "nutze es."
+        ),
+    },
+    {
+        "migration_key": "seed/skill-rule/no-skill-drift",
+        "type": "rule",
+        "title": "Skill-Regel: kein Drift vom Skill zu Ad-hoc-Bash",
+        "category": "skills",
+        "content": (
+            "Wenn ein bestehender Skill ein Problem hat (kaputter Output, "
+            "fehlender Feature-Wunsch, Setup-Error): lies `skill_logs` und "
+            "`skill_get`, finde das Problem, fixe es mit `skill_update`. "
+            "\n"
+            "ABSOLUT VERBOTEN: 'ich lass den Code jetzt einfach direkt auf "
+            "der VM laufen' / direkt Bash-curl-Befehle ausfuehren statt "
+            "den Skill anzufassen. Das macht den Skill zur Karteileiche "
+            "und beim naechsten Mal hast Du wieder nichts. Stefan kann "
+            "dann auch nichts wiederverwenden (Triggers, App-UI, Logs).\n"
+            "\n"
+            "Auch nicht: 'ich baue dir einen Skill' SAGEN ohne tatsaechlich "
+            "`skill_create` zu rufen. Stefan checkt die Skill-Liste, und "
+            "wenn er nichts findet, glaubt er dir nie wieder. Wenn Du es "
+            "sagst, MACH es. Wenn es Probleme gibt (anti-Friedhof-Check, "
+            "Setup-Error): sag das ehrlich statt zu halluzinieren."
+        ),
+    },
+    {
+        "migration_key": "seed/architecture/runtime-topology",
+        "type": "rule",
+        "title": "Architektur: wo Du als ARIA tatsaechlich laufst",
+        "category": "architektur",
+        "content": (
+            "WICHTIG fuer jeden Bash-Reflex: Du bist die `claude` CLI als "
+            "Subprocess IM `aria-proxy` Container (node:22-alpine). NICHT "
+            "im aria-brain. Konsequenzen:\n"
+            "\n"
+            "  - `python3` / `python` / `jq` sind NICHT installiert. Alpine "
+            "ist minimal. Nutze nur: curl, sed, grep, awk, sh — oder das "
+            "richtige Tool statt Bash.\n"
+            "  - `/data/skills/` existiert NUR im aria-brain Container. "
+            "Du kannst Skills NICHT ueber Bash inspizieren oder starten. "
+            "Skills laeufst Du als Brain-Tool: `run_<skill_name>` "
+            "(z.B. `run_yt_dlp_download`). `skill_list` zeigt verfuegbare.\n"
+            "  - `localhost` in Deinem Bash heisst aria-proxy, NICHT "
+            "aria-brain. Brain ist via Docker-Net erreichbar als "
+            "`http://aria-brain:8080` (oder Alias `http://brain:8080`). "
+            "ABER: in 99% der Faelle willst Du das gar nicht — nutze die "
+            "Brain-Tools direkt (`oauth_get_token`, `memory_search`, …), "
+            "die sind eine Tool-Call-Ebene hoeher und schneller.\n"
+            "  - `BRAIN_INTERNAL_URL` ist NUR in laufenden Skills gesetzt, "
+            "NICHT in Deinem Bash-Env. Wenn Du `env | grep BRAIN` machst "
+            "und nichts findest: das ist normal, Du bist hier nicht in "
+            "einem Skill.\n"
+            "\n"
+            "Was Du DOCH von hier aus kannst:\n"
+            "  - Per `ssh aria@host` zur VM-Host wechseln — der ed25519-"
+            "Key liegt unter /root/.ssh/. Dort bist Du `aria` mit sudo "
+            "und voller Linux-Power. Fuer Pentest, Admin, komplexe Tasks "
+            "der richtige Weg.\n"
+            "  - Externe APIs direkt anpingen (Spotify, GitHub etc.) — "
+            "curl reicht. Token holst Du Dir per Brain-Tool "
+            "`oauth_get_token('<service>')` und packst ihn in den curl-"
+            "Header. Aber: das ist Ad-hoc. Fuer wiederkehrendes baust Du "
+            "einen Skill (siehe no-skill-drift Regel).\n"
+            "\n"
+            "Anti-Pattern (47 Sekunden Stefan-Lebenszeit, am 29.05.2026): "
+            "12 Bash-Versuche mit python3/python/jq/lokales /data/skills "
+            "→ alles fehlte. Erst nach 9 Tries kapiert dass `localhost` "
+            "der falsche Host ist. Bei jedem Bash-Call gegen 'lokale' "
+            "Brain-Resources: erst denken, sonst Brain-Tool nehmen."
+        ),
+    },
+    {
+        "migration_key": "seed/skill-rule/scaffold-reflex",
+        "type": "rule",
+        "title": "Skill-Regel: skill_scaffold-Reflex (mit Cross-Session-Counter)",
+        "category": "skills",
+        "content": (
+            "Brain trackt server-side wie oft Du in den letzten 24h dieselbe "
+            "externe API per Bash-curl angerufen hast (Cross-Session-Counter, "
+            "siehe '## API-Heuristik'-Block im System-Prompt). Sobald da "
+            "ein Eintrag steht: das ist KEINE Empfehlung sondern eine "
+            "Aufforderung. RUFE als ALLERERSTES `skill_scaffold` mit dem "
+            "vorgeschlagenen Template und params auf, BEVOR Du wieder Bash-"
+            "curl machst. Dann nutze den frischen Skill via `run_<name>`.\n"
+            "\n"
+            "Warum: jede Chat-Anfrage ist eine eigene Claude-CLI-Session — "
+            "Du siehst nicht dass Du gestern auch schon 10x Spotify gecurled "
+            "hast. Der API-Heuristik-Block ist Dein Cross-Session-Gedaechtnis. "
+            "Wenn er leer ist: alles OK, weitermachen. Wenn nicht: scaffolden.\n"
+            "\n"
+            "Templates (ausfuehrliche Doku siehe skill_scaffold-Tool):\n"
+            "  - **oauth-api**: Spotify/GitHub/Reddit/Google/Discord. Token "
+            "kommt vom Brain mit Auto-Refresh.\n"
+            "  - **apikey-api**: OpenWeather/OpenAI/Twilio. Key landet im "
+            "config_schema → CFG_<NAME> ENV. Stefan setzt ihn in Diagnostic.\n"
+            "  - **file-process**: PDF/Bild/JSON-Wandler. process()-Stub, "
+            "danach `skill_update` mit echtem Code.\n"
+            "\n"
+            "Belohnung konkret: ein Spotify-Skill macht 'welches lied laeuft' "
+            "in 1 Tool-Call (~3s) statt 3-5 Bash-Roundtrips (~13-20s). Stefan "
+            "merkt das sofort. Ein einmaliger Scaffold-Aufwand spart hunderte "
+            "Bash-Roundtrips."
+        ),
+    },
+    {
+        "migration_key": "seed/skill-rule/external-api-auth-strategy",
+        "type": "rule",
+        "title": "Skill-Regel: Auth-Strategie fuer externe APIs",
+        "category": "skills",
+        "content": (
+            "Wenn dein Skill mit einer externen API redet (Spotify, Google, "
+            "Reddit, GitHub, OpenWeather, OpenAI, …), entscheide IMMER bewusst "
+            "die Auth-Strategie in dieser Reihenfolge:\n"
+            "  1. OAuth2? (Spotify, Google, GitHub, Reddit, Discord, Twitch, "
+            "Microsoft, …) -> nutze `oauth_register_provider` falls der "
+            "Provider noch nicht da ist, dann `oauth_authorize` fuer "
+            "Initial-Login. Im Skill: Token via "
+            "BRAIN_INTERNAL_URL/oauth/<service>/token holen — Brain macht "
+            "Auto-Refresh, Stefan muss sich nicht alle 60min neu einloggen.\n"
+            "  2. Statischer API-Key / Bearer-Token? (OpenWeather, OpenAI, "
+            "Twilio, SendGrid, …) -> in skill.json `config_schema` "
+            "deklarieren. Stefan setzt den Wert in Diagnostic, Skill bekommt "
+            "ihn als CFG_<NAME> ENV.\n"
+            "  3. NIEMALS hardcoden — egal wie 'temporaer' es ist.\n"
+            "Wenn Du nicht sicher bist welche Strategie ein Service nutzt: "
+            "in der API-Doku des Services nachsehen ('OAuth' oder "
+            "'API Key' im Auth-Kapitel). Nicht raten."
+        ),
+    },
+]
+
+
+def apply(store: VectorStore, embedder: Embedder) -> dict:
+    """Schreibt alle SEED_RULES idempotent in die DB.
+
+    Vorgehen: erst alle Punkte mit `source=seed` UND passender migration_key
+    loeschen, dann frisch upserten. So koennen Regeln editiert/entfernt
+    werden indem die SEED_RULES-Liste angepasst wird.
+    """
+    if not SEED_RULES:
+        return {"written": 0}
+
+    migration_keys = [r["migration_key"] for r in SEED_RULES]
+
+    # Alte Versionen entfernen (nur die mit unserer migration_key — andere
+    # source=seed Punkte aus zukuenftigen seed-Files sind sicher)
+    try:
+        store.client.delete(
+            collection_name=COLLECTION,
+            points_selector=qm.FilterSelector(filter=qm.Filter(must=[
+                qm.FieldCondition(key="migration_key", match=qm.MatchAny(any=migration_keys))
+            ])),
+        )
+    except Exception as exc:
+        logger.warning("seed_rules: delete-by-migration_key fehlgeschlagen (%s) — wahrscheinlich erster Run", exc)
+
+    # Frisch einbetten + schreiben
+    texts = [r["content"] for r in SEED_RULES]
+    vectors = embedder.embed_batch(texts)
+
+    now = datetime.now(timezone.utc).isoformat()
+    written = 0
+    for rule, vec in zip(SEED_RULES, vectors):
+        payload = {
+            "type": rule["type"],
+            "title": rule["title"],
+            "content": rule["content"],
+            "pinned": True,
+            "category": rule.get("category", ""),
+            "source": "seed",
+            "tags": [],
+            "created_at": now,
+            "updated_at": now,
+            "migration_key": rule["migration_key"],
+            "attachments": [],
+        }
+        store.client.upsert(
+            collection_name=COLLECTION,
+            points=[qm.PointStruct(id=str(uuid.uuid4()), vector=vec, payload=payload)],
+        )
+        written += 1
+
+    logger.info("seed_rules: %d Regeln in DB geschrieben", written)
+    return {"written": written, "keys": migration_keys}

aria-brain/skill_templates.py

@@ -0,0 +1,460 @@
+"""
+Skill-Templates — Boilerplate fuer haeufige Skill-Pattern.
+
+ARIA muss nicht jedes Mal einen kompletten Python-Skill aus dem Nichts
+generieren. Sie ruft `skill_scaffold(name, template, params)`, Brain
+expandiert das Template und legt den Skill an. Hoehere Skill-Adoption
+weil niedrigere Bauh-Huerde.
+
+Templates sind ueber Token-Replacement parametrisiert (kein f-String —
+das wuerde mit dem skill-internen Python-Code kollidieren).
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Callable
+
+
+# ── Hilfsfunktion ────────────────────────────────────────────────────
+
+def _replace_tokens(s: str, tokens: dict) -> str:
+    """Ersetzt {{TOKEN}}-Platzhalter durch Werte. Robust gegen f-String-
+    Konflikte im Python-Code des Skills."""
+    out = s
+    for k, v in tokens.items():
+        out = out.replace("{{" + k + "}}", str(v))
+    return out
+
+
+# ── Template 1: oauth-api ────────────────────────────────────────────
+# Wrappt eine OAuth2-API. Token kommt aus dem Brain (Auto-Refresh).
+
+_OAUTH_API_CODE = '''"""
+{{NAME}} — OAuth2-API-Wrapper fuer {{SERVICE}}.
+
+Holt Token vom Brain (Auto-Refresh) und ruft HTTP-Endpoints der {{SERVICE}}-API.
+Keine hardcoded Credentials — alles ueber das zentrale OAuth-System.
+
+Args (alle als ENV ARG_<NAME>):
+  ARG_METHOD   = GET | POST | PUT | DELETE | PATCH (Default GET)
+  ARG_PATH     = API-Pfad inkl. Query-String (z.B. /v1/me/player)
+  ARG_BODY     = JSON-Body als String (optional, fuer POST/PUT/PATCH)
+  ARG_BASE_URL = Override der Default-Base-URL (optional)
+
+Exit-Codes: 0 ok, 1 Fehler, 2 nicht autorisiert (Re-Login noetig)
+"""
+import json
+import os
+import sys
+import urllib.error
+import urllib.parse
+import urllib.request
+
+BRAIN_URL = os.environ.get("BRAIN_INTERNAL_URL", "http://localhost:8080")
+DEFAULT_BASE_URL = "{{DEFAULT_BASE_URL}}"
+SERVICE = "{{SERVICE}}"
+
+
+def get_token() -> str:
+    try:
+        with urllib.request.urlopen(
+            f"{BRAIN_URL}/oauth/{SERVICE}/token", timeout=10,
+        ) as r:
+            return json.loads(r.read())["access_token"]
+    except urllib.error.HTTPError as e:
+        body = e.read().decode("utf-8", "replace")[:400]
+        if e.code == 401:
+            print(f"NICHT AUTORISIERT: {SERVICE}-Token abgelaufen oder nie gesetzt. "
+                  f"ARIA-Tool 'oauth_authorize' nutzen. Details: {body}", file=sys.stderr)
+            sys.exit(2)
+        print(f"Token-Holen fehlgeschlagen: HTTP {e.code} - {body}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"Token-Holen fehlgeschlagen: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def main() -> int:
+    method = (os.environ.get("ARG_METHOD") or "GET").upper()
+    path = (os.environ.get("ARG_PATH") or "").strip()
+    body_raw = (os.environ.get("ARG_BODY") or "").strip()
+    base_url = (os.environ.get("ARG_BASE_URL") or DEFAULT_BASE_URL).rstrip("/")
+    if not path:
+        print(json.dumps({"ok": False, "error": "ARG_PATH erforderlich"}), file=sys.stderr)
+        return 1
+    if not path.startswith("/"):
+        path = "/" + path
+    url = base_url + path
+    headers = {"Authorization": f"Bearer {get_token()}"}
+    data = None
+    if body_raw and method in ("POST", "PUT", "PATCH"):
+        data = body_raw.encode("utf-8")
+        headers["Content-Type"] = "application/json"
+    req = urllib.request.Request(url, data=data, method=method, headers=headers)
+    try:
+        with urllib.request.urlopen(req, timeout=20) as r:
+            txt = r.read().decode("utf-8")
+            parsed = json.loads(txt) if txt and txt[:1] in "[{" else txt
+            print(json.dumps({"ok": True, "status": r.status, "data": parsed},
+                             ensure_ascii=False, indent=2))
+            return 0
+    except urllib.error.HTTPError as e:
+        txt = e.read().decode("utf-8", "replace")
+        try: parsed = json.loads(txt)
+        except Exception: parsed = txt[:800]
+        print(json.dumps({"ok": False, "status": e.code, "error": parsed},
+                         ensure_ascii=False, indent=2))
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+'''
+
+_OAUTH_API_README = '''# {{NAME}}
+
+OAuth2-API-Wrapper fuer **{{SERVICE}}**. Generiert via `skill_scaffold(template="oauth-api")`.
+
+Holt den Token vom Brain (Auto-Refresh) und macht beliebige HTTP-Calls gegen
+die {{SERVICE}}-API. Keine hardcoded Credentials — die Auth-Pipeline laeuft
+zentral ueber das Brain-OAuth-System.
+
+## Voraussetzung
+
+- OAuth-App fuer **{{SERVICE}}** im Brain registriert (Diagnostic → OAuth-Apps → client_id + client_secret eintragen)
+- Einmaliges `oauth_authorize {{SERVICE}}` zum Initial-Login
+
+## Args
+
+| Name | Default | Beschreibung |
+|------|---------|--------------|
+| method | GET | HTTP-Methode (GET/POST/PUT/DELETE/PATCH) |
+| path | - | API-Pfad mit Query-String (z.B. `/v1/me/player`) |
+| body | - | JSON-Body fuer POST/PUT/PATCH |
+| base_url | {{DEFAULT_BASE_URL}} | Override der Base-URL falls Sub-API |
+
+## Beispiele
+
+```
+method=GET path=/v1/me/player                              # Was laeuft?
+method=POST path=/v1/me/player/next                        # Skip
+method=PUT path=/v1/me/player/volume?volume_percent=40     # Volume 40
+```
+
+Antwort: `{ok, status, data}` als JSON. Bei Fehler `ok=false`.
+'''
+
+
+def _oauth_api(name: str, params: dict) -> dict:
+    service = (params.get("service") or name).strip().lower()
+    default_base_url = params.get("base_url") or f"https://api.{service}.com"
+    tokens = {
+        "NAME": name,
+        "SERVICE": service,
+        "DEFAULT_BASE_URL": default_base_url,
+    }
+    return {
+        "entry_code": _replace_tokens(_OAUTH_API_CODE, tokens),
+        "readme": _replace_tokens(_OAUTH_API_README, tokens),
+        "pip_packages": [],
+        "args": [
+            {"name": "method", "type": "string", "required": False,
+             "description": "HTTP-Methode (Default GET)"},
+            {"name": "path", "type": "string", "required": True,
+             "description": "API-Pfad inkl. Query-String, z.B. /v1/me/player"},
+            {"name": "body", "type": "string", "required": False,
+             "description": "JSON-Body fuer POST/PUT/PATCH"},
+            {"name": "base_url", "type": "string", "required": False,
+             "description": f"Override der Base-URL (Default {default_base_url})"},
+        ],
+        "config_schema": [],
+        "description": f"OAuth2-API-Wrapper fuer {service}. Token kommt vom Brain (Auto-Refresh).",
+    }
+
+
+# ── Template 2: apikey-api ───────────────────────────────────────────
+# Wrappt eine API die mit statischem API-Key/Bearer-Token arbeitet.
+# Key liegt in skill.json::config_schema und wird via CFG_<KEY> ENV
+# durchgereicht — kein hardcoden, Stefan setzt's in Diagnostic.
+
+_APIKEY_API_CODE = '''"""
+{{NAME}} — API-Wrapper fuer {{API_NAME}} mit statischem Key.
+
+Schluessel kommt aus dem Skill-Config (CFG_{{KEY_ENV}}) — Stefan setzt
+ihn im Diagnostic-UI bzw. App, NICHT hardcoded.
+
+Args:
+  ARG_METHOD   = GET | POST | PUT | DELETE (Default GET)
+  ARG_PATH     = API-Pfad inkl. Query-String
+  ARG_BODY     = JSON-Body (optional)
+  ARG_BASE_URL = Override der Default-Base-URL
+
+Exit-Codes: 0 ok, 1 Fehler, 2 Key nicht gesetzt
+"""
+import json
+import os
+import sys
+import urllib.error
+import urllib.request
+
+DEFAULT_BASE_URL = "{{DEFAULT_BASE_URL}}"
+AUTH_HEADER = "{{AUTH_HEADER}}"           # z.B. "Authorization" oder "X-Api-Key"
+AUTH_PREFIX = "{{AUTH_PREFIX}}"           # z.B. "Bearer " oder leer
+
+
+def main() -> int:
+    key = os.environ.get("CFG_{{KEY_ENV}}", "").strip()
+    if not key:
+        print(json.dumps({"ok": False,
+                          "error": "API-Key nicht gesetzt — in Diagnostic Skill-Config '{{KEY_ENV}}' eintragen"}),
+              file=sys.stderr)
+        return 2
+    method = (os.environ.get("ARG_METHOD") or "GET").upper()
+    path = (os.environ.get("ARG_PATH") or "").strip()
+    body_raw = (os.environ.get("ARG_BODY") or "").strip()
+    base_url = (os.environ.get("ARG_BASE_URL") or DEFAULT_BASE_URL).rstrip("/")
+    if not path:
+        print(json.dumps({"ok": False, "error": "ARG_PATH erforderlich"}), file=sys.stderr)
+        return 1
+    if not path.startswith("/"):
+        path = "/" + path
+    url = base_url + path
+    headers = {AUTH_HEADER: f"{AUTH_PREFIX}{key}"}
+    data = None
+    if body_raw and method in ("POST", "PUT", "PATCH"):
+        data = body_raw.encode("utf-8")
+        headers["Content-Type"] = "application/json"
+    req = urllib.request.Request(url, data=data, method=method, headers=headers)
+    try:
+        with urllib.request.urlopen(req, timeout=20) as r:
+            txt = r.read().decode("utf-8")
+            parsed = json.loads(txt) if txt and txt[:1] in "[{" else txt
+            print(json.dumps({"ok": True, "status": r.status, "data": parsed},
+                             ensure_ascii=False, indent=2))
+            return 0
+    except urllib.error.HTTPError as e:
+        txt = e.read().decode("utf-8", "replace")
+        try: parsed = json.loads(txt)
+        except Exception: parsed = txt[:800]
+        print(json.dumps({"ok": False, "status": e.code, "error": parsed},
+                         ensure_ascii=False, indent=2))
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+'''
+
+_APIKEY_API_README = '''# {{NAME}}
+
+API-Wrapper fuer **{{API_NAME}}** mit statischem API-Key. Generiert via
+`skill_scaffold(template="apikey-api")`.
+
+Schluessel ist NICHT im Code, sondern im Skill-Config (`CFG_{{KEY_ENV}}`).
+Stefan setzt ihn in Diagnostic → Skills → Detail → Konfiguration.
+
+## Args
+
+| Name | Default | Beschreibung |
+|------|---------|--------------|
+| method | GET | HTTP-Methode |
+| path | - | API-Pfad mit Query-String |
+| body | - | JSON-Body |
+| base_url | {{DEFAULT_BASE_URL}} | Override |
+
+## Config (in Diagnostic einstellen)
+
+| Feld | Typ | Beschreibung |
+|------|-----|--------------|
+| {{KEY_ENV}} | password | API-Key fuer {{API_NAME}} |
+'''
+
+
+def _apikey_api(name: str, params: dict) -> dict:
+    api_name = params.get("api_name") or name
+    key_env = (params.get("key_env") or "API_KEY").upper()
+    # safe: nur Buchstaben/Zahlen/Underscore
+    key_env = re.sub(r"[^A-Z0-9_]", "_", key_env)
+    auth_header = params.get("auth_header") or "Authorization"
+    auth_prefix = params.get("auth_prefix") if "auth_prefix" in params else "Bearer "
+    default_base_url = params.get("base_url") or "https://api.example.com"
+    tokens = {
+        "NAME": name,
+        "API_NAME": api_name,
+        "KEY_ENV": key_env,
+        "AUTH_HEADER": auth_header,
+        "AUTH_PREFIX": auth_prefix,
+        "DEFAULT_BASE_URL": default_base_url,
+    }
+    return {
+        "entry_code": _replace_tokens(_APIKEY_API_CODE, tokens),
+        "readme": _replace_tokens(_APIKEY_API_README, tokens),
+        "pip_packages": [],
+        "args": [
+            {"name": "method", "type": "string", "required": False,
+             "description": "HTTP-Methode (Default GET)"},
+            {"name": "path", "type": "string", "required": True,
+             "description": "API-Pfad inkl. Query-String"},
+            {"name": "body", "type": "string", "required": False,
+             "description": "JSON-Body fuer POST/PUT"},
+            {"name": "base_url", "type": "string", "required": False,
+             "description": "Override der Base-URL"},
+        ],
+        "config_schema": [
+            {"name": key_env, "type": "password", "label": f"{api_name} API-Key",
+             "secret": True, "description": f"Persoenlicher API-Key fuer {api_name}"},
+        ],
+        "description": f"API-Wrapper fuer {api_name} (Key aus CFG_{key_env}).",
+    }
+
+
+# ── Template 3: file-process ─────────────────────────────────────────
+# Nimmt eine Datei aus /shared/uploads/, ruft eine User-Funktion drauf
+# auf, schreibt das Resultat nach /shared/uploads/. Skelett — ARIA fuellt
+# die `process()`-Funktion danach via skill_update mit dem echten Code.
+
+_FILE_PROCESS_CODE = '''"""
+{{NAME}} — File-Processing-Skelett.
+
+Liest eine Eingabe-Datei aus /shared/uploads/, ruft process() auf,
+schreibt Output zurueck nach /shared/uploads/.
+
+Args:
+  ARG_INPUT  = Pfad zur Eingabedatei (z.B. /shared/uploads/foo.pdf)
+  ARG_OUTPUT = Optional Pfad fuer Output (Default: <input>.{{OUTPUT_EXT}})
+
+ARIA-Hinweis: die process()-Funktion ist ein Stub — passe sie via
+skill_update an deine Aufgabe an. pip_packages bei Bedarf via
+skill_update ergaenzen (z.B. pypdf, Pillow, reportlab).
+"""
+import os
+import shutil
+import sys
+
+
+def process(input_path: str, output_path: str) -> None:
+    """Eigentlicher Verarbeitungs-Schritt. Hier kommt der Code rein."""
+    # STUB: kopiert die Datei einfach. ARIA: ueberschreibe diese Funktion.
+    shutil.copy(input_path, output_path)
+
+
+def main() -> int:
+    inp = (os.environ.get("ARG_INPUT") or "").strip()
+    if not inp:
+        print("FEHLER: ARG_INPUT erforderlich", file=sys.stderr)
+        return 1
+    if not os.path.exists(inp):
+        print(f"FEHLER: Eingabe nicht gefunden: {inp}", file=sys.stderr)
+        return 1
+    out = (os.environ.get("ARG_OUTPUT") or "").strip()
+    if not out:
+        base, _ = os.path.splitext(inp)
+        out = f"{base}.{{OUTPUT_EXT}}"
+    try:
+        process(inp, out)
+    except Exception as e:
+        print(f"FEHLER bei process(): {e}", file=sys.stderr)
+        return 1
+    print(out)  # stdout = Pfad zur Ausgabe-Datei, ARIA kann den dem User zurueckgeben
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+'''
+
+_FILE_PROCESS_README = '''# {{NAME}}
+
+File-Processing-Skelett (`skill_scaffold(template="file-process")`).
+
+Liest eine Datei aus `/shared/uploads/`, ruft die `process()`-Funktion auf,
+schreibt das Resultat zurueck. Die `process()`-Funktion ist initial ein
+Stub (kopiert nur) — ARIA passt sie via `skill_update` an die konkrete
+Aufgabe an.
+
+## Args
+
+| Name | Default | Beschreibung |
+|------|---------|--------------|
+| input | - | Eingabedatei (z.B. /shared/uploads/foo.pdf) |
+| output | `<input>.{{OUTPUT_EXT}}` | Ausgabepfad (optional) |
+
+stdout = Pfad zur erzeugten Datei → ARIA kann ihn dem User zurueckgeben.
+'''
+
+
+def _file_process(name: str, params: dict) -> dict:
+    output_ext = (params.get("output_ext") or "out").strip().lstrip(".")
+    output_ext = re.sub(r"[^a-zA-Z0-9]", "", output_ext) or "out"
+    tokens = {
+        "NAME": name,
+        "OUTPUT_EXT": output_ext,
+    }
+    return {
+        "entry_code": _replace_tokens(_FILE_PROCESS_CODE, tokens),
+        "readme": _replace_tokens(_FILE_PROCESS_README, tokens),
+        "pip_packages": [],
+        "args": [
+            {"name": "input", "type": "string", "required": True,
+             "description": "Eingabedatei (z.B. /shared/uploads/foo.pdf)"},
+            {"name": "output", "type": "string", "required": False,
+             "description": f"Output-Pfad (Default <input>.{output_ext})"},
+        ],
+        "config_schema": [],
+        "description": f"File-Processing-Skelett (Input → process() → Output.{output_ext}).",
+    }
+
+
+# ── Registry ────────────────────────────────────────────────────────
+
+TEMPLATES: dict[str, Callable[[str, dict], dict]] = {
+    "oauth-api": _oauth_api,
+    "apikey-api": _apikey_api,
+    "file-process": _file_process,
+}
+
+
+def list_templates() -> list[dict]:
+    """Liste aller verfuegbaren Templates mit Kurzbeschreibung — fuer UI/Tool-Doku."""
+    return [
+        {
+            "name": "oauth-api",
+            "description": "OAuth2-API-Wrapper (Spotify, GitHub, Reddit, Google, …). "
+                           "Token kommt vom Brain mit Auto-Refresh. Args: method/path/body.",
+            "params": ["service (str, OAuth-Service-Name)", "base_url (str, optional)"],
+        },
+        {
+            "name": "apikey-api",
+            "description": "API-Wrapper fuer Services mit statischem API-Key "
+                           "(OpenWeather, OpenAI, Twilio, …). Key liegt im Skill-Config "
+                           "und kommt als CFG_<NAME> ENV — kein hardcode.",
+            "params": ["api_name (str)", "key_env (str, ENV-Name fuer den Key)",
+                       "auth_header (str, default 'Authorization')",
+                       "auth_prefix (str, default 'Bearer ')",
+                       "base_url (str)"],
+        },
+        {
+            "name": "file-process",
+            "description": "Skelett fuer File-In/File-Out-Operationen "
+                           "(PDF konvertieren, Bild bearbeiten, JSON umformen). "
+                           "process()-Funktion ist Stub, ARIA fuellt sie via skill_update.",
+            "params": ["output_ext (str, Datei-Endung des Outputs)"],
+        },
+    ]
+
+
+def expand(name: str, template: str, params: dict | None = None) -> dict:
+    """Expandiert ein Template zu einem fertigen Skill-Spec.
+
+    Returns: dict mit entry_code / readme / pip_packages / args /
+             config_schema / description — direkt an create_skill weitergebbar.
+
+    Wirft ValueError wenn das Template nicht existiert.
+    """
+    fn = TEMPLATES.get(template)
+    if not fn:
+        raise ValueError(
+            f"Template '{template}' unbekannt. Verfuegbar: {sorted(TEMPLATES.keys())}"
+        )
+    return fn(name, params or {})

aria-brain/skills.py

@@ -47,9 +47,15 @@ logger = logging.getLogger(__name__)
 
 SKILLS_DIR = Path(os.environ.get("SKILLS_DIR", "/data/skills"))
 SHARED_UPLOADS = Path("/shared/uploads")
+SKILL_CONFIGS_FILE = Path(os.environ.get("SKILL_CONFIGS_FILE", "/shared/config/skill_configs.json"))
+
+# Beim Archivieren in versions/ ausgenommen (gross, regenerierbar, sind keine Sources)
+_VERSION_SKIP = {"venv", "logs", "versions", "__pycache__"}
 
 VALID_EXECUTIONS = {"local-venv", "local-bin", "bash"}
 NAME_RE = re.compile(r"^[a-zA-Z0-9_-]{2,60}$")
+# Anti-Skill-Friedhof: ARIAs Lieblings-Suffixe wenn sie statt updaten neu baut
+VERSION_SUFFIX_RE = re.compile(r"(?:[-_]v\d+|[-_](?:new|fixed|old|alt|copy|final|clean))$", re.I)
 
 
 def _now() -> str:
@@ -66,6 +72,44 @@ def _skill_dir(name: str) -> Path:
     return SKILLS_DIR / _safe_name(name)
 
 
+def _check_anti_graveyard(name: str) -> None:
+    """Verhindert klassische Skill-Friedhof-Patterns beim Anlegen.
+
+    Hard-Reject auf:
+    1. Versions-Suffixe (`-v2`, `_v3`, `-new`, `-fixed`, …) im Namen
+    2. Prefix-Kollision mit existierendem Skill (z.B. `spotify` existiert,
+       jemand will `spotify-aria` oder `spotify-ctl` anlegen)
+    """
+    if VERSION_SUFFIX_RE.search(name):
+        raise ValueError(
+            f"Skill-Name '{name}' enthaelt einen Versions-Suffix "
+            f"(-v2 / _v3 / -new / -fixed / -old / -alt / -copy / -final / -clean). "
+            f"Skills werden intern versioniert (skill_rollback). "
+            f"Waehle einen klaren Namen ohne Suffix oder nutze skill_update auf "
+            f"den bestehenden Skill."
+        )
+    if not SKILLS_DIR.exists():
+        return
+    existing = [p.name for p in SKILLS_DIR.iterdir() if p.is_dir()]
+    for ex in existing:
+        if ex == name:
+            continue  # wird spaeter mit "existiert bereits" abgefangen
+        # neuer Name verlaengert existierenden Stem: 'spotify' da, neu 'spotify-aria'
+        if name.startswith(ex + "-") or name.startswith(ex + "_"):
+            raise ValueError(
+                f"Skill-Name '{name}' kollidiert mit existierendem '{ex}'. "
+                f"Wenn Du '{ex}' verbessern willst: skill_update auf '{ex}'. "
+                f"Wenn es wirklich was anderes ist: waehle einen Namen ohne den "
+                f"Praefix '{ex}-' / '{ex}_'."
+            )
+        # neuer Name ist Kurzform eines existierenden: 'spotify-aria' da, neu 'spotify'
+        if ex.startswith(name + "-") or ex.startswith(name + "_"):
+            raise ValueError(
+                f"Es existiert bereits '{ex}' mit Praefix '{name}'. Pruefe ob '{ex}' "
+                f"das schon kann; wenn ja: skill_update auf '{ex}' oder Skill umbenennen."
+            )
+
+
 # ─── Listing ────────────────────────────────────────────────────────
 
 def list_skills(active_only: bool = False) -> list[dict]:
@@ -119,6 +163,7 @@ def create_skill(
     requires: Optional[dict] = None,
     pip_packages: Optional[list[str]] = None,
     author: str = "aria",
+    config_schema: Optional[list] = None,
 ) -> dict:
     """Legt einen neuen Skill an. Wirft ValueError bei ungueltigen Inputs.
 
@@ -128,6 +173,7 @@ def create_skill(
     name = _safe_name(name)
     if execution not in VALID_EXECUTIONS:
         raise ValueError(f"execution muss eines von {VALID_EXECUTIONS} sein")
+    _check_anti_graveyard(name)
     d = _skill_dir(name)
     if d.exists():
         raise ValueError(f"Skill '{name}' existiert bereits — erst loeschen oder updaten")
@@ -166,6 +212,8 @@ def create_skill(
         "use_count": 0,
         "version": "1.0",
         "author": author,
+        "config_schema": _normalize_config_schema(config_schema),
+        "version_history": [],
     }
     write_manifest(name, manifest)
 
@@ -184,6 +232,35 @@ def create_skill(
     return manifest
 
 
+def _normalize_config_schema(schema: Optional[list]) -> list:
+    """Filter + Normalisiert das config_schema. Erwartet Liste von Dicts mit
+    Pflichtfeld 'name'. Optional: label, type (string|number|boolean|password),
+    secret (bool), default, description."""
+    if not schema:
+        return []
+    out = []
+    for f in schema:
+        if not isinstance(f, dict):
+            continue
+        fname = (f.get("name") or "").strip()
+        if not re.match(r"^[a-zA-Z][a-zA-Z0-9_]{0,40}$", fname):
+            continue
+        ftype = (f.get("type") or "string").lower()
+        if ftype not in ("string", "number", "boolean", "password"):
+            ftype = "string"
+        # password impliziert secret=True
+        secret = bool(f.get("secret")) or ftype == "password"
+        out.append({
+            "name": fname,
+            "type": ftype,
+            "label": (f.get("label") or fname),
+            "secret": secret,
+            "description": (f.get("description") or "")[:300],
+            "default": f.get("default"),
+        })
+    return out
+
+
 def _setup_venv(skill_dir: Path, pip_packages: list[str]) -> None:
     venv = skill_dir / "venv"
     logger.info("venv erstellen: %s", venv)
@@ -206,10 +283,30 @@ def update_skill(name: str, patch: dict) -> dict:
     if manifest is None:
         raise ValueError(f"Skill '{name}' nicht gefunden")
     d = _skill_dir(name)
+
+    # Auto-Archive: wenn strukturelle Aenderung (Code/README/Deps/Schema), erst
+    # snapshot machen. So kann jeder skill_update zurueckgerollt werden.
+    structural = any(k in patch for k in ("entry_code", "readme", "pip_packages",
+                                          "config_schema", "args"))
+    if structural:
+        try:
+            archive_current_version(
+                name,
+                summary=patch.get("_change_summary") or ", ".join(
+                    sorted(k for k in patch.keys() if k != "_change_summary")
+                )[:200],
+            )
+        except Exception as exc:
+            logger.warning("update_skill: Auto-Archive %s fehlgeschlagen: %s", name, exc)
+        # nach archive_current_version manifest neu laden (version_history geupdatet)
+        manifest = read_manifest(name) or manifest
+
     allowed = {"description", "args", "requires", "active", "version", "entry"}
     for k, v in patch.items():
         if k in allowed:
             manifest[k] = v
+    if "config_schema" in patch:
+        manifest["config_schema"] = _normalize_config_schema(patch["config_schema"])
 
     # Code austauschen
     if "entry_code" in patch and patch["entry_code"]:
@@ -250,14 +347,268 @@ def update_skill(name: str, patch: dict) -> dict:
     return manifest
 
 
+def scaffold_skill(
+    name: str,
+    template: str,
+    params: Optional[dict] = None,
+    author: str = "aria",
+) -> dict:
+    """Baut einen Skill aus einem Template-Skelett. ARIA muss nicht jedes Mal
+    einen kompletten Python-Skill schreiben — sie waehlt ein Template und
+    optionale Parameter, Brain expandiert das zu fertigem Code.
+
+    Templates siehe `skill_templates.TEMPLATES`. Konkret:
+      - 'oauth-api' : params={service, base_url?}
+      - 'apikey-api': params={api_name, key_env, auth_header?, auth_prefix?, base_url?}
+      - 'file-process': params={output_ext?}
+
+    Wirft ValueError wenn Template unbekannt oder Name kollidiert.
+    Sonst: ruft intern create_skill mit den expandierten Feldern auf.
+    """
+    import skill_templates as _st
+    spec = _st.expand(name, template, params or {})
+    return create_skill(
+        name=name,
+        description=spec["description"],
+        execution="local-venv",
+        entry_code=spec["entry_code"],
+        readme=spec["readme"],
+        args=spec["args"],
+        pip_packages=spec["pip_packages"],
+        config_schema=spec["config_schema"],
+        author=author,
+    )
+
+
 def delete_skill(name: str) -> None:
     d = _skill_dir(name)
     if not d.exists():
         raise ValueError(f"Skill '{name}' nicht gefunden")
     shutil.rmtree(d)
+    # Configs auch raeumen — sonst Karteileiche in skill_configs.json
+    try:
+        all_cfg = _load_all_skill_configs()
+        if name in all_cfg:
+            all_cfg.pop(name)
+            _save_all_skill_configs(all_cfg)
+    except Exception:
+        pass
     logger.info("Skill geloescht: %s", name)
 
 
+# ─── Skill-Configs (statische Werte je Skill — API-Keys, IDs etc.) ──
+# Werte liegen zentral in /shared/config/skill_configs.json damit Stefan
+# sie im Diagnostic-UI editieren kann. Skill bekommt sie zur Laufzeit
+# als ENV `CFG_<UPPER_NAME>` — kein hardcoden im Code noetig.
+
+def _load_all_skill_configs() -> dict:
+    if not SKILL_CONFIGS_FILE.exists():
+        return {}
+    try:
+        return json.loads(SKILL_CONFIGS_FILE.read_text(encoding="utf-8"))
+    except Exception as exc:
+        logger.warning("skill_configs.json kaputt (%s) — leeres dict", exc)
+        return {}
+
+
+def _save_all_skill_configs(data: dict) -> None:
+    SKILL_CONFIGS_FILE.parent.mkdir(parents=True, exist_ok=True)
+    SKILL_CONFIGS_FILE.write_text(json.dumps(data, indent=2, ensure_ascii=False),
+                                  encoding="utf-8")
+
+
+def get_skill_config(name: str) -> dict:
+    """Liefert die rohen Config-Werte fuer einen Skill (ungemasked).
+    Wird intern beim run_skill genutzt um CFG_<NAME>-Env zu bauen."""
+    return _load_all_skill_configs().get(name, {})
+
+
+def set_skill_config(name: str, values: dict) -> dict:
+    """Speichert die Config-Werte fuer einen Skill (komplett ueberschreiben).
+    Werte landen sofort persistent; naechster run_skill nutzt sie."""
+    if not isinstance(values, dict):
+        raise ValueError("values muss ein Dict sein")
+    all_cfg = _load_all_skill_configs()
+    all_cfg[name] = values
+    _save_all_skill_configs(all_cfg)
+    return values
+
+
+def get_skill_config_masked(name: str) -> dict:
+    """Wie get_skill_config, aber secret-Felder werden auf '***SET***' maskiert.
+    Schema kommt aus dem skill.json — Felder ohne secret=True werden klar
+    zurueckgegeben. Fuer UI-Anzeige."""
+    manifest = read_manifest(name)
+    schema = (manifest or {}).get("config_schema") or []
+    secret_fields = {f.get("name") for f in schema if f.get("secret")}
+    values = get_skill_config(name)
+    return {k: ("***SET***" if (k in secret_fields and v) else v)
+            for k, v in values.items()}
+
+
+def _config_env_name(field_name: str) -> str:
+    """API-Key → CFG_API_KEY. Erlaubt nur a-zA-Z0-9_."""
+    safe = re.sub(r"[^a-zA-Z0-9]", "_", field_name).upper()
+    return f"CFG_{safe}"
+
+
+# ─── Versionierung (Rollback-fähiges update_skill) ───────────────────
+# Vor jedem strukturellen update wird der aktuelle Stand nach
+# versions/v_<ts>/ kopiert (ohne venv/logs/versions). Rollback kopiert
+# eine Version zurueck — vorher noch ein Auto-Snapshot, damit auch der
+# Rollback rueckholbar ist.
+
+def _versions_dir(name: str) -> Path:
+    return _skill_dir(name) / "versions"
+
+
+def _copytree_skill(src: Path, dst: Path) -> None:
+    """Kopiert Skill-Sources (alles ausser venv/logs/versions/__pycache__)."""
+    dst.mkdir(parents=True, exist_ok=True)
+    for item in src.iterdir():
+        if item.name in _VERSION_SKIP:
+            continue
+        target = dst / item.name
+        if item.is_dir():
+            shutil.copytree(item, target, dirs_exist_ok=True)
+        else:
+            shutil.copy2(item, target)
+
+
+def archive_current_version(name: str, summary: str = "") -> str:
+    """Kopiert den aktuellen Skill-Stand nach versions/v_<ts>/. Returnt die
+    version_id. Im Manifest wird `version_history` gepflegt."""
+    d = _skill_dir(name)
+    if not d.exists():
+        raise ValueError(f"Skill '{name}' nicht gefunden")
+    ts = int(time.time())
+    version_id = f"v_{ts}"
+    # Kollisionsschutz bei sub-Sekunden-Calls
+    while (_versions_dir(name) / version_id).exists():
+        ts += 1
+        version_id = f"v_{ts}"
+    archive = _versions_dir(name) / version_id
+    _copytree_skill(d, archive)
+    (archive / "_version.json").write_text(json.dumps({
+        "version_id": version_id,
+        "archived_at": _now(),
+        "summary": (summary or "")[:300],
+    }, indent=2, ensure_ascii=False), encoding="utf-8")
+    # Manifest-History pflegen (read-back nach _copytree, damit history konsistent)
+    manifest = read_manifest(name)
+    if manifest is not None:
+        hist = list(manifest.get("version_history") or [])
+        hist.append({"version_id": version_id, "archived_at": _now(),
+                     "summary": (summary or "")[:300]})
+        # Cap auf 50 Versionen — alte Eintraege wegrotieren (Dateien bleiben aber)
+        manifest["version_history"] = hist[-50:]
+        write_manifest(name, manifest)
+    return version_id
+
+
+def list_skill_versions(name: str) -> list[dict]:
+    """Liste aller archivierten Versionen, neueste zuerst."""
+    versions = _versions_dir(name)
+    if not versions.exists():
+        return []
+    out = []
+    for entry in sorted(versions.iterdir(), reverse=True):
+        if not entry.is_dir():
+            continue
+        meta = entry / "_version.json"
+        if meta.exists():
+            try:
+                out.append(json.loads(meta.read_text(encoding="utf-8")))
+                continue
+            except Exception:
+                pass
+        out.append({"version_id": entry.name, "archived_at": "", "summary": ""})
+    return out
+
+
+def rollback_skill(name: str, version_id: str) -> dict:
+    """Stellt eine archivierte Version wieder her. Vorher wird der aktuelle
+    Stand automatisch als neue Version archiviert ('safety_snapshot') —
+    Rollback ist also nicht destruktiv. venv wird neu aufgebaut wenn
+    requirements.txt vorhanden ist."""
+    d = _skill_dir(name)
+    if not d.exists():
+        raise ValueError(f"Skill '{name}' nicht gefunden")
+    archive = _versions_dir(name) / version_id
+    if not archive.exists() or not archive.is_dir():
+        raise ValueError(f"Version '{version_id}' fuer Skill '{name}' nicht gefunden")
+
+    # 1. Sicherung des aktuellen Stands
+    safety = archive_current_version(name, summary=f"safety-snapshot vor rollback auf {version_id}")
+
+    # 2. Aktuelle Sources loeschen (venv/logs/versions bleiben)
+    for item in d.iterdir():
+        if item.name in _VERSION_SKIP:
+            continue
+        if item.is_dir():
+            shutil.rmtree(item, ignore_errors=True)
+        else:
+            try:
+                item.unlink()
+            except FileNotFoundError:
+                pass
+
+    # 3. Archive zurueck kopieren (ohne _version.json — das ist Versions-Metadata)
+    for item in archive.iterdir():
+        if item.name == "_version.json":
+            continue
+        target = d / item.name
+        if item.is_dir():
+            shutil.copytree(item, target, dirs_exist_ok=True)
+        else:
+            shutil.copy2(item, target)
+
+    # 4. Manifest-Stempel
+    manifest = read_manifest(name)
+    if manifest is not None:
+        manifest["updated_at"] = _now()
+        manifest["last_rollback"] = {"to": version_id, "safety": safety, "at": _now()}
+        write_manifest(name, manifest)
+
+    # 5. venv-Rebuild bei local-venv
+    req_file = d / "requirements.txt"
+    if (manifest or {}).get("execution") == "local-venv" and req_file.exists():
+        pip_packages = [l.strip() for l in req_file.read_text(encoding="utf-8").splitlines()
+                        if l.strip() and not l.strip().startswith("#")]
+        venv = d / "venv"
+        if venv.exists():
+            shutil.rmtree(venv, ignore_errors=True)
+        try:
+            _setup_venv(d, pip_packages)
+            if manifest is not None:
+                manifest.pop("setup_error", None)
+                manifest["active"] = True
+                write_manifest(name, manifest)
+        except Exception as exc:
+            if manifest is not None:
+                manifest["active"] = False
+                manifest["setup_error"] = str(exc)[:500]
+                write_manifest(name, manifest)
+            logger.warning("Rollback %s: venv-Rebuild fehlgeschlagen: %s", name, exc)
+
+    return {"ok": True, "name": name, "rolled_back_to": version_id,
+            "safety_snapshot": safety}
+
+
+def delete_skill_version(name: str, version_id: str) -> dict:
+    """Loescht eine einzelne Version aus versions/. Nicht-rueckholbar."""
+    archive = _versions_dir(name) / version_id
+    if not archive.exists():
+        raise ValueError(f"Version '{version_id}' nicht gefunden")
+    shutil.rmtree(archive)
+    manifest = read_manifest(name)
+    if manifest is not None:
+        manifest["version_history"] = [v for v in (manifest.get("version_history") or [])
+                                       if v.get("version_id") != version_id]
+        write_manifest(name, manifest)
+    return {"ok": True, "deleted": version_id}
+
+
 # ─── Run ────────────────────────────────────────────────────────────
 
 def run_skill(name: str, args: Optional[dict] = None, timeout_sec: int = 300) -> dict:
@@ -284,6 +635,22 @@ def run_skill(name: str, args: Optional[dict] = None, timeout_sec: int = 300) ->
         env[f"ARG_{k.upper()}"] = str(v)
     env["SKILL_DIR"] = str(d)
     env["SHARED_UPLOADS"] = str(SHARED_UPLOADS)
+    # Brain-API fuer Skills die OAuth-Tokens / Brain-Helpers brauchen.
+    # Beispiel: requests.get(f"{os.environ['BRAIN_INTERNAL_URL']}/oauth/spotify/token")
+    env["BRAIN_INTERNAL_URL"] = os.environ.get("BRAIN_INTERNAL_URL", "http://localhost:8080")
+    # Config-Schema-Werte als CFG_<NAME>-ENV (P3). Default greift wenn Stefan
+    # noch keinen Wert gesetzt hat — None wird uebersprungen damit der Skill
+    # selbst entscheiden kann ob das ein Fehler ist.
+    schema = manifest.get("config_schema") or []
+    values = get_skill_config(name)
+    for field in schema:
+        fname = field.get("name")
+        if not fname:
+            continue
+        val = values.get(fname, field.get("default"))
+        if val is None:
+            continue
+        env[_config_env_name(fname)] = str(val)
 
     # Command bauen
     if exec_mode == "local-venv":

diagnostic/index.html

@@ -357,6 +357,37 @@
     </div>
   </div>
 
+  <!-- ARIA-Stream Archiv-Modal: paginierter Browser fuer den
+       persistierten agent_stream.jsonl. Page 1 = juengste Eintraege. -->
+  <div id="aria-archive-modal" style="display:none;position:fixed;top:0;left:0;width:100vw;height:100vh;background:rgba(0,0,0,0.75);z-index:1100;align-items:center;justify-content:center;padding:24px;" onclick="if(event.target===this) closeAriaStreamModal();">
+    <div style="background:#0D0D1A;border:1px solid #1E1E2E;border-radius:12px;width:100%;max-width:1100px;height:85vh;display:flex;flex-direction:column;">
+      <div style="display:flex;align-items:center;padding:12px 14px;border-bottom:1px solid #1E1E2E;gap:8px;flex-wrap:wrap;">
+        <h2 style="margin:0;color:#FFD60A;font-size:15px;flex:1;">📜 ARIA-Stream Archiv <span id="aria-archive-total" style="color:#8888AA;font-weight:normal;"></span></h2>
+        <label style="color:#8888AA;font-size:11px;">Pro Seite:</label>
+        <select id="aria-archive-perpage" onchange="loadAriaArchivePage(1)" style="background:#1A1A2E;color:#E0E0F0;border:1px solid #1E1E2E;border-radius:4px;padding:3px 6px;font-size:11px;">
+          <option value="50">50</option>
+          <option value="100" selected>100</option>
+          <option value="500">500</option>
+          <option value="1000">1000</option>
+        </select>
+        <button class="btn secondary" onclick="loadAriaArchivePage(_ariaArchivePage)" style="padding:3px 10px;font-size:11px;" title="Aktuelle Seite neu laden">↻</button>
+        <button class="btn secondary" onclick="closeAriaStreamModal()" style="padding:3px 12px;font-size:11px;">Schliessen</button>
+      </div>
+      <div style="display:flex;align-items:center;gap:6px;padding:8px 14px;border-bottom:1px solid #1E1E2E;flex-wrap:wrap;">
+        <button class="btn secondary" onclick="loadAriaArchivePage(1)" id="aria-arch-first" style="padding:3px 8px;font-size:11px;" title="Juengste Seite">«</button>
+        <button class="btn secondary" onclick="loadAriaArchivePage(_ariaArchivePage-1)" id="aria-arch-prev" style="padding:3px 8px;font-size:11px;" title="Eine Seite juenger">‹</button>
+        <span id="aria-arch-pageinfo" style="color:#8888AA;font-size:11px;min-width:140px;text-align:center;">Seite ? / ?</span>
+        <button class="btn secondary" onclick="loadAriaArchivePage(_ariaArchivePage+1)" id="aria-arch-next" style="padding:3px 8px;font-size:11px;" title="Eine Seite aelter">›</button>
+        <button class="btn secondary" onclick="loadAriaArchivePage(_ariaArchivePagesTotal)" id="aria-arch-last" style="padding:3px 8px;font-size:11px;" title="Aelteste Seite">»</button>
+        <span style="flex:1;"></span>
+        <span style="color:#555570;font-size:10px;">Seite 1 = neueste · höhere Pages = älter</span>
+      </div>
+      <div id="aria-archive-list" style="flex:1;overflow-y:auto;background:#040408;font-family:'Courier New',monospace;font-size:11px;line-height:1.4;color:#C0C0D0;padding:6px 12px;">
+        <div style="color:#555570;font-style:italic;padding:20px;text-align:center;">Lade...</div>
+      </div>
+    </div>
+  </div>
+
   <!-- Sessions + alter Brain-Viewer entfernt — Memories laufen jetzt
        komplett ueber den Gehirn-Tab gegen die Vector-DB im aria-brain. -->
 
@@ -405,6 +436,7 @@
         <div id="live-aria-bar" style="display:flex;gap:6px;align-items:center;padding:4px 4px 6px;flex-shrink:0;">
           <span id="live-aria-status" style="font-size:11px;color:#8888AA;flex:1;">Idle — warte auf ARIA-Aktivitaet</span>
           <button class="btn" onclick="clearAriaLive()" style="padding:4px 12px;font-size:11px;" title="Live-Mitschrift leeren">Leeren</button>
+          <button class="btn" onclick="openAriaStreamModal()" style="padding:4px 12px;font-size:11px;" title="Komplettes Archiv durchblaettern">📜 Archiv</button>
           <label style="font-size:11px;color:#8888AA;display:flex;align-items:center;gap:4px;cursor:pointer;" title="Bei jeder neuen Zeile ans Ende scrollen">
             <input type="checkbox" id="live-aria-autoscroll" checked style="margin:0;"> Auto-Scroll
           </label>
@@ -1650,36 +1682,54 @@
         if (msg.type === 'chat_history') {
           const boxes = [chatBox, document.getElementById('chat-box-fs')].filter(Boolean);
           for (const b of boxes) b.innerHTML = '';
+          let errorCount = 0;
           if (msg.messages && msg.messages.length > 0) {
-            for (const m of msg.messages) {
-              if (m.type === 'aria_file') {
-                // ARIA-Datei-Bubble — addAriaFile schreibt selbst in beide Boxen
-                addAriaFile({ serverPath: m.serverPath, name: m.name, mimeType: m.mimeType, size: m.size, deleted: m.deleted });
-                continue;
-              }
-              // [FILE: ...]-Marker rausfiltern (gleicher Filter wie addChat)
-              const cleaned = (m.text || '').replace(/\[FILE:\s*\/shared\/uploads\/[^\]]+\]/gi, '').replace(/\n{3,}/g, '\n\n').trim();
-              const escaped = escapeHtml(cleaned);
-              let linked = linkifyText(escaped);
-              // /shared/uploads/-Bildpfade auch im History inline rendern
-              linked = linked.replace(/\/shared\/uploads\/[^\s<"]+\.(jpg|jpeg|png|gif|webp|svg|bmp)/gi, (match) => {
-                return `<a href="${match}" target="_blank">${match}</a><img src="${match}" class="chat-media" onclick="openLightbox('image','${match}')" onerror="this.style.display='none'">`;
-              });
-              const time = m.ts ? new Date(m.ts).toLocaleTimeString('de-DE') : '?';
-              const trashBtn = m.ts
-                ? `<button class="bubble-trash" title="Diese Bubble loeschen" onclick="deleteDiagBubble(${m.ts})">🗑</button>`
-                : '';
-              const innerHtml = `${trashBtn}${linked}<div class="meta">${escapeHtml(m.meta)} — ${time}</div>`;
-              for (const b of boxes) {
-                const el = document.createElement('div');
-                el.className = `chat-msg ${m.type}`;
-                if (m.ts) el.dataset.ts = String(m.ts);
-                el.innerHTML = innerHtml;
-                b.appendChild(el);
+            for (let mi = 0; mi < msg.messages.length; mi++) {
+              const m = msg.messages[mi];
+              try {
+                if (m.type === 'aria_file') {
+                  addAriaFile({ serverPath: m.serverPath, name: m.name, mimeType: m.mimeType, size: m.size, deleted: m.deleted });
+                  continue;
+                }
+                const cleaned = (m.text || '').replace(/\[FILE:\s*\/shared\/uploads\/[^\]]+\]/gi, '').replace(/\n{3,}/g, '\n\n').trim();
+                const escaped = escapeHtml(cleaned);
+                let linked = linkifyText(escaped);
+                linked = linked.replace(/\/shared\/uploads\/[^\s<"]+\.(jpg|jpeg|png|gif|webp|svg|bmp)/gi, (match) => {
+                  return `<a href="${match}" target="_blank">${match}</a><img src="${match}" class="chat-media" onclick="openLightbox('image','${match}')" onerror="this.style.display='none'">`;
+                });
+                const time = m.ts ? new Date(m.ts).toLocaleTimeString('de-DE') : '?';
+                const trashBtn = m.ts
+                  ? `<button class="bubble-trash" title="Diese Bubble loeschen" onclick="deleteDiagBubble(${m.ts})">🗑</button>`
+                  : '';
+                const innerHtml = `${trashBtn}${linked}<div class="meta">${escapeHtml(m.meta)} — ${time}</div>`;
+                for (const b of boxes) {
+                  const el = document.createElement('div');
+                  el.className = `chat-msg ${m.type}`;
+                  if (m.ts) el.dataset.ts = String(m.ts);
+                  el.innerHTML = innerHtml;
+                  b.appendChild(el);
+                }
+              } catch (renderErr) {
+                // Eine kaputte Bubble darf nicht den Rest der History killen.
+                // Vorher passierte genau das: Frontend-Render bracht bei einer
+                // problematischen Antwort ab, alle nachfolgenden Nachrichten waren
+                // beim Reload weg. Jetzt: Fehler-Bubble einbauen + weitermachen.
+                errorCount++;
+                console.error('chat_history render error at idx ' + mi + ':', renderErr, m);
+                for (const b of boxes) {
+                  const el = document.createElement('div');
+                  el.className = `chat-msg ${m.type || 'received'}`;
+                  if (m.ts) el.dataset.ts = String(m.ts);
+                  el.innerHTML = `<span style="color:#FF6B6B;">⚠ Render-Fehler in Bubble (${escapeHtml(String(renderErr.message || renderErr))})</span><div class="meta">${m.ts ? new Date(m.ts).toLocaleTimeString('de-DE') : '?'}</div>`;
+                  b.appendChild(el);
+                }
               }
             }
             for (const b of boxes) b.scrollTop = b.scrollHeight;
           }
+          if (errorCount > 0) {
+            console.warn(`chat_history: ${errorCount} Bubble(s) konnten nicht gerendert werden`);
+          }
           return;
         }
 
@@ -3017,6 +3067,7 @@
       document.getElementById('live-desktop').style.display = tab === 'desktop' ? 'block' : 'none';
       document.getElementById('live-tab-aria').className = 'tab-btn' + (tab === 'aria' ? ' active' : '');
       document.getElementById('live-tab-desktop').className = 'tab-btn' + (tab === 'desktop' ? ' active' : '');
+      if (tab === 'aria') loadAriaStreamHistory();
     }
 
     // ── ARIA Live (read-only Mirror der Claude-Code-Session) ──────
@@ -3132,6 +3183,127 @@
       const el = _ariaStreamEl();
       if (el) el.innerHTML = '<div style="color:#555570;font-style:italic;">Geleert.</div>';
     }
+
+    // Beim ersten Tab-Oeffnen / Page-Reload: letzte 200 persistierte Events
+    // aus dem Diagnostic-Server holen. So sind die Live-Bash-Eintraege auch
+    // dann da wenn der Browser im Standby war.
+    let _ariaHistoryLoaded = false;
+    async function loadAriaStreamHistory(lines = 200) {
+      if (_ariaHistoryLoaded) return;
+      _ariaHistoryLoaded = true;
+      try {
+        const r = await fetch('/api/agent-stream?lines=' + lines);
+        if (!r.ok) return;
+        const d = await r.json();
+        const events = d.lines || [];
+        if (!events.length) return;
+        const el = _ariaStreamEl();
+        if (el) {
+          // Placeholder ('Sobald ARIA aktiv...') wegwerfen wenn vorhanden
+          const placeholder = el.querySelector('div[style*="italic"]');
+          if (placeholder) el.removeChild(placeholder);
+        }
+        _ariaPushLine(
+          `<span style="color:#444460;">━━━ ${events.length} fruehere Events (aus ${d.total || '?'} gespeicherten) ━━━</span>`,
+          '#444460',
+        );
+        for (const ev of events) {
+          try { appendAriaStreamEvent(ev); } catch {}
+        }
+        _ariaPushLine(
+          `<span style="color:#444460;">━━━ Ende History — Live ab hier ━━━</span>`,
+          '#444460',
+        );
+        _ariaMaybeScroll();
+      } catch (_) {}
+    }
+
+    // ── ARIA-Stream Archiv-Modal (Pagination) ────────────────
+    let _ariaArchivePage = 1;
+    let _ariaArchivePagesTotal = 1;
+
+    function openAriaStreamModal() {
+      const m = document.getElementById('aria-archive-modal');
+      if (!m) return;
+      m.style.display = 'flex';
+      loadAriaArchivePage(1);
+    }
+
+    function closeAriaStreamModal() {
+      const m = document.getElementById('aria-archive-modal');
+      if (m) m.style.display = 'none';
+    }
+
+    async function loadAriaArchivePage(page) {
+      const listEl = document.getElementById('aria-archive-list');
+      const infoEl = document.getElementById('aria-arch-pageinfo');
+      const totalEl = document.getElementById('aria-archive-total');
+      if (!listEl) return;
+      const perPage = parseInt(document.getElementById('aria-archive-perpage').value, 10) || 100;
+      page = Math.max(1, page || 1);
+      listEl.innerHTML = '<div style="color:#555570;font-style:italic;padding:20px;text-align:center;">Lade...</div>';
+      try {
+        const r = await fetch(`/api/agent-stream?page=${page}&perPage=${perPage}`);
+        if (!r.ok) throw new Error('HTTP ' + r.status);
+        const d = await r.json();
+        const events = d.lines || [];
+        _ariaArchivePage = d.page || page;
+        _ariaArchivePagesTotal = d.pagesTotal || 1;
+        if (totalEl) totalEl.textContent = `(${d.total || 0} Eintraege gesamt)`;
+        if (infoEl) infoEl.textContent = `Seite ${_ariaArchivePage} / ${_ariaArchivePagesTotal}`;
+        // Nav-Buttons enablen/disablen
+        document.getElementById('aria-arch-first').disabled = (_ariaArchivePage <= 1);
+        document.getElementById('aria-arch-prev').disabled = (_ariaArchivePage <= 1);
+        document.getElementById('aria-arch-next').disabled = (_ariaArchivePage >= _ariaArchivePagesTotal);
+        document.getElementById('aria-arch-last').disabled = (_ariaArchivePage >= _ariaArchivePagesTotal);
+
+        if (!events.length) {
+          listEl.innerHTML = '<div style="color:#555570;font-style:italic;padding:20px;text-align:center;">Keine Eintraege auf dieser Seite.</div>';
+          return;
+        }
+        // Eintraege rendern — wir teilen sie in HTML-Snippets analog zu
+        // appendAriaStreamEvent, schreiben aber direkt in den Modal-Container.
+        const html = events.map(p => renderArchiveLine(p)).join('');
+        listEl.innerHTML = html;
+        listEl.scrollTop = listEl.scrollHeight;
+      } catch (e) {
+        listEl.innerHTML = `<div style="color:#FF6B6B;padding:20px;">Fehler beim Laden: ${_ariaEsc(e.message)}</div>`;
+      }
+    }
+
+    function renderArchiveLine(p) {
+      const t = _ariaTimePrefix(p.ts);
+      const kind = p.kind || '';
+      const time = `<span style="color:#777799;">[${t}]</span>`;
+      if (kind === 'start') {
+        return `<div style="color:#444460;">━━━ ${t} session start (${_ariaEsc(p.model||'unknown')}) ━━━</div>`;
+      }
+      if (kind === 'end') {
+        const reason = p.reason || '?';
+        const codePart = (p.code != null) ? ` code=${_ariaEsc(p.code)}` : '';
+        const errPart = p.error ? ` err=${_ariaEsc(String(p.error).slice(0,120))}` : '';
+        return `<div style="color:#444460;">━━━ ${t} session end (${_ariaEsc(reason)}${codePart}${errPart}) ━━━</div>`;
+      }
+      if (kind === 'text') {
+        return `<div style="color:#D0D0E0;white-space:pre-wrap;word-break:break-word;">${time} ${_ariaEsc(p.text || '')}</div>`;
+      }
+      if (kind === 'thinking') {
+        return `<div style="color:#888866;font-style:italic;white-space:pre-wrap;word-break:break-word;">${time} 💭 ${_ariaEsc(p.text || '')}</div>`;
+      }
+      if (kind === 'tool_use') {
+        const name = _ariaEsc(p.name || '?');
+        const inp = _ariaEsc(p.input || '');
+        const tail = p.inputTruncatedBytes ? `<span style="color:#777799;"> ...(+${p.inputTruncatedBytes} bytes)</span>` : '';
+        return `<div style="color:#C0C0D0;white-space:pre-wrap;word-break:break-word;">${time} <span style="color:#0096FF;">▶ ${name}</span> <span style="color:#8888AA;">${inp}${tail}</span></div>`;
+      }
+      if (kind === 'tool_result') {
+        const isError = p.isError === true;
+        const head = isError ? '<span style="color:#FF6B6B;">✗ result (ERROR)</span>' : '<span style="color:#34C759;">✓ result</span>';
+        const tail = p.truncatedBytes ? `<span style="color:#777799;"> ...(+${p.truncatedBytes} bytes)</span>` : '';
+        return `<div style="color:#9090A0;">${time} ${head}<div style="white-space:pre-wrap;padding-left:14px;border-left:2px solid #2A2A3E;margin-top:2px;">${_ariaEsc(p.content || '')}${tail}</div></div>`;
+      }
+      return `<div style="color:#AAAACC;">${time} <span>${_ariaEsc(kind)}: ${_ariaEsc(JSON.stringify(p).slice(0, 500))}</span></div>`;
+    }
     function ariaPanicStop() {
       if (!confirm('Wirklich NOT-AUS? Alle aktiven Claude-Subprocesses werden sofort gekillt.')) return;
       send({ action: 'aria_panic_stop' });
@@ -3496,6 +3668,8 @@
                 <button class="btn secondary" onclick="exportSkill('${escapeHtml(s.name)}')" style="padding:2px 10px;font-size:11px;color:#0096FF;border-color:#0096FF;">⬇ Export</button>
                 <button class="btn secondary" onclick="deleteSkill('${escapeHtml(s.name)}')" style="padding:2px 10px;font-size:11px;color:#FF6B6B;border-color:#FF6B6B;">🗑 Löschen</button>
               </div>
+              <div id="skill-config-${escapeHtml(s.name)}" style="margin-bottom:10px;"></div>
+              <div id="skill-versions-${escapeHtml(s.name)}" style="margin-bottom:10px;"></div>
               <div style="color:#0096FF;font-size:11px;font-weight:bold;margin:6px 0 4px;">Logs (letzte 20)</div>
               <div id="skill-logs-${escapeHtml(s.name)}" style="font-size:11px;color:#8888AA;">(Logs lädt...)</div>
             </div>
@@ -3529,6 +3703,8 @@
           const el = document.getElementById('skill-readme-' + name);
           if (el && d.readme) el.innerHTML = '<pre style="margin:0;font-family:inherit;white-space:pre-wrap;">' + escapeHtml(d.readme) + '</pre>';
         } catch {}
+        loadSkillConfigSection(name);
+        loadSkillVersionsSection(name);
         try {
           const r2 = await fetch('/api/brain/skills/' + encodeURIComponent(name) + '/logs');
           const d2 = await r2.json();
@@ -3547,6 +3723,155 @@
       }
     }
 
+    // ── Skill-Configs (P3) ─────────────────────────────────
+    async function loadSkillConfigSection(name) {
+      const el = document.getElementById('skill-config-' + name);
+      if (!el) return;
+      try {
+        const r = await fetch('/api/brain/skills/' + encodeURIComponent(name) + '/config');
+        if (!r.ok) { el.innerHTML = ''; return; }
+        const d = await r.json();
+        const schema = d.schema || [];
+        if (!schema.length) { el.innerHTML = ''; return; }
+        const values = d.values || {};
+        const inputs = schema.map(f => {
+          const fname = f.name;
+          const label = f.label || fname;
+          const desc = f.description ? `<div style="color:#555570;font-size:10px;">${escapeHtml(f.description)}</div>` : '';
+          const isSecret = f.secret || f.type === 'password';
+          const cur = values[fname];
+          const placeholder = isSecret && cur === '***SET***' ? '••• gesetzt (leer lassen = unverändert) •••'
+                            : (f.default !== undefined && f.default !== null ? `Default: ${f.default}` : '');
+          let inputEl;
+          if (f.type === 'boolean') {
+            const checked = (cur === true || cur === 'true') ? 'checked' : '';
+            inputEl = `<input type="checkbox" data-cfg="${escapeHtml(fname)}" data-type="boolean" ${checked} style="margin-right:6px;">`;
+          } else {
+            const type = isSecret ? 'password' : (f.type === 'number' ? 'number' : 'text');
+            const val = (isSecret) ? '' : (cur !== undefined && cur !== null && cur !== '***SET***' ? escapeHtml(String(cur)) : '');
+            inputEl = `<input type="${type}" data-cfg="${escapeHtml(fname)}" data-type="${f.type || 'string'}" value="${val}" placeholder="${escapeHtml(placeholder)}" style="flex:1;padding:3px 6px;background:#0D0D1A;color:#E0E0F0;border:1px solid #1E1E2E;border-radius:3px;font-size:11px;">`;
+          }
+          return `<div style="margin-bottom:6px;">
+            <div style="display:flex;align-items:center;gap:6px;">
+              <label style="min-width:120px;color:#8888AA;font-size:11px;">${escapeHtml(label)}${isSecret ? ' 🔒' : ''}</label>
+              ${inputEl}
+            </div>
+            ${desc}
+          </div>`;
+        }).join('');
+        el.innerHTML = `
+          <div style="background:#0D0D1A;border:1px solid #1E1E2E;border-radius:4px;padding:8px;">
+            <div style="color:#FFD60A;font-size:11px;font-weight:bold;margin-bottom:6px;">⚙ Konfiguration</div>
+            ${inputs}
+            <button class="btn secondary" onclick="saveSkillConfig('${escapeHtml(name)}')" style="padding:3px 12px;font-size:11px;color:#3FFF3F;border-color:#3FFF3F;margin-top:4px;">💾 Speichern</button>
+            <span id="skill-cfg-status-${escapeHtml(name)}" style="color:#8888AA;font-size:11px;margin-left:8px;"></span>
+          </div>`;
+      } catch (e) {
+        el.innerHTML = `<div style="color:#FF6B6B;font-size:11px;">Config-Load: ${escapeHtml(e.message)}</div>`;
+      }
+    }
+
+    async function saveSkillConfig(name) {
+      const el = document.getElementById('skill-config-' + name);
+      if (!el) return;
+      const inputs = el.querySelectorAll('[data-cfg]');
+      // Erst aktuelle gespeicherte Werte holen — secret-Felder die leer sind sollen unverändert bleiben
+      let existing = {};
+      try {
+        const r = await fetch('/api/brain/skills/' + encodeURIComponent(name) + '/config');
+        const d = await r.json();
+        existing = d.values || {};
+      } catch {}
+      const values = { ...existing };
+      inputs.forEach(inp => {
+        const fname = inp.getAttribute('data-cfg');
+        const type = inp.getAttribute('data-type');
+        let v;
+        if (type === 'boolean') v = inp.checked;
+        else if (type === 'number') v = inp.value === '' ? null : Number(inp.value);
+        else v = inp.value;
+        const isPassword = inp.type === 'password';
+        if (isPassword && v === '') return; // leer bei secret = unverändert
+        if (v === '' || v === null) { delete values[fname]; return; }
+        if (v === '***SET***') return;
+        values[fname] = v;
+      });
+      try {
+        const r = await fetch('/api/brain/skills/' + encodeURIComponent(name) + '/config', {
+          method: 'POST', headers: {'Content-Type': 'application/json'},
+          body: JSON.stringify({ values }),
+        });
+        const stat = document.getElementById('skill-cfg-status-' + name);
+        if (r.ok) {
+          if (stat) { stat.textContent = '✓ gespeichert'; stat.style.color = '#3FFF3F'; }
+          loadSkillConfigSection(name);
+        } else {
+          if (stat) { stat.textContent = 'Fehler ' + r.status; stat.style.color = '#FF6B6B'; }
+        }
+      } catch (e) {
+        alert('Speichern fehlgeschlagen: ' + e.message);
+      }
+    }
+
+    // ── Skill-Versions (P4) ─────────────────────────────────
+    async function loadSkillVersionsSection(name) {
+      const el = document.getElementById('skill-versions-' + name);
+      if (!el) return;
+      try {
+        const r = await fetch('/api/brain/skills/' + encodeURIComponent(name) + '/versions');
+        if (!r.ok) { el.innerHTML = ''; return; }
+        const d = await r.json();
+        const versions = d.versions || [];
+        if (!versions.length) { el.innerHTML = ''; return; }
+        const fmtDate = (iso) => iso ? new Date(iso).toLocaleString('de-DE') : '?';
+        const rows = versions.map(v => `
+          <div style="display:flex;align-items:center;gap:6px;padding:3px 0;border-bottom:1px solid #1E1E2E;">
+            <span style="flex:1;font-family:monospace;font-size:10px;color:#E0E0F0;">${escapeHtml(v.version_id)}</span>
+            <span style="font-size:10px;color:#8888AA;">${fmtDate(v.archived_at)}</span>
+            <span style="flex:2;font-size:10px;color:#8888AA;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;">${escapeHtml(v.summary || '')}</span>
+            <button class="btn secondary" onclick="rollbackSkillVersion('${escapeHtml(name)}','${escapeHtml(v.version_id)}')" style="padding:1px 8px;font-size:10px;color:#FFD60A;border-color:#FFD60A;">↺ Rollback</button>
+            <button class="btn secondary" onclick="deleteSkillVersion('${escapeHtml(name)}','${escapeHtml(v.version_id)}')" style="padding:1px 8px;font-size:10px;color:#FF6B6B;border-color:#FF6B6B;">🗑</button>
+          </div>
+        `).join('');
+        el.innerHTML = `
+          <div style="background:#0D0D1A;border:1px solid #1E1E2E;border-radius:4px;padding:8px;">
+            <div style="color:#FFD60A;font-size:11px;font-weight:bold;margin-bottom:6px;">📦 Versionen (${versions.length})</div>
+            ${rows}
+          </div>`;
+      } catch (e) {
+        el.innerHTML = `<div style="color:#FF6B6B;font-size:11px;">Versions-Load: ${escapeHtml(e.message)}</div>`;
+      }
+    }
+
+    async function rollbackSkillVersion(name, versionId) {
+      if (!confirm(`Skill "${name}" auf Version ${versionId} zurückrollen?\n\nDer aktuelle Stand wird vorher automatisch gesichert (safety-snapshot).`)) return;
+      try {
+        const r = await fetch('/api/brain/skills/' + encodeURIComponent(name) + '/rollback', {
+          method: 'POST', headers: {'Content-Type':'application/json'},
+          body: JSON.stringify({ version_id: versionId }),
+        });
+        const d = await r.json();
+        if (r.ok) {
+          alert(`✓ Rollback OK\nSicherheits-Snapshot: ${d.safety_snapshot}`);
+          loadSkillVersionsSection(name);
+          loadSkills();
+        } else {
+          alert('Rollback fehlgeschlagen: ' + (d.detail || JSON.stringify(d)));
+        }
+      } catch (e) { alert('Rollback-Fehler: ' + e.message); }
+    }
+
+    async function deleteSkillVersion(name, versionId) {
+      if (!confirm(`Version ${versionId} von "${name}" wirklich löschen?\n\nNicht rückholbar.`)) return;
+      try {
+        const r = await fetch('/api/brain/skills/' + encodeURIComponent(name) + '/versions/' + encodeURIComponent(versionId), {
+          method: 'DELETE',
+        });
+        if (r.ok) loadSkillVersionsSection(name);
+        else { const d = await r.json().catch(()=>({})); alert('Löschen fehlgeschlagen: ' + (d.detail || r.status)); }
+      } catch (e) { alert('Fehler: ' + e.message); }
+    }
+
     async function toggleSkillActive(name, newActive) {
       try {
         await fetch('/api/brain/skills/' + encodeURIComponent(name), {
@@ -5283,6 +5608,9 @@
 
     loadThoughtStream();
     connectWS();
+    // ARIA-Live ist beim Page-Load schon der aktive Sub-Tab.
+    // History gleich nach Seitenstart laden damit Browser-Reload nichts verliert.
+    loadAriaStreamHistory();
   </script>
 </body>
 </html>

diagnostic/server.js

@@ -29,6 +29,40 @@ const RVS_TLS_FALLBACK = process.env.RVS_TLS_FALLBACK || "true";
 const RVS_TOKEN = process.env.RVS_TOKEN || "";
 const PROXY_URL = process.env.PROXY_URL || "http://proxy:3456";
 
+// ── Persistenz fuer agent_stream-Events ──────────────────
+// Jeder agent_stream-Event wird parallel zum Broadcast in eine .jsonl
+// geschrieben. Live-View laedt beim Tab-Oeffnen die letzten ~200 Zeilen,
+// damit Browser-Reload / Standby den Verlauf nicht wegwerfen. Rotation
+// haendelt logrotate / manual cleanup — wir cappen hier nur weichweich.
+const AGENT_STREAM_LOG = process.env.AGENT_STREAM_LOG || "/shared/logs/agent_stream.jsonl";
+const AGENT_STREAM_MAX_BYTES = 50 * 1024 * 1024;  // 50 MB → halten den File handlebar
+function appendAgentStream(payload) {
+  if (!payload || typeof payload !== "object") return;
+  try {
+    const line = JSON.stringify({ ts: Date.now(), ...payload }) + "\n";
+    // Soft-Cap: bei >50 MB ein Truncate auf den letzten ~25 MB Inhalt
+    try {
+      const st = fs.statSync(AGENT_STREAM_LOG);
+      if (st.size > AGENT_STREAM_MAX_BYTES) {
+        const half = Math.floor(AGENT_STREAM_MAX_BYTES / 2);
+        const fd = fs.openSync(AGENT_STREAM_LOG, "r");
+        const buf = Buffer.alloc(half);
+        fs.readSync(fd, buf, 0, half, st.size - half);
+        fs.closeSync(fd);
+        // bis zum naechsten Newline springen damit wir keine halbe Zeile haben
+        const firstNl = buf.indexOf(0x0a);
+        const start = firstNl >= 0 ? firstNl + 1 : 0;
+        fs.writeFileSync(AGENT_STREAM_LOG, buf.slice(start));
+      }
+    } catch {}
+    // Verzeichnis sicherstellen
+    try { fs.mkdirSync(path.dirname(AGENT_STREAM_LOG), { recursive: true }); } catch {}
+    fs.appendFileSync(AGENT_STREAM_LOG, line);
+  } catch (e) {
+    // Schweigend ignorieren — Persistence darf den Stream nicht blockieren
+  }
+}
+
 // ── State ───────────────────────────────────────────────
 const state = {
   gateway: { status: "disconnected", lastError: null, handshakeOk: false },
@@ -637,6 +671,9 @@ function connectRVS(forcePlain) {
         // Voller Live-Stream der Claude-Code-Session (assistant_text +
         // tool_use mit Input + tool_result mit truncated Output). Geht
         // 1:1 an Browser durch — die ARIA-Live-View rendert's.
+        // Zusaetzlich persistieren damit Browser-Reload / Standby den
+        // History-Verlauf nicht wegwirft.
+        try { appendAgentStream(msg.payload); } catch {}
         broadcast({ type: "agent_stream", payload: msg.payload });
       } else if (msg.type === "memory_saved") {
         // ARIA hat selber etwas in die Qdrant-DB gespeichert (via memory_save Tool).
@@ -701,8 +738,16 @@ function connectRVS(forcePlain) {
     state.rvs.lastError = err.message;
     broadcastState();
 
-    // TLS Fallback
-    if (useTls && RVS_TLS_FALLBACK === "true" && !fallbackTriggered) {
+    // TLS-Fallback nur bei wirklichen TLS/Handshake-Fehlern.
+    // Bei Netz-Problemen wie EHOSTUNREACH, ECONNREFUSED, ENETUNREACH,
+    // EAI_AGAIN ist der Server eh tot — Fallback bringt nichts ausser
+    // Log-Spam und doppelten Retries.
+    const netErr = (err.code || err.message || "").toString();
+    const isNetDown =
+      /^(EHOSTUNREACH|ECONNREFUSED|ENETUNREACH|ETIMEDOUT|EAI_AGAIN|ENOTFOUND)$/.test(netErr) ||
+      /EHOSTUNREACH|ECONNREFUSED|ENETUNREACH|ETIMEDOUT|EAI_AGAIN|ENOTFOUND/.test(err.message || "");
+
+    if (useTls && RVS_TLS_FALLBACK === "true" && !fallbackTriggered && !isNetDown) {
       fallbackTriggered = true;
       log("warn", "rvs", "TLS fehlgeschlagen — Fallback auf ws://");
       try { ws.removeAllListeners(); ws.close(); } catch (_) {}
@@ -1706,6 +1751,68 @@ const server = http.createServer((req, res) => {
     });
     req.pipe(proxyReq);
     return;
+  } else if (req.url.startsWith("/api/chat-backup") && req.method === "GET") {
+    // Tail des chat_backup.jsonl — fuer Debug-Sessions (was hat ARIA wirklich
+    // gesagt/getan). ?lines=N (Default 200, Max 5000).
+    try {
+      const u = new URL(req.url, "http://localhost");
+      const lines = Math.max(1, Math.min(5000, parseInt(u.searchParams.get("lines") || "200", 10) || 200));
+      const file = "/shared/config/chat_backup.jsonl";
+      let raw = "";
+      try { raw = fs.readFileSync(file, "utf-8"); } catch {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        return res.end(JSON.stringify({ ok: true, file, lines: [] }));
+      }
+      const all = raw.split("\n").filter(l => l.trim());
+      const tail = all.slice(-lines);
+      const parsed = tail.map(l => { try { return JSON.parse(l); } catch { return { _raw: l }; } });
+      res.writeHead(200, { "Content-Type": "application/json" });
+      return res.end(JSON.stringify({ ok: true, file, count: parsed.length, total: all.length, lines: parsed }));
+    } catch (e) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      return res.end(JSON.stringify({ ok: false, error: e.message }));
+    }
+  } else if (req.url.startsWith("/api/agent-stream") && req.method === "GET") {
+    // Tail / paginierter Slice des persistierten agent_stream.jsonl.
+    // Modi:
+    //   ?lines=N               → letzte N Zeilen (Live-View Initial-Load)
+    //   ?page=P&perPage=M      → 1-indexed Pagination (Modal-Browser);
+    //                            page=1 = neueste Seite, hoehere Pages = aelter
+    try {
+      const u = new URL(req.url, "http://localhost");
+      const linesParam = u.searchParams.get("lines");
+      const pageParam = u.searchParams.get("page");
+      const perPageParam = u.searchParams.get("perPage");
+      const file = AGENT_STREAM_LOG;
+      let raw = "";
+      try { raw = fs.readFileSync(file, "utf-8"); } catch {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        return res.end(JSON.stringify({ ok: true, file, total: 0, lines: [] }));
+      }
+      const all = raw.split("\n").filter(l => l.trim());
+      let slice, page = 1, perPage = 0, pagesTotal = 1;
+      if (pageParam || perPageParam) {
+        perPage = Math.max(10, Math.min(5000, parseInt(perPageParam || "100", 10) || 100));
+        pagesTotal = Math.max(1, Math.ceil(all.length / perPage));
+        page = Math.max(1, Math.min(pagesTotal, parseInt(pageParam || "1", 10) || 1));
+        // page=1 = juengste Seite → vom Ende her slicen
+        const end = all.length - (page - 1) * perPage;
+        const start = Math.max(0, end - perPage);
+        slice = all.slice(start, end);
+      } else {
+        const lines = Math.max(1, Math.min(5000, parseInt(linesParam || "200", 10) || 200));
+        slice = all.slice(-lines);
+      }
+      const parsed = slice.map(l => { try { return JSON.parse(l); } catch { return { _raw: l }; } });
+      res.writeHead(200, { "Content-Type": "application/json" });
+      return res.end(JSON.stringify({
+        ok: true, file, total: all.length, count: parsed.length,
+        page, perPage, pagesTotal, lines: parsed,
+      }));
+    } catch (e) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      return res.end(JSON.stringify({ ok: false, error: e.message }));
+    }
   } else if (req.url === "/api/brain-export" && req.method === "GET") {
     // Komplettes Gehirn als tar.gz streamen.
     // Schritte: Brain + Qdrant stoppen (saubere Bytes) → tar streamen → wieder starten.

rvs/docker-compose.yml

@@ -39,7 +39,7 @@ services:
     restart: always
     ports:
       - "80:80"
-      - "443:443"
+      - "444:443"
     command: caddy reverse-proxy --from ${PUBLIC_URL} --to rvs:3000
     volumes:
       - ./data/caddy/data:/data            # Zertifikate (PERSISTENT)