iobroker.poolcontrol 0.7.3 → 0.8.0

package/lib/helpers/aiHelper.js

@@ -8,35 +8,35 @@
  * Zentraler KI-Helper für PoolControl.
  *
  * Nutzt die States aus aiStates.js:
- *   ai.switches.*
- *   ai.schedule.*
- *   ai.outputs.*
+ *   ai.weather.switches.*
+ *   ai.weather.schedule.*
+ *   ai.weather.outputs.*
  *
  * Funktionen:
  *   - Liest Geodaten aus system.config (Latitude/Longitude)
  *   - Ruft Wetterdaten von Open-Meteo ab (bei Bedarf, max. 4x/Tag – je Modul)
  *   - Erzeugt Textausgaben:
- *       ai.outputs.weather_advice
- *       ai.outputs.daily_summary
- *       ai.outputs.pool_tips
- *       ai.outputs.weekend_summary
- *       ai.outputs.last_message
+ *       ai.weather.outputs.weather_advice
+ *       ai.weather.outputs.daily_summary
+ *       ai.weather.outputs.pool_tips
+ *       ai.weather.outputs.weekend_summary
+ *       ai.weather.outputs.last_message
  *   - Optional: legt Texte in speech.queue für Sprachausgabe
  *
  * Wichtige Schalter:
- *   - ai.switches.enabled              → globaler KI-Schalter
- *   - ai.switches.allow_speech         → Sprachausgabe erlaubt
- *   - ai.switches.weather_advice_enabled
- *   - ai.switches.daily_summary_enabled
- *   - ai.switches.daily_pool_tips_enabled
- *   - ai.switches.weekend_summary_enabled
- *   - ai.switches.debug_mode
+ *   - ai.enabled              → globaler KI-Schalter
+ *   - ai.weather.switches.allow_speech         → Sprachausgabe erlaubt
+ *   - ai.weather.switches.weather_advice_enabled
+ *   - ai.weather.switches.daily_summary_enabled
+ *   - ai.weather.switches.daily_pool_tips_enabled
+ *   - ai.weather.switches.weekend_summary_enabled
+ *   - ai.weather.switches.debug_mode
  *
  * Zeitsteuerung (HH:MM, lokal):
- *   - ai.schedule.weather_advice_time
- *   - ai.schedule.daily_summary_time
- *   - ai.schedule.daily_pool_tips_time
- *   - ai.schedule.weekend_summary_time
+ *   - ai.weather.schedule.weather_advice_time
+ *   - ai.weather.schedule.daily_summary_time
+ *   - ai.weather.schedule.daily_pool_tips_time
+ *   - ai.weather.schedule.weekend_summary_time
  */
 
 const https = require('https');
@@ -47,6 +47,11 @@ const aiHelper = {
     _lastScheduleValues: {}, // NEU: merkt sich letzte Zeitwerte
     _debugMode: false,
 
+    // Anti-Spam-Level (merkt sich letzte Warnungen)
+    _lastPoolTipCode: null,
+    _lastPoolTipWindLevel: null,
+    _lastPoolTipTimestamp: 0,
+
     /**
      * Initialisiert den AI-Helper (Timer + Grundkonfiguration).
      *
@@ -101,7 +106,7 @@ const aiHelper = {
         // ---------------------------------------------------------
         // FIX 2: Uhrzeitänderungen IMMER erkennen und loggen
         // ---------------------------------------------------------
-        if (id.includes('.ai.schedule.')) {
+        if (id.includes('.ai.weather.schedule.')) {
             const oldVal = this._lastScheduleValues[id];
             const newVal = state.val;
 
@@ -114,13 +119,49 @@ const aiHelper = {
 
             // Timer neu aufbauen
             await this._refreshTimers();
+
+            // NEU: Wenn Uhrzeit heute noch in der Zukunft liegt → sofort ausführen
+            try {
+                const now = new Date();
+                const [hourStr, minuteStr] = String(newVal).split(':');
+                const hour = Number(hourStr);
+                const minute = Number(minuteStr);
+
+                if (!Number.isNaN(hour) && !Number.isNaN(minute)) {
+                    const target = new Date();
+                    target.setHours(hour, minute, 0, 0);
+
+                    // Nur wenn Zielzeit HEUTE noch bevorsteht
+                    if (target > now) {
+                        this.adapter.log.info(
+                            `[aiHelper] Neue Uhrzeit liegt heute noch in der Zukunft → führe Modul sofort aus (${id})`,
+                        );
+
+                        if (id.endsWith('weather_advice_time')) {
+                            await this._runWeatherAdvice();
+                        }
+                        if (id.endsWith('daily_summary_time')) {
+                            await this._runDailySummary();
+                        }
+                        if (id.endsWith('daily_pool_tips_time')) {
+                            await this._runDailyPoolTips();
+                        }
+                        if (id.endsWith('weekend_summary_time')) {
+                            await this._runWeekendSummary();
+                        }
+                    }
+                }
+            } catch (e) {
+                this.adapter.log.warn(`[aiHelper] Fehler bei Sofortausführung nach Zeitänderung: ${e.message}`);
+            }
+
             return;
         }
 
         // ---------------------------------------------------------
         // FIX 3: Schalteränderungen immer melden
         // ---------------------------------------------------------
-        if (id.includes('.ai.switches.')) {
+        if (id.includes('.ai.weather.switches.')) {
             this.adapter.log.info(`[aiHelper] Schalter geändert: ${id} = ${state.val} – Timer werden neu aufgebaut`);
 
             await this._refreshTimers();
@@ -148,63 +189,106 @@ const aiHelper = {
     async _refreshTimers() {
         this._clearTimers();
 
-        const aiEnabled = await this._getBool('ai.switches.enabled', false);
-        this._debugMode = await this._getBool('ai.switches.debug_mode', false);
+        const aiEnabled = await this._getBool('ai.enabled', false);
+        this._debugMode = await this._getBool('ai.weather.switches.debug_mode', false);
 
         if (!aiEnabled) {
-            this.adapter.log.info('[aiHelper] KI ist deaktiviert (ai.switches.enabled = false) – keine Timer aktiv');
+            this.adapter.log.info('[aiHelper] KI ist deaktiviert (ai.enabled = false) – keine Timer aktiv');
             return;
         }
 
         this.adapter.log.info('[aiHelper] KI ist aktiv – Timer werden gesetzt');
 
         // --- Wetterhinweise ---
-        const weatherEnabled = await this._getBool('ai.switches.weather_advice_enabled', false);
+        const weatherEnabled = await this._getBool('ai.weather.switches.weather_advice_enabled', false);
         if (weatherEnabled) {
-            const time = await this._getTimeOrDefault('ai.schedule.weather_advice_time', '08:00');
+            const time = await this._getTimeOrDefault('ai.weather.schedule.weather_advice_time', '08:00');
             this._createDailyTimer(time, async () => {
                 await this._runWeatherAdvice();
             });
-            this.adapter.log.info(
+            this.adapter.log.debug(
                 `[aiHelper] Wetterhinweis-Timer gesetzt für ${time.hour}:${String(time.minute).padStart(2, '0')}`,
             );
         }
 
         // --- Tägliche Zusammenfassung ---
-        const summaryEnabled = await this._getBool('ai.switches.daily_summary_enabled', false);
+        const summaryEnabled = await this._getBool('ai.weather.switches.daily_summary_enabled', false);
         if (summaryEnabled) {
-            const time = await this._getTimeOrDefault('ai.schedule.daily_summary_time', '09:00');
+            const time = await this._getTimeOrDefault('ai.weather.schedule.daily_summary_time', '09:00');
             this._createDailyTimer(time, async () => {
                 await this._runDailySummary();
             });
-            this.adapter.log.info(
+            this.adapter.log.debug(
                 `[aiHelper] Daily-Summary-Timer gesetzt für ${time.hour}:${String(time.minute).padStart(2, '0')}`,
             );
         }
 
         // --- Tägliche Pool-Tipps ---
-        const tipsEnabled = await this._getBool('ai.switches.daily_pool_tips_enabled', false);
+        const tipsEnabled = await this._getBool('ai.weather.switches.daily_pool_tips_enabled', false);
         if (tipsEnabled) {
-            const time = await this._getTimeOrDefault('ai.schedule.daily_pool_tips_time', '10:00');
+            const time = await this._getTimeOrDefault('ai.weather.schedule.daily_pool_tips_time', '10:00');
             this._createDailyTimer(time, async () => {
                 await this._runDailyPoolTips();
             });
-            this.adapter.log.info(
+            this.adapter.log.debug(
                 `[aiHelper] Pool-Tipps-Timer gesetzt für ${time.hour}:${String(time.minute).padStart(2, '0')}`,
             );
         }
 
         // --- Wochenend-Zusammenfassung ---
-        const weekendEnabled = await this._getBool('ai.switches.weekend_summary_enabled', false);
+        const weekendEnabled = await this._getBool('ai.weather.switches.weekend_summary_enabled', false);
         if (weekendEnabled) {
-            const time = await this._getTimeOrDefault('ai.schedule.weekend_summary_time', '18:00');
+            const time = await this._getTimeOrDefault('ai.weather.schedule.weekend_summary_time', '18:00');
             this._createDailyTimer(time, async () => {
                 await this._runWeekendSummary();
             });
-            this.adapter.log.info(
+            this.adapter.log.debug(
                 `[aiHelper] Wochenend-Timer gesetzt für ${time.hour}:${String(time.minute).padStart(2, '0')}`,
             );
         }
+
+        //--------------------------------------------------------
+        // NEU: Stündlicher Wetter-Update-Timer
+        //--------------------------------------------------------
+        this.adapter.log.debug('[aiHelper] Stündlicher Wetter-Update-Timer wird gesetzt');
+
+        const hourlyTimer = setInterval(
+            async () => {
+                try {
+                    const geo = await this._loadGeoLocation();
+                    if (!geo) {
+                        this.adapter.log.info('[aiHelper] Wetter-Update abgebrochen – keine Geodaten verfügbar');
+                        return;
+                    }
+
+                    const weather = await this._fetchWeather(geo.lat, geo.lon);
+                    if (!weather) {
+                        this.adapter.log.info('[aiHelper] Wetter-Update abgebrochen – keine Wetterdaten verfügbar');
+                        return;
+                    }
+
+                    // WeatherAdvice aktualisieren (heutiges Wetter)
+                    const weatherText = this._buildWeatherAdviceText(weather);
+                    await this._writeOutput('weather_advice', weatherText);
+
+                    // NEU: Pool-Tipps automatisch mit aktualisieren
+                    const seasonActive = await this._getBool('status.season_active', false);
+                    const poolTipsText = this._buildPoolTipsText(weather, seasonActive);
+                    await this._writeOutput('pool_tips', poolTipsText);
+
+                    if (this._debugMode) {
+                        this.adapter.log.debug(
+                            '[aiHelper] Stündliches Wetter-Update durchgeführt (Weather + Pool-Tipps)',
+                        );
+                    }
+                } catch (err) {
+                    this.adapter.log.warn(`[aiHelper] Fehler beim stündlichen Wetter-Update: ${err.message}`);
+                }
+            },
+            60 * 60 * 1000,
+        ); // 1 Stunde
+
+        this.timers.push(hourlyTimer);
     },
 
     /**
@@ -225,14 +309,14 @@ const aiHelper = {
             if (diffMinutes > 0 && diffMinutes <= 2) {
                 try {
                     await callback();
-                    this.adapter.log.info('[aiHelper] Zeit knapp verpasst – nachträgliche Ausführung durchgeführt');
+                    this.adapter.log.debug('[aiHelper] Zeit knapp verpasst – nachträgliche Ausführung durchgeführt');
                 } catch (err) {
                     this.adapter.log.warn(`[aiHelper] Fehler bei nachträglicher Ausführung: ${err.message}`);
                 }
             }
 
             if (now.getHours() === hour && now.getMinutes() === minute) {
-                this.adapter.log.info(
+                this.adapter.log.debug(
                     `[aiHelper] Timer ausgelöst: ${hour}:${String(minute).padStart(2, '0')} → Callback wird ausgeführt`,
                 ); // NEU
 
@@ -359,32 +443,57 @@ const aiHelper = {
         }
     },
 
+    //--------------------------------------------------------
+    // NEU: Stündliches Wetter-Update als eigene Funktion
+    //--------------------------------------------------------
+    async _runWeatherAutoUpdate() {
+        try {
+            const geo = await this._loadGeoLocation();
+            if (!geo) {
+                this.adapter.log.info('[aiHelper] Auto-Wetterupdate abgebrochen – keine Geodaten verfügbar');
+                return;
+            }
+
+            const weather = await this._fetchWeather(geo.lat, geo.lon);
+            if (!weather) {
+                this.adapter.log.info('[aiHelper] Auto-Wetterupdate abgebrochen – keine Wetterdaten verfügbar');
+                return;
+            }
+
+            // WeatherAdvice aktualisieren
+            const text = this._buildWeatherAdviceText(weather);
+            await this._writeOutput('weather_advice', text);
+
+            if (this._debugMode) {
+                this.adapter.log.debug('[aiHelper] Auto-Wetterupdate erfolgreich durchgeführt');
+            }
+        } catch (err) {
+            this.adapter.log.warn(`[aiHelper] Fehler bei Auto-Wetterupdate: ${err.message}`);
+        }
+    },
+
     // ---------------------------------------------------------------------
     // Geodaten + Wetter
     // ---------------------------------------------------------------------
 
     /**
-     * Lädt Geokoordinaten aus system.config.
+     * Lädt Geokoordinaten korrekt aus system.config.
      *
      * @returns {{lat:number,lon:number}|null}
      */
     async _loadGeoLocation() {
         try {
-            const latState = await this.adapter.getForeignStateAsync('system.config.latitude');
-            const lonState = await this.adapter.getForeignStateAsync('system.config.longitude');
-
-            if (!latState || !lonState || latState.val == null || lonState.val == null) {
-                this.adapter.log.warn(
-                    '[aiHelper] Geodaten in system.config nicht gesetzt – bitte im Admin konfigurieren',
-                );
+            const obj = await this.adapter.getForeignObjectAsync('system.config');
+            if (!obj || !obj.common) {
+                this.adapter.log.warn('[aiHelper] Konnte system.config nicht laden');
                 return null;
             }
 
-            const lat = Number(latState.val);
-            const lon = Number(lonState.val);
+            const lat = Number(obj.common.latitude);
+            const lon = Number(obj.common.longitude);
 
             if (Number.isNaN(lat) || Number.isNaN(lon)) {
-                this.adapter.log.warn('[aiHelper] Geodaten ungültig – latitude/longitude sind keine Zahlen');
+                this.adapter.log.warn('[aiHelper] Geodaten ungültig – bitte in Admin unter System/Standort eintragen');
                 return null;
             }
 
@@ -567,6 +676,54 @@ const aiHelper = {
 
         let text = 'Pool-Tipp für heute: ';
 
+        //--------------------------------------------------------
+        // NEU: Erweiterte Analyse für Pool-Tipps
+        //--------------------------------------------------------
+
+        // 1) Wind / Sturm
+        const wind = weather?.current?.wind_speed_10m ?? null;
+        if (wind != null) {
+            if (wind >= 60) {
+                text +=
+                    '⚠️ Extrem starker Sturm erwartet! Bitte unbedingt die Abdeckung sichern und alle Gegenstände im Poolbereich fest verankern. ';
+            } else if (wind >= 45) {
+                text += 'Achtung: Starke Windböen treten auf. Bitte Abdeckung fixieren und lose Gegenstände sichern. ';
+            } else if (wind >= 30) {
+                text += 'Es wird windig – Abdeckung gut verschließen und empfindliches Zubehör schützen. ';
+            }
+        }
+
+        // 2) Regen / Starkregen
+        if (code != null) {
+            if ([65, 82].includes(code)) {
+                text += 'Kräftige Regenschauer erwartet – Abdeckung geschlossen halten. ';
+            } else if ([61, 63, 80, 81].includes(code)) {
+                text += 'Es wird regnerisch – Abdeckung eher geschlossen lassen. ';
+            }
+        }
+
+        // 3) Gewitter / Hagel
+        if (code === 95) {
+            text += '⚡ Gewitterwarnung! Bitte Solarfolie sichern und Technik vor Feuchtigkeit schützen. ';
+        }
+        if (code === 96 || code === 99) {
+            text += '⚠️ Hagelgefahr! Bitte empfindliche Geräte schützen und Poolbereich räumen. ';
+        }
+
+        // 4) Temperatur / Hitze
+        if (tmax >= 28) {
+            text += 'Sehr warmes Badewetter – Abdeckung tagsüber offen lassen. Chlorverbrauch steigt. ';
+        } else if (tmax >= 22) {
+            text += 'Angenehme Temperaturen – normaler Poolbetrieb empfohlen. ';
+        } else if (tmax <= 16) {
+            text += 'Kühle Temperaturen – Abdeckung geschlossen halten, um Wärmeverluste zu reduzieren. ';
+        }
+
+        // Fallback falls noch nichts geschrieben wurde
+        if (text.trim() === 'Pool-Tipp für heute:') {
+            text += desc ? `${desc}. ` : 'Keine besonderen Hinweise für den heutigen Tag. ';
+        }
+
         if (tmax >= 26) {
             text += 'Es wird warm bis sehr warm – gutes Badewetter. ';
             text +=
@@ -587,6 +744,47 @@ const aiHelper = {
             text += 'Bei sonniger Witterung steigt der Chlorverbrauch – Wasserwerte im Auge behalten.';
         }
 
+        //--------------------------------------------------------
+        // NEU: Anti-Spam-Logik
+        //--------------------------------------------------------
+
+        // // Wettercode vergleichen
+        // if (code != null) {
+        //     if (this._lastPoolTipCode === code) {
+        //         // gleiches Wetter wie vorher → eventuell abbrechen
+        //         const nowTs = Date.now();
+        //         // nur jede 3 Stunden dieselbe Warnung erneut ausgeben
+        //         if (nowTs - this._lastPoolTipTimestamp < 3 * 60 * 60 * 1000) {
+        //             return 'Pool-Tipp: Keine neuen Hinweise – Bedingungen unverändert.';
+        //         }
+        //     }
+        // }
+
+        // Windlevel kategorisieren: 0 = ruhig, 1 = windig, 2 = stark, 3 = Sturm
+        let windLevel = 0;
+        if (wind != null) {
+            if (wind >= 60) {
+                windLevel = 3;
+            } else if (wind >= 45) {
+                windLevel = 2;
+            } else if (wind >= 30) {
+                windLevel = 1;
+            }
+        }
+
+        // // prüfen, ob derselbe Windlevel schon gemeldet wurde
+        // if (windLevel === this._lastPoolTipWindLevel) {
+        //     const nowTs = Date.now();
+        //     if (nowTs - this._lastPoolTipTimestamp < 3 * 60 * 60 * 1000) {
+        //         return 'Pool-Tipp: Keine neuen Informationen – Wetter gleich geblieben.';
+        //     }
+        // }
+
+        // Wenn wir hier sind → neuer Hinweis → Werte speichern
+        this._lastPoolTipCode = code;
+        this._lastPoolTipWindLevel = windLevel;
+        this._lastPoolTipTimestamp = Date.now();
+
         return text;
     },
 
@@ -761,11 +959,11 @@ const aiHelper = {
         }
 
         try {
-            await this.adapter.setStateAsync(`ai.outputs.${id}`, { val: text, ack: true });
-            await this.adapter.setStateAsync('ai.outputs.last_message', { val: text, ack: true });
+            await this.adapter.setStateAsync(`ai.weather.outputs.${id}`, { val: text, ack: true });
+            await this.adapter.setStateAsync('ai.weather.outputs.last_message', { val: text, ack: true });
 
             if (this._debugMode) {
-                this.adapter.log.info(`[aiHelper] Output geschrieben → ai.outputs.${id}: ${text}`);
+                this.adapter.log.debug(`[aiHelper] Output geschrieben → ai.weather.outputs.${id}: ${text}`);
             }
         } catch (err) {
             this.adapter.log.error(`[aiHelper] Fehler beim Schreiben eines Outputs (${id}): ${err.message}`);
@@ -785,10 +983,12 @@ const aiHelper = {
             return;
         }
 
-        const allowSpeech = await this._getBool('ai.switches.allow_speech', false);
+        const allowSpeech = await this._getBool('ai.weather.switches.allow_speech', false);
         if (!allowSpeech) {
             if (this._debugMode) {
-                this.adapter.log.debug('[aiHelper] Sprachausgabe deaktiviert (ai.switches.allow_speech = false)');
+                this.adapter.log.debug(
+                    '[aiHelper] Sprachausgabe deaktiviert (ai.weather.switches.allow_speech = false)',
+                );
             }
             return;
         }
@@ -870,7 +1070,7 @@ const aiHelper = {
         const str = await this._getString(id, def);
 
         // NEU: Log, welche Uhrzeit der Helper tatsächlich verwendet
-        this.adapter.log.info(`[aiHelper] Uhrzeit geladen: ${id} = "${str}" (Default: ${def})`);
+        this.adapter.log.debug(`[aiHelper] Uhrzeit geladen: ${id} = "${str}" (Default: ${def})`);
 
         const match = /^(\d{1,2}):(\d{2})$/.exec(str || '');
         let hour = 0;

package/lib/stateDefinitions/aiStates.js

@@ -4,10 +4,13 @@
  * aiStates.js
  * ----------------------------------------------------------
  * Definiert alle States für den KI-Bereich des PoolControl-Adapters.
- * Struktur:
- * ai.switches.*
- * ai.schedule.*
- * ai.outputs.*
+ *
+ * Neue Struktur:
+ *   ai.enabled                         → globaler KI-Hauptschalter
+ *
+ *   ai.weather.switches.*              → Schalter für Wetter-KI
+ *   ai.weather.schedule.*              → Zeitpläne für Wetter-KI
+ *   ai.weather.outputs.*               → Textausgaben der Wetter-KI
  * ----------------------------------------------------------
  *
  * @param {import('iobroker').Adapter} adapter - ioBroker Adapterinstanz
@@ -21,7 +24,9 @@
 async function createAiStates(adapter) {
     adapter.log.debug('[aiStates] Initialisierung gestartet');
 
-    // Hauptordner
+    // ------------------------------------------------------
+    // Hauptordner: ai
+    // ------------------------------------------------------
     await adapter.setObjectNotExistsAsync('ai', {
         type: 'channel',
         common: { name: 'KI / AI-Funktionen' },
@@ -29,26 +34,67 @@ async function createAiStates(adapter) {
     });
 
     // ------------------------------------------------------
-    // Unterordner: switches
+    // NEU / GEÄNDERT:
+    // Globaler KI-Hauptschalter (anstatt ai.switches.enabled)
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('ai.enabled', {
+        type: 'state',
+        common: {
+            name: 'KI aktivieren',
+            desc: 'Globaler Hauptschalter für alle KI-Funktionen',
+            type: 'boolean',
+            role: 'switch',
+            read: true,
+            write: true,
+            def: false,
+            persist: true,
+        },
+        native: {},
+    });
+
+    // ------------------------------------------------------
+    // NEU: Wetter-Hauptordner
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('ai.weather', {
+        type: 'channel',
+        common: {
+            name: 'Wetterbezogene KI-Funktionen',
+            desc: 'Alle KI-Funktionen rund um Wetter, Vorhersagen und Pooltipps',
+        },
+        native: {},
+    });
+
+    // ------------------------------------------------------
+    // NEU: Unterordner Wetter-Switches
     // ------------------------------------------------------
-    await adapter.setObjectNotExistsAsync('ai.switches', {
+    await adapter.setObjectNotExistsAsync('ai.weather.switches', {
         type: 'channel',
-        common: { name: 'Schalter (KI-Steuerung)' },
+        common: {
+            name: 'Schalter (Wetter-KI)',
+            desc: 'Einzelne Schalter für wetterbezogene KI-Funktionen',
+        },
         native: {},
     });
 
-    const switches = [
-        { id: 'enabled', name: 'KI aktivieren', def: false },
-        { id: 'allow_speech', name: 'Sprachausgabe durch KI erlauben', def: false },
+    // NEU / GEÄNDERT:
+    // Alle bisherigen wetterbezogenen Switches liegen jetzt unter ai.weather.switches.*
+    const weatherSwitches = [
+        // Steuerung & Debug für Wetter-KI
+        { id: 'allow_speech', name: 'Sprachausgabe für Wetter-KI erlauben', def: false }, // GEÄNDERT: von ai.switches → ai.weather.switches
+        { id: 'debug_mode', name: 'Debugmodus für Wetter-KI', def: false }, // GEÄNDERT: von ai.switches → ai.weather.switches
+
+        // Modulspezifische Schalter
         { id: 'daily_summary_enabled', name: 'Tägliche Zusammenfassung aktiv', def: false },
         { id: 'daily_pool_tips_enabled', name: 'Tägliche Pool-Tipps aktiv', def: false },
         { id: 'weather_advice_enabled', name: 'Wetterhinweise aktiv', def: false },
         { id: 'weekend_summary_enabled', name: 'Wochenende-Zusammenfassung aktiv', def: false },
-        { id: 'debug_mode', name: 'KI-Debugmodus', def: false },
+
+        // NEU: Schalter für "Vorhersage für morgen"
+        { id: 'tomorrow_forecast_enabled', name: 'Vorhersage für morgen aktiv', def: false }, // NEU
     ];
 
-    for (const s of switches) {
-        await adapter.setObjectNotExistsAsync(`ai.switches.${s.id}`, {
+    for (const s of weatherSwitches) {
+        await adapter.setObjectNotExistsAsync(`ai.weather.switches.${s.id}`, {
             type: 'state',
             common: {
                 name: s.name,
@@ -64,23 +110,31 @@ async function createAiStates(adapter) {
     }
 
     // ------------------------------------------------------
-    // Unterordner: schedule
+    // NEU: Unterordner Wetter-Schedule
     // ------------------------------------------------------
-    await adapter.setObjectNotExistsAsync('ai.schedule', {
+    await adapter.setObjectNotExistsAsync('ai.weather.schedule', {
         type: 'channel',
-        common: { name: 'Zeitpläne (KI-Ausgaben)' },
+        common: {
+            name: 'Zeitpläne (Wetter-KI)',
+            desc: 'Zeitsteuerung für wetterbezogene KI-Ausgaben',
+        },
         native: {},
     });
 
-    const schedule = [
+    // NEU / GEÄNDERT:
+    // Alle Zeitpläne liegen jetzt unter ai.weather.schedule.*
+    const weatherSchedule = [
         { id: 'daily_summary_time', name: 'Zeit für tägliche Zusammenfassung', def: '09:00' },
         { id: 'daily_pool_tips_time', name: 'Zeit für tägliche Pool-Tipps', def: '10:00' },
         { id: 'weather_advice_time', name: 'Zeit für Wetterhinweise', def: '08:00' },
         { id: 'weekend_summary_time', name: 'Zeit für Wochenend-Zusammenfassung', def: '18:00' },
+
+        // NEU: Zeitplan für "Vorhersage für morgen"
+        { id: 'tomorrow_forecast_time', name: 'Zeit für morgige Vorhersage', def: '19:00' }, // NEU
     ];
 
-    for (const t of schedule) {
-        await adapter.setObjectNotExistsAsync(`ai.schedule.${t.id}`, {
+    for (const t of weatherSchedule) {
+        await adapter.setObjectNotExistsAsync(`ai.weather.schedule.${t.id}`, {
             type: 'state',
             common: {
                 name: t.name,
@@ -96,24 +150,34 @@ async function createAiStates(adapter) {
     }
 
     // ------------------------------------------------------
-    // Unterordner: outputs
+    // NEU: Unterordner Wetter-Outputs
     // ------------------------------------------------------
-    await adapter.setObjectNotExistsAsync('ai.outputs', {
+    await adapter.setObjectNotExistsAsync('ai.weather.outputs', {
         type: 'channel',
-        common: { name: 'KI-Ausgaben (Texte)' },
+        common: {
+            name: 'KI-Ausgaben (Wetter-Texte)',
+            desc: 'Textausgaben der Wetter-KI (Hinweise, Tipps, Zusammenfassungen)',
+        },
         native: {},
     });
 
-    const outputs = [
+    // NEU / GEÄNDERT:
+    // Alle bisherigen Ausgaben + neue Vorhersage + last_message unter ai.weather.outputs.*
+    const weatherOutputs = [
         { id: 'daily_summary', name: 'Tägliche Zusammenfassung' },
         { id: 'pool_tips', name: 'Pool-Tipps' },
         { id: 'weather_advice', name: 'Wetterhinweise' },
         { id: 'weekend_summary', name: 'Wochenende-Zusammenfassung' },
-        { id: 'last_message', name: 'Letzte KI-Meldung' },
+
+        // NEU: Ausgabefeld für die Vorhersage für morgen
+        { id: 'tomorrow_forecast', name: 'Vorhersage für morgen' }, // NEU
+
+        // GEÄNDERT: last_message gehört aktuell zur Wetter-KI
+        { id: 'last_message', name: 'Letzte Wetter-KI-Meldung' }, // GEÄNDERT: von ai.outputs → ai.weather.outputs
     ];
 
-    for (const o of outputs) {
-        await adapter.setObjectNotExistsAsync(`ai.outputs.${o.id}`, {
+    for (const o of weatherOutputs) {
+        await adapter.setObjectNotExistsAsync(`ai.weather.outputs.${o.id}`, {
             type: 'state',
             common: {
                 name: o.name,