node-red-contrib-knx-ultimate 6.3.18 → 6.3.21

package/nodes/locales/de/knxUltimateAI.html

@@ -33,6 +33,9 @@ Bei DPT-1.xxx-Schreibvorgängen werden die sicheren KI-Entsprechungen `true`/`fa
 ### Aktuelle KNX-Lesewerte
 Wenn der Benutzer ausdrücklich einen aktuellen oder aktualisierten Zustand anfordert, kann die KI exakte Objekte aus dem importierten ETS-Katalog abfragen, einschließlich Status- und anderer schreibgeschützter Objekte. Ausgang 4 gibt `msg.destination`, `msg.dpt`, `msg.event = "GroupValue_Read"` und `msg.readstatus = true` aus. Der Node wartet bis zu 6 Sekunden auf jede `GroupValue_Response` oder ein aktuelles Write-Telegramm, gibt anschließend die dekodierten Werte an Ausgang 3 zurück und stellt Details in `msg.knxAi.readResults` bereit. Leseoperationen erfordern keine Bestätigung und werden niemals in Schreiboperationen umgewandelt.
 
+### Mehrstufige Gesprächsroutinen
+Anfragen wie „Ich gehe“, „Gute Nacht“ oder „Kinomodus“ können ohne neue Editor-Option eine zustandsabhängige Routine koordinieren. Im ersten LLM-Durchlauf werden ausschließlich exakte ETS-Leseoperationen akzeptiert (maximal 20); KNX AI sendet sie und übergibt die aktuellen GA-/DPT-/Wert-Ergebnisse an einen zweiten isolierten Planungsdurchlauf. Dieser darf bis zu 12 validierte Schreiboperationen vorbereiten, aber keinen weiteren Lesezyklus starten. Bei aktivierter Bestätigung benötigt der gesamte Plan eine einzige lokalisierte Bestätigung; vorher werden weder Schreiboperationen noch angeforderte TTS-Ansagen ausgegeben. Nach der Bestätigung wird jede Schreiboperation erneut validiert, in Reihenfolge weitergegeben und bis zu 4 Sekunden auf eine passende unmittelbare Bus-Rückmeldung beobachtet. Die Abschlussmeldung unterscheidet beobachtete Rückmeldungen von Vorgängen ohne unmittelbare Rückmeldung, ohne daraus einen Gerätefehler abzuleiten. Details stehen in `msg.knxAi.routine`, `readResults`, `verifiedCount` und `unverifiedCount`.
+
 ### Bestätigungsanfrage für Chat-Schaltflächen
 Solange ein Plan aussteht, enthält Ausgang 3 `msg.knxAi.confirmationRequest`. Das Objekt enthält `required`, `status`, `sessionId`, `expiresAt`, `commandCount` und zwei Einträge in `actions`. Verwenden Sie `action.label` als Text der Telegram-Schaltfläche, `action.callbackData` als Callback und senden Sie `action.message` an KNX AI zurück, um ohne Texteingabe zu bestätigen oder abzubrechen.
 
@@ -48,6 +51,8 @@ Installierte Kamerapakete können KNX AI zur Laufzeit einen Kamera-Adapter berei
 
 Der Benutzer kann einen aktuellen Snapshot anfordern oder das Vision-Modell nach dem sichtbaren Inhalt fragen. Die Telegram- und RedBot-Vorlagen senden das Bild als natives Foto mit Bildunterschrift. Außerdem lassen sich dauerhafte Benachrichtigungen für Bewegung, das Überqueren einer intelligenten Linie oder das Betreten einer Einbruchs-/Verweilzone erstellen, optional auf erkannte Personen und eine genau benannte Linie oder Zone begrenzt. Diese Regeln werden in derselben Datei `knxai-chat-context.md` gespeichert und nach einem Neustart von Node-RED wiederhergestellt. UniFi-Ereignisse und Snapshot-Anfragen laufen direkt über den erkannten Anbieter; Ausgang 4 von KNX AI und zusätzliche Flow-Verkabelung sind nicht erforderlich.
 
+Jedes von einem automatisch erkannten Adapter veröffentlichte Ereignis wird normalisiert und in eine tägliche Datei `YYYY-MM-DD.jsonl` unter `knxultimatestorage/knxai/adapter-history/<node-id>/` geschrieben. Das Archiv bewahrt 10 Tage auf, garantiert mehr als 24 Stunden Historie und speichert Ereignismetadaten, jedoch keine Snapshot-Bilder. Web-Assistent und alle CHAT-Kanäle fragen es zusammen mit dem täglichen KNX-Telegrammarchiv ab. Summen umfassen alle gespeicherten Zeilen; ausgewählte Details sind nur eine relevante Stichprobe.
+
 ### Ansagen mit TTS Ultimate
 Wenn das optionale Paket `node-red-contrib-tts-ultimate` installiert ist, erscheint es unter den automatisch erkannten Adaptern. Die Auswahl listet alle `ttsultimate`-Nodes in sämtlichen Projekt-Flows mit Flow, Node-Name und konfiguriertem Player auf. Wählen Sie den Node für Chat-Ansagen aus und deployen Sie den Flow.
 

package/nodes/locales/de/knxUltimateAI.json

@@ -90,6 +90,7 @@
       "chatContextFilesTitle": "Dauerhafte Kontextdateien",
       "chatContextDirectoriesTitle": "KNX-Telegrammarchiv",
       "chatContextSourceKnxTraffic": "Aktuelle KNX-Zusammenfassung, Anomalien, Topologie und ausgewählte Telegramme.",
+      "chatContextSourceAdapterHistory": "Dauerhaftes Tagesarchiv automatisch erkannter Adapterereignisse einschließlich Kameraerkennungen.",
       "chatContextSourceEtsProject": "ETS-Semantik und vollständiges Inventar des Node-RED-Projekts.",
       "chatContextSourceMemoryEducation": "Sitzungskontext, KI-Erziehung und begrenztes Hausgedächtnis.",
       "chatContextSourceCamerasDocs": "Erkannte Kameras und relevante Auszüge aus Hilfe, README und Beispielen.",
@@ -102,6 +103,9 @@
       "chatContextDirectoryRoot": "Stammverzeichnis des Telegrammarchivs",
       "chatContextDirectoryNode": "Telegrammarchiv dieses Nodes",
       "chatContextDirectoryBadge": "KNX",
+      "chatContextDirectoryAdapterRoot": "Stammverzeichnis des Adapterereignisarchivs",
+      "chatContextDirectoryAdapterNode": "Adapterereignisarchiv dieses Nodes",
+      "chatContextDirectoryAdapterBadge": "Adapter",
       "chatContextTelegramPattern": "Tagesdateien",
       "chatAdapterIntro": "Wählen Sie eine Vorlage, um den Code für Ein- und Ausgang einzufügen. Die Liste wird aus der mitgelieferten Chat-Adapter-Datei geladen; der erzeugte Code bleibt bearbeitbar.",
       "chatAdapterCodeHelp": "Zuordnungen laufen synchron. Geben Sie msg zurück, um fortzufahren, oder keinen Wert, um die Nachricht zu verwerfen. Fehler werden abgefangen und gemeldet, ohne Node-RED anzuhalten.",

package/nodes/locales/en/knxUltimateAI.html

@@ -33,6 +33,9 @@ For DPT 1.xxx writes, safe AI equivalents `true`/`false`, `1`/`0`, and `on`/`off
 ### Fresh KNX reads
 When the user explicitly asks for a fresh/current state, the AI may query exact objects from the imported ETS catalog, including status and other read-only objects. Output 4 emits `msg.destination`, `msg.dpt`, `msg.event = "GroupValue_Read"`, and `msg.readstatus = true`. The node waits up to 6 seconds for each `GroupValue_Response` or fresh write, then returns the decoded values on output 3 and exposes details in `msg.knxAi.readResults`. Reads never require confirmation and never become writes.
 
+### Conversational multi-step routines
+Requests such as “I’m leaving”, “Good night”, or “Cinema mode” can coordinate a state-aware routine without a new editor option. In the first LLM pass, only exact ETS reads are accepted (up to 20); KNX AI sends them and supplies the fresh GA/DPT/value results to a second isolated planning pass. That pass may prepare up to 12 validated writes, but cannot request another read cycle. With confirmation enabled, the complete plan has one localized confirmation and no write or requested TTS announcement is emitted beforehand. After confirmation every write is revalidated, forwarded in order, and observed for up to 4 seconds for matching immediate bus feedback. The final reply distinguishes observed feedback from operations without immediate feedback—absence of feedback is not reported as device failure. Routine details are exposed in `msg.knxAi.routine`, `readResults`, `verifiedCount`, and `unverifiedCount`.
+
 ### Confirmation request for chat buttons
 While a plan is pending, output 3 contains `msg.knxAi.confirmationRequest`. The object includes `required`, `status`, `sessionId`, `expiresAt`, `commandCount`, and two entries in `actions`. Use `action.label` as the Telegram button text, `action.callbackData` as its callback, and send `action.message` back to KNX AI to confirm or cancel without typed text.
 
@@ -48,13 +51,15 @@ Installed camera packages can publish a camera adapter to KNX AI at runtime. The
 
 The user can ask for a current snapshot or ask the vision model what is visible. Telegram and RedBot presets emit the returned image as a native photo with a caption. The user can also create persistent notifications for motion, a smart line crossing or entry into an intrusion/loiter zone, optionally limited to detected people and to an exact named line or zone. These rules are stored in the same `knxai-chat-context.md` file and are restored after Node-RED restarts. UniFi event subscriptions and snapshot requests are made directly through the detected provider; KNX AI output 4 is not involved and no intermediate flow wiring is required.
 
+Every event published by an automatically detected adapter is normalized and appended to a daily `YYYY-MM-DD.jsonl` file under `knxultimatestorage/knxai/adapter-history/<node-id>/`. The archive keeps 10 days, guarantees more than 24 hours of history and stores event metadata rather than snapshot images. The web Assistant and every CHAT channel query it together with the KNX daily telegram archive. Totals cover every stored row in the requested interval; selected details are only a relevant sample.
+
 ### TTS Ultimate announcements
 When the optional `node-red-contrib-tts-ultimate` package is installed, it appears among the automatically detected adapters. The selector lists every `ttsultimate` node in all project flows, with its flow, node name and configured player. Choose the node that must handle chat announcements and deploy the flow.
 
 Only an explicit request in the current chat message can create an announcement. KNX AI sends the exact text directly to the selected node as `msg.payload`, with `msg.topic = "knx_ai_announcement"`; no intermediate flow wiring is required. TTS Ultimate then handles the configured Sonos player, voice, volume, hailing and queue. Persistent context, AI Education, camera content and inferred events never trigger speech by themselves.
 
 ### Chat context overview
-The node editor shows a compact card summarizing the sources available to the chat: live KNX traffic, ETS semantics and the Node-RED project, session and home memory, AI Education, detected cameras and relevant documentation. It also lists `knxai-chat-context.md`, `knxai-home-memory.md` and `knxai-config-<node-id>.json`, together with the absolute KNX telegram archive root, the node-specific archive directory and the `YYYY-MM-DD.jsonl` daily-file pattern. The paths are resolved at runtime from the data directory actually used by the configured gateway.
+The node editor shows a compact card summarizing the sources available to the chat: live and archived KNX traffic, persistent adapter events, ETS semantics and the Node-RED project, session and home memory, AI Education, detected cameras and relevant documentation. It also lists the absolute KNX telegram and adapter-event archive directories and the `YYYY-MM-DD.jsonl` daily-file pattern.
 
 ## Education-driven proactive home intelligence and bounded memory
 From ETS hierarchy, names, roles and DPTs, the node builds a deterministic semantic model for covers, windows, doors, lights, temperature, climate, occupancy and alarms using Italian, English, German, French, Spanish and Chinese terms. Its proactive detector watches only reliably recognized non-command cover/window/door states.

package/nodes/locales/en/knxUltimateAI.json

@@ -91,6 +91,7 @@
       "chatContextFilesTitle": "Persistent context files",
       "chatContextDirectoriesTitle": "KNX telegram archive",
       "chatContextSourceKnxTraffic": "Live KNX summary, anomalies, topology and selected telegrams.",
+      "chatContextSourceAdapterHistory": "Persistent daily history of automatically detected adapter events, including camera detections.",
       "chatContextSourceEtsProject": "ETS semantics and the full Node-RED project inventory.",
       "chatContextSourceMemoryEducation": "Session context, AI Education and bounded home memory.",
       "chatContextSourceCamerasDocs": "Detected cameras and relevant help, README and example snippets.",
@@ -103,6 +104,9 @@
       "chatContextDirectoryRoot": "Telegram archive root",
       "chatContextDirectoryNode": "This node's telegram archive",
       "chatContextDirectoryBadge": "KNX",
+      "chatContextDirectoryAdapterRoot": "Adapter event archive root",
+      "chatContextDirectoryAdapterNode": "This node's adapter event archive",
+      "chatContextDirectoryAdapterBadge": "Adapter",
       "chatContextTelegramPattern": "Daily files",
       "chatAdapterIntro": "Choose a mapping preset to insert its input and output code. The list is loaded from the packaged chat-adapter mappings file; the generated code remains editable.",
       "chatAdapterCodeHelp": "Mappings run synchronously. Return msg to continue or return no value to discard it. Errors are caught and reported without stopping Node-RED.",

package/nodes/locales/es/knxUltimateAI.html

@@ -33,6 +33,9 @@ Para las escrituras DPT 1.xxx, los equivalentes seguros producidos por la IA `tr
 ### Lecturas KNX actualizadas
 Cuando el usuario solicita explícitamente un estado actual o actualizado, la IA puede consultar objetos exactos del catálogo ETS importado, incluidos objetos de estado y otros objetos de solo lectura. La salida 4 emite `msg.destination`, `msg.dpt`, `msg.event = "GroupValue_Read"` y `msg.readstatus = true`. El nodo espera hasta 6 segundos cada `GroupValue_Response` o escritura reciente, devuelve los valores decodificados por la salida 3 y expone los detalles en `msg.knxAi.readResults`. Las lecturas nunca requieren confirmación ni se convierten en escrituras.
 
+### Rutinas conversacionales de varios pasos
+Solicitudes como «Me voy», «Buenas noches» o «Modo cine» pueden coordinar una rutina basada en el estado actual sin añadir opciones al editor. En la primera pasada del LLM solo se aceptan lecturas ETS exactas (hasta 20); KNX AI las envía y proporciona los resultados actualizados de GA/DPT/valor a una segunda pasada de planificación aislada. Esta puede preparar hasta 12 escrituras validadas, pero no iniciar otro ciclo de lecturas. Con la confirmación activa, todo el plan requiere una sola confirmación localizada y antes no se emite ninguna escritura ni anuncio TTS solicitado. Tras confirmar, cada escritura se vuelve a validar, se envía en orden y se observa hasta 4 segundos para detectar una respuesta inmediata coincidente en el bus. La respuesta final distingue las respuestas observadas de las operaciones sin respuesta inmediata, sin declarar por ello un fallo del dispositivo. Los detalles están disponibles en `msg.knxAi.routine`, `readResults`, `verifiedCount` y `unverifiedCount`.
+
 ### Solicitud de confirmación para botones de chat
 Mientras un plan está pendiente, la salida 3 contiene `msg.knxAi.confirmationRequest`. El objeto incluye `required`, `status`, `sessionId`, `expiresAt`, `commandCount` y dos elementos en `actions`. Usa `action.label` como texto del botón de Telegram, `action.callbackData` como callback y devuelve `action.message` a KNX AI para confirmar o cancelar sin escribir texto.
 
@@ -48,6 +51,8 @@ Los paquetes de cámaras instalados pueden publicar en tiempo de ejecución un a
 
 El usuario puede pedir una captura actual o preguntar al modelo de visión qué se ve. Los preajustes de Telegram y RedBot envían la imagen como foto nativa con pie. También se pueden crear notificaciones persistentes por movimiento, cruce de una línea inteligente o entrada en una zona de intrusión/merodeo, limitadas opcionalmente a personas detectadas y a una línea o zona concreta por nombre. Estas reglas se guardan en el mismo archivo `knxai-chat-context.md` y se restauran después de reiniciar Node-RED. Las suscripciones a eventos UniFi y las solicitudes de captura se realizan directamente a través del proveedor detectado; no interviene la salida 4 de KNX AI ni hace falta cableado intermedio en el flujo.
 
+Cada evento publicado por un adaptador detectado automáticamente se normaliza y se añade a un archivo diario `YYYY-MM-DD.jsonl` bajo `knxultimatestorage/knxai/adapter-history/<id-nodo>/`. El archivo conserva 10 días, garantiza más de 24 horas de historial y guarda metadatos, pero no imágenes. El Asistente web y todos los canales CHAT lo consultan junto con el archivo diario KNX. Los totales abarcan todas las filas almacenadas; los detalles seleccionados son solo una muestra relevante.
+
 ### Anuncios con TTS Ultimate
 Cuando está instalado el paquete opcional `node-red-contrib-tts-ultimate`, aparece entre los adaptadores detectados automáticamente. El selector muestra todos los nodos `ttsultimate` de todos los flows del proyecto, con el flow, el nombre del nodo y el reproductor configurado. Elige el nodo que gestionará los anuncios del chat y despliega el flow.
 

package/nodes/locales/es/knxUltimateAI.json

@@ -83,6 +83,7 @@
       "chatContextFilesTitle": "Archivos de contexto persistentes",
       "chatContextDirectoriesTitle": "Archivo de telegramas KNX",
       "chatContextSourceKnxTraffic": "Resumen KNX actual, anomalías, topología y telegramas seleccionados.",
+      "chatContextSourceAdapterHistory": "Historial diario persistente de eventos de los adaptadores detectados, incluidas las detecciones de cámaras.",
       "chatContextSourceEtsProject": "Semántica ETS e inventario completo del proyecto Node-RED.",
       "chatContextSourceMemoryEducation": "Contexto de sesión, Educación IA y memoria doméstica limitada.",
       "chatContextSourceCamerasDocs": "Cámaras detectadas y fragmentos relevantes de la ayuda, README y ejemplos.",
@@ -95,6 +96,9 @@
       "chatContextDirectoryRoot": "Raíz del archivo de telegramas",
       "chatContextDirectoryNode": "Archivo de telegramas de este nodo",
       "chatContextDirectoryBadge": "KNX",
+      "chatContextDirectoryAdapterRoot": "Raíz del archivo de eventos de adaptadores",
+      "chatContextDirectoryAdapterNode": "Archivo de eventos de adaptadores de este nodo",
+      "chatContextDirectoryAdapterBadge": "Adaptador",
       "chatContextTelegramPattern": "Archivos diarios",
       "chatAdapterIntro": "Elige un preajuste para insertar su código de mapeo de entrada y salida. La lista se carga desde el archivo de adaptadores de chat incluido; el código generado sigue siendo editable.",
       "chatAdapterCodeHelp": "Los mapeos se ejecutan de forma síncrona. Devuelve msg para continuar o ningún valor para descartarlo. Los errores se capturan y notifican sin detener Node-RED.",

package/nodes/locales/fr/knxUltimateAI.html

@@ -33,6 +33,9 @@ Pour les écritures DPT 1.xxx, les équivalents sûrs produits par l’IA `true`
 ### Lectures KNX actualisées
 Lorsque l’utilisateur demande explicitement un état actuel ou actualisé, l’IA peut interroger les objets exacts du catalogue ETS importé, y compris les objets d’état et autres objets en lecture seule. La sortie 4 émet `msg.destination`, `msg.dpt`, `msg.event = "GroupValue_Read"` et `msg.readstatus = true`. Le nœud attend jusqu’à 6 secondes chaque `GroupValue_Response` ou écriture récente, puis renvoie les valeurs décodées sur la sortie 3 et les détails dans `msg.knxAi.readResults`. Les lectures ne nécessitent jamais de confirmation et ne sont jamais transformées en écritures.
 
+### Routines conversationnelles multi-étapes
+Des demandes comme « Je pars », « Bonne nuit » ou « Mode cinéma » peuvent coordonner une routine tenant compte de l’état courant sans nouvelle option dans l’éditeur. Au premier passage LLM, seules les lectures ETS exactes sont acceptées (20 au maximum) ; KNX AI les envoie puis fournit les résultats actualisés GA/DPT/valeur à un second passage de planification isolé. Celui-ci peut préparer jusqu’à 12 écritures validées, sans lancer un nouveau cycle de lecture. Lorsque la confirmation est active, le plan complet ne demande qu’une confirmation localisée et aucune écriture ni annonce TTS demandée n’est émise auparavant. Après confirmation, chaque écriture est revalidée, transmise dans l’ordre et observée jusqu’à 4 secondes pour détecter un retour immédiat correspondant sur le bus. La réponse finale distingue les retours observés des opérations sans retour immédiat, sans déclarer pour autant une panne de l’appareil. Les détails figurent dans `msg.knxAi.routine`, `readResults`, `verifiedCount` et `unverifiedCount`.
+
 ### Demande de confirmation pour les boutons du chat
 Lorsqu'un plan est en attente, la sortie 3 contient `msg.knxAi.confirmationRequest`. L'objet comprend `required`, `status`, `sessionId`, `expiresAt`, `commandCount` et deux éléments dans `actions`. Utilisez `action.label` comme texte du bouton Telegram, `action.callbackData` comme callback et renvoyez `action.message` à KNX AI pour confirmer ou annuler sans saisir de texte.
 
@@ -48,6 +51,8 @@ Les paquets de caméra installés peuvent publier à l’exécution un adaptateu
 
 L’utilisateur peut demander une capture actuelle ou demander au modèle de vision ce qui est visible. Les préréglages Telegram et RedBot envoient l’image comme photo native avec une légende. L’utilisateur peut aussi créer des notifications persistantes pour un mouvement, le franchissement d’une ligne intelligente ou l’entrée dans une zone d’intrusion/de stationnement, avec une limitation facultative aux personnes détectées et à une ligne ou zone nommée précise. Ces règles sont stockées dans le même fichier `knxai-chat-context.md` et restaurées après les redémarrages de Node-RED. Les abonnements aux événements UniFi et les demandes de capture passent directement par le fournisseur détecté ; la sortie 4 de KNX AI et un câblage intermédiaire ne sont pas nécessaires.
 
+Chaque événement publié par un adaptateur détecté automatiquement est normalisé puis ajouté à un fichier quotidien `YYYY-MM-DD.jsonl` sous `knxultimatestorage/knxai/adapter-history/<id-nœud>/`. L’archive conserve 10 jours, garantit plus de 24 heures d’historique et stocke les métadonnées, mais pas les images. L’Assistant web et tous les canaux CHAT l’interrogent avec l’archive quotidienne KNX. Les totaux couvrent toutes les lignes stockées ; les détails sélectionnés ne sont qu’un échantillon pertinent.
+
 ### Annonces avec TTS Ultimate
 Lorsque le paquet facultatif `node-red-contrib-tts-ultimate` est installé, il apparaît parmi les adaptateurs détectés automatiquement. Le sélecteur recense tous les nœuds `ttsultimate` de tous les flows du projet, avec le flow, le nom du nœud et le lecteur configuré. Sélectionnez le nœud chargé des annonces du chat, puis déployez le flow.
 

package/nodes/locales/fr/knxUltimateAI.json

@@ -83,6 +83,7 @@
       "chatContextFilesTitle": "Fichiers de contexte persistants",
       "chatContextDirectoriesTitle": "Archive des télégrammes KNX",
       "chatContextSourceKnxTraffic": "Résumé KNX actuel, anomalies, topologie et télégrammes sélectionnés.",
+      "chatContextSourceAdapterHistory": "Historique quotidien persistant des événements des adaptateurs détectés, y compris les détections des caméras.",
       "chatContextSourceEtsProject": "Sémantique ETS et inventaire complet du projet Node-RED.",
       "chatContextSourceMemoryEducation": "Contexte de session, Éducation IA et mémoire domestique limitée.",
       "chatContextSourceCamerasDocs": "Caméras détectées et extraits pertinents de l'aide, du README et des exemples.",
@@ -95,6 +96,9 @@
       "chatContextDirectoryRoot": "Racine de l'archive des télégrammes",
       "chatContextDirectoryNode": "Archive des télégrammes de ce nœud",
       "chatContextDirectoryBadge": "KNX",
+      "chatContextDirectoryAdapterRoot": "Racine de l’archive des événements des adaptateurs",
+      "chatContextDirectoryAdapterNode": "Archive des événements des adaptateurs de ce nœud",
+      "chatContextDirectoryAdapterBadge": "Adaptateur",
       "chatContextTelegramPattern": "Fichiers quotidiens",
       "chatAdapterIntro": "Choisissez un préréglage pour insérer son code de mappage d’entrée et de sortie. La liste est chargée depuis le fichier d’adaptateurs de chat fourni ; le code généré reste modifiable.",
       "chatAdapterCodeHelp": "Les mappages s’exécutent de façon synchrone. Renvoyez msg pour continuer ou aucune valeur pour l’écarter. Les erreurs sont interceptées et signalées sans arrêter Node-RED.",

package/nodes/locales/it/knxUltimateAI.html

@@ -33,6 +33,9 @@ Per le scritture DPT 1.xxx, gli equivalenti sicuri prodotti dall'AI `true`/`fals
 ### Letture KNX aggiornate
 Quando l'utente chiede esplicitamente uno stato attuale o aggiornato, l'AI può interrogare gli oggetti esatti del catalogo ETS importato, compresi gli oggetti di stato e di sola lettura. L'uscita 4 emette `msg.destination`, `msg.dpt`, `msg.event = "GroupValue_Read"` e `msg.readstatus = true`. Il nodo attende fino a 6 secondi ogni `GroupValue_Response` o scrittura fresca, poi restituisce i valori decodificati sull'uscita 3 e i dettagli in `msg.knxAi.readResults`. Le letture non richiedono mai conferma e non vengono mai trasformate in scritture.
 
+### Routine conversazionali multi-step
+Richieste come «Sto uscendo», «Buonanotte» o «Modalità cinema» possono coordinare una routine basata sullo stato corrente senza aggiungere opzioni all'editor. Nel primo passaggio LLM vengono accettate soltanto letture ETS esatte (massimo 20); KNX AI le invia e passa i risultati aggiornati GA/DPT/valore a un secondo passaggio di pianificazione isolato. Quest'ultimo può preparare fino a 12 scritture validate, ma non può avviare un altro ciclo di letture. Con la conferma attiva, l'intero piano richiede una sola conferma localizzata e nessuna scrittura o annuncio TTS richiesto viene emesso prima. Dopo la conferma ogni scrittura viene rivalidata, inoltrata in ordine e osservata fino a 4 secondi per un feedback immediato corrispondente sul bus. La risposta finale distingue il feedback osservato dalle operazioni senza feedback immediato, senza considerare queste ultime come dispositivi guasti. I dettagli sono disponibili in `msg.knxAi.routine`, `readResults`, `verifiedCount` e `unverifiedCount`.
+
 ### Richiesta di conferma per pulsanti chat
 Quando un piano è in attesa, l'uscita 3 contiene `msg.knxAi.confirmationRequest`. L'oggetto include `required`, `status`, `sessionId`, `expiresAt`, `commandCount` e due elementi in `actions`. Usa `action.label` per il testo del pulsante Telegram, `action.callbackData` per il callback e reinvia `action.message` al nodo KNX AI per confermare o annullare senza digitare testo.
 
@@ -48,13 +51,15 @@ I pacchetti di telecamere installati possono pubblicare a runtime un adapter per
 
 L'utente può chiedere uno snapshot aggiornato oppure domandare al modello vision che cosa è visibile. I preset Telegram e RedBot inviano l'immagine come foto nativa con didascalia. L'utente può anche creare notifiche persistenti per movimento, attraversamento di una linea intelligente o ingresso in una zona di intrusione/stazionamento, limitandole facoltativamente alle persone rilevate e a una linea o zona nominata esatta. Le regole vengono salvate nello stesso file `knxai-chat-context.md` e ripristinate dopo i riavvii di Node-RED. Le sottoscrizioni agli eventi UniFi e le richieste snapshot avvengono direttamente tramite il provider rilevato: l'uscita 4 di KNX AI non è coinvolta e non servono collegamenti intermedi nel flow.
 
+Ogni evento pubblicato da un adapter rilevato automaticamente viene normalizzato e aggiunto a un file giornaliero `YYYY-MM-DD.jsonl` sotto `knxultimatestorage/knxai/adapter-history/<id-nodo>/`. L'archivio conserva 10 giorni, garantisce più di 24 ore di storico e salva i metadati degli eventi, non le immagini. Assistente web e canali CHAT lo interrogano insieme all'archivio giornaliero KNX. I totali comprendono tutte le righe memorizzate nell'intervallo richiesto; i dettagli selezionati sono soltanto un campione pertinente.
+
 ### Annunci con TTS Ultimate
 Quando è installato il pacchetto opzionale `node-red-contrib-tts-ultimate`, questo compare tra gli adapter rilevati automaticamente. Il selettore elenca tutti i nodi `ttsultimate` presenti in tutti i flow del progetto, indicando flow, nome del nodo e player configurato. Scegli il nodo che deve gestire gli annunci della chat e fai il deploy del flow.
 
 Solo una richiesta esplicita nel messaggio corrente della chat può creare un annuncio. KNX AI invia il testo esatto direttamente al nodo scelto come `msg.payload`, con `msg.topic = "knx_ai_announcement"`; non servono collegamenti intermedi nel flow. TTS Ultimate gestisce poi il player Sonos configurato, voce, volume, hailing e coda. Contesto persistente, Educazione AI, contenuto delle telecamere ed eventi dedotti non attivano mai autonomamente la voce.
 
 ### Riepilogo del contesto della chat
-L'editor del nodo mostra una scheda compatta con le fonti disponibili alla chat: traffico KNX corrente, semantica ETS e progetto Node-RED, memoria di sessione e domestica, Educazione AI, telecamere rilevate e documentazione pertinente. Elenca inoltre `knxai-chat-context.md`, `knxai-home-memory.md` e `knxai-config-<id-nodo>.json`, insieme alla radice assoluta dell'archivio telegrammi KNX, alla cartella specifica del nodo e al formato giornaliero `YYYY-MM-DD.jsonl`. I percorsi vengono risolti a runtime dalla directory dati realmente usata dal gateway configurato.
+L'editor del nodo mostra una scheda compatta con le fonti disponibili alla chat: traffico KNX corrente e archiviato, eventi persistenti degli adapter, semantica ETS e progetto Node-RED, memoria di sessione e domestica, Educazione AI, telecamere rilevate e documentazione pertinente. Elenca anche le directory assolute degli archivi KNX e degli eventi adapter e il formato giornaliero `YYYY-MM-DD.jsonl`.
 
 ## Intelligenza domestica proattiva guidata dall'Educazione e memoria limitata
 Da gerarchia ETS, nomi, ruoli e DPT, il nodo crea un modello semantico deterministico per persiane, finestre, porte, luci, temperatura, clima, presenza e allarmi usando termini italiani, inglesi, tedeschi, francesi, spagnoli e cinesi. Il rilevatore proattivo osserva soltanto stati non di comando di persiane, finestre e porte riconosciuti con sufficiente affidabilità.

package/nodes/locales/it/knxUltimateAI.json

@@ -91,6 +91,7 @@
       "chatContextFilesTitle": "File persistenti di contesto",
       "chatContextDirectoriesTitle": "Archivio telegrammi KNX",
       "chatContextSourceKnxTraffic": "Riepilogo KNX corrente, anomalie, topologia e telegrammi selezionati.",
+      "chatContextSourceAdapterHistory": "Storico giornaliero persistente degli eventi degli adapter rilevati, comprese le rilevazioni delle telecamere.",
       "chatContextSourceEtsProject": "Semantica ETS e inventario completo del progetto Node-RED.",
       "chatContextSourceMemoryEducation": "Contesto di sessione, Educazione AI e memoria domestica limitata.",
       "chatContextSourceCamerasDocs": "Telecamere rilevate ed estratti pertinenti da help, README ed esempi.",
@@ -103,6 +104,9 @@
       "chatContextDirectoryRoot": "Radice archivio telegrammi",
       "chatContextDirectoryNode": "Archivio telegrammi di questo nodo",
       "chatContextDirectoryBadge": "KNX",
+      "chatContextDirectoryAdapterRoot": "Radice archivio eventi adapter",
+      "chatContextDirectoryAdapterNode": "Archivio eventi adapter di questo nodo",
+      "chatContextDirectoryAdapterBadge": "Adapter",
       "chatContextTelegramPattern": "File giornalieri",
       "chatAdapterIntro": "Scegli un preset per inserire il codice di mappatura in ingresso e in uscita. La lista viene caricata dal file degli adattatori chat incluso nel pacchetto; il codice generato resta modificabile.",
       "chatAdapterCodeHelp": "Le mappature sono sincrone. Restituisci msg per continuare oppure nessun valore per scartarlo. Gli errori vengono intercettati e segnalati senza arrestare Node-RED.",

package/nodes/locales/zh-CN/knxUltimateAI.html

@@ -33,6 +33,9 @@ Canvas 上的节点状态专门用于显示最近收到的请求，以及 LLM
 ### 最新 KNX 读取
 当用户明确要求当前或最新状态时，AI 可以查询已导入 ETS 目录中的精确对象，包括状态对象和其他只读对象。输出 4 会发送 `msg.destination`、`msg.dpt`、`msg.event = "GroupValue_Read"` 和 `msg.readstatus = true`。节点会为每个 `GroupValue_Response` 或最新写入等待最多 6 秒，然后在输出 3 返回解码值，并在 `msg.knxAi.readResults` 中提供详细信息。读取从不需要确认，也绝不会转换为写入。
 
+### 多步骤对话例行程序
+“我要离家”“晚安”或“影院模式”等请求可以在不增加编辑器选项的情况下，根据当前状态协调例行程序。第一次 LLM 处理仅接受精确的 ETS 读取（最多 20 个）；KNX AI 发送读取，并把最新的 GA/DPT/值结果交给隔离的第二次规划处理。第二次处理最多可准备 12 个已验证写入，但不能再次发起读取循环。启用确认时，整个计划只需一次本地化确认；确认前不会发送任何写入或所请求的 TTS 播报。确认后，每个写入都会重新验证、按顺序转发，并在最多 4 秒内观察总线上匹配的即时反馈。最终回复会区分已观察到反馈的操作与没有即时反馈的操作，但不会把后者报告为设备故障。详细信息位于 `msg.knxAi.routine`、`readResults`、`verifiedCount` 和 `unverifiedCount`。
+
 ### 用于聊天按钮的确认请求
 计划等待确认时，输出 3 包含 `msg.knxAi.confirmationRequest`。该对象包括 `required`、`status`、`sessionId`、`expiresAt`、`commandCount`，以及 `actions` 中的两个项目。使用 `action.label` 作为 Telegram 按钮文本，使用 `action.callbackData` 作为回调，并将 `action.message` 发送回 KNX AI，即可在无需输入文本的情况下确认或取消。
 
@@ -48,6 +51,8 @@ Canvas 上的节点状态专门用于显示最近收到的请求，以及 LLM
 
 用户可以请求当前快照，或询问视觉模型画面中可见的内容。Telegram 和 RedBot 预设会把图像作为带说明文字的原生照片发送。用户还可以为移动、智能越线或进入入侵/徘徊区域创建持久通知，并可按检测到的人员以及指定名称的线或区域进行限制。这些规则保存在同一个 `knxai-chat-context.md` 文件中，并在 Node-RED 重启后恢复。UniFi 事件订阅和快照请求直接通过检测到的提供方完成；不会使用 KNX AI 输出 4，也不需要中间 Flow 连线。
 
+自动检测到的适配器发布的每个事件都会被标准化，并追加到 `knxultimatestorage/knxai/adapter-history/<节点ID>/` 下的每日 `YYYY-MM-DD.jsonl` 文件。存档保留 10 天，保证超过 24 小时的历史，只保存事件元数据，不保存图像。Web 助手和所有 CHAT 渠道会同时查询它与每日 KNX 报文存档。总数涵盖所请求区间内的全部存档行；选出的详情仅是相关样本。
+
 ### 使用 TTS Ultimate 播报
 安装可选软件包 `node-red-contrib-tts-ultimate` 后，它会显示在自动检测的适配器中。选择器会列出项目所有 Flow 中的全部 `ttsultimate` 节点，并显示 Flow、节点名称和已配置的播放器。请选择负责聊天播报的节点，然后部署 Flow。
 

package/nodes/locales/zh-CN/knxUltimateAI.json

@@ -83,6 +83,7 @@
       "chatContextFilesTitle": "持久化上下文文件",
       "chatContextDirectoriesTitle": "KNX 报文归档",
       "chatContextSourceKnxTraffic": "当前 KNX 摘要、异常、拓扑和选定报文。",
+      "chatContextSourceAdapterHistory": "自动检测到的适配器事件的持久每日历史记录，包括摄像机检测事件。",
       "chatContextSourceEtsProject": "ETS 语义和完整的 Node-RED 项目清单。",
       "chatContextSourceMemoryEducation": "会话上下文、AI 教育和有界家庭记忆。",
       "chatContextSourceCamerasDocs": "检测到的摄像机以及相关帮助、README 和示例片段。",
@@ -95,6 +96,9 @@
       "chatContextDirectoryRoot": "报文归档根目录",
       "chatContextDirectoryNode": "此节点的报文归档",
       "chatContextDirectoryBadge": "KNX",
+      "chatContextDirectoryAdapterRoot": "适配器事件存档根目录",
+      "chatContextDirectoryAdapterNode": "此节点的适配器事件存档",
+      "chatContextDirectoryAdapterBadge": "适配器",
       "chatContextTelegramPattern": "每日文件",
       "chatAdapterIntro": "选择预设即可插入输入和输出映射代码。列表从随包提供的聊天适配器文件加载；生成的代码仍可编辑。",
       "chatAdapterCodeHelp": "映射同步运行。返回 msg 以继续，或不返回值以丢弃消息。错误会被捕获并报告，不会停止 Node-RED。",

package/nodes/utils/knxAiEventHistory.js

@@ -0,0 +1,246 @@
+const KNX_AI_ADAPTER_HISTORY_MIN_HOURS = 24
+const KNX_AI_HISTORY_DETAILS_MAX_CHARS = 12000
+
+const clampText = (value, maxChars = 500) => String(value === undefined || value === null ? '' : value)
+  .trim()
+  .slice(0, Math.max(0, Number(maxChars) || 0))
+
+const normalizeSearchText = value => clampText(value, 4000)
+  .normalize('NFKD')
+  .replace(/[\u0300-\u036f]/g, '')
+  .toLocaleLowerCase()
+  .replace(/[^a-z0-9./_-]+/g, ' ')
+  .trim()
+
+const parseTimestamp = (value, fallback = Date.now()) => {
+  if (typeof value === 'number' && Number.isFinite(value)) return value > 100000000000 ? value : value * 1000
+  const parsed = new Date(String(value || '')).getTime()
+  return Number.isFinite(parsed) ? parsed : fallback
+}
+
+const sanitizeHistoryValue = (value, depth = 0, seen = new Set()) => {
+  if (value === null || value === undefined) return value
+  if (typeof value === 'string') return clampText(value, 1000)
+  if (typeof value === 'number' || typeof value === 'boolean') return value
+  if (typeof value === 'bigint') return String(value)
+  if (Buffer.isBuffer(value)) return `[binary ${value.length} bytes]`
+  if (typeof value !== 'object') return clampText(value, 1000)
+  if (depth >= 3 || seen.has(value)) return '[nested]'
+  seen.add(value)
+  if (Array.isArray(value)) {
+    const out = value.slice(0, 30).map(item => sanitizeHistoryValue(item, depth + 1, seen))
+    seen.delete(value)
+    return out
+  }
+  const out = {}
+  Object.keys(value).slice(0, 60).forEach(key => {
+    const normalizedKey = clampText(key, 120)
+    if (!normalizedKey || /^(data|image|snapshot|buffer|base64)$/i.test(normalizedKey)) return
+    out[normalizedKey] = sanitizeHistoryValue(value[key], depth + 1, seen)
+  })
+  seen.delete(value)
+  return out
+}
+
+const normalizeKnxAiAdapterHistoryEvent = ({ event, adapter, provider, nowTs = Date.now() } = {}) => {
+  const source = event && typeof event === 'object' && !Array.isArray(event) ? event : {}
+  const adapterSource = adapter && typeof adapter === 'object' ? adapter : {}
+  const providerSource = provider && typeof provider === 'object' ? provider : {}
+  const ts = parseTimestamp(source.ts || source.timestamp || source.at || source.start || source.date, nowTs)
+  const eventType = clampText(source.eventType || source.type || source.event || source.kind, 120)
+  if (!eventType) return null
+  const cameraId = clampText(source.cameraId || source.resourceId || source.deviceId, 200)
+  const cameraName = clampText(source.cameraName || source.resourceName || source.deviceName, 300)
+  const details = sanitizeHistoryValue(source.raw || source.details || source.metadata || {})
+  let detailsText = ''
+  try { detailsText = JSON.stringify(details) } catch (error) { detailsText = '' }
+  return {
+    ts,
+    at: new Date(ts).toISOString(),
+    adapterId: clampText(source.adapterId || providerSource.adapterId || adapterSource.id, 160),
+    adapterTitle: clampText(source.adapterTitle || adapterSource.title || adapterSource.name, 240),
+    providerId: clampText(source.providerId || providerSource.id, 220),
+    providerTitle: clampText(source.providerTitle || providerSource.title || providerSource.name, 240),
+    controllerId: clampText(source.controllerId || providerSource.controllerId, 180),
+    controllerName: clampText(source.controllerName || providerSource.controllerName, 240),
+    resourceType: clampText(source.resourceType || (cameraId || cameraName ? 'camera' : 'adapter'), 80),
+    resourceId: cameraId,
+    resourceName: cameraName,
+    eventType,
+    eventId: clampText(source.eventId || source.id, 200),
+    active: source.active !== false,
+    scopeId: clampText(source.scopeId, 180),
+    scopeName: clampText(source.scopeName, 240),
+    objectTypes: Array.from(new Set((Array.isArray(source.objectTypes) ? source.objectTypes : [])
+      .map(value => clampText(value, 100))
+      .filter(Boolean))).slice(0, 24),
+    details: detailsText.length <= KNX_AI_HISTORY_DETAILS_MAX_CHARS ? details : { truncated: true }
+  }
+}
+
+const HISTORY_STOP_WORDS = new Set([
+  'a', 'al', 'alla', 'alle', 'anche', 'and', 'auf', 'aux', 'avec', 'che', 'con', 'da', 'dal', 'dalla', 'das', 'de', 'dei', 'del', 'della', 'des', 'di', 'die', 'do', 'du', 'e', 'el', 'en', 'et', 'for', 'gli', 'ha', 'hanno', 'i', 'il', 'in', 'is', 'la', 'le', 'les', 'lo', 'mit', 'nel', 'nella', 'of', 'on', 'or', 'per', 'pour', 'que', 'qui', 'se', 'sono', 'su', 'the', 'to', 'tra', 'un', 'una', 'und', 'was', 'what', 'with', 'zu'
+])
+
+const historyQuestionTokens = question => Array.from(new Set(normalizeSearchText(question)
+  .split(/\s+/)
+  .filter(token => token.length >= 2 && !HISTORY_STOP_WORDS.has(token) && !/^\d{1,4}$/.test(token))))
+  .slice(0, 24)
+
+const incrementCount = (map, key) => {
+  const normalized = clampText(key, 500) || '(unknown)'
+  map.set(normalized, Number(map.get(normalized) || 0) + 1)
+}
+
+const topCounts = (map, limit) => Array.from(map.entries())
+  .map(([key, count]) => ({ key, count }))
+  .sort((left, right) => right.count - left.count || left.key.localeCompare(right.key))
+  .slice(0, Math.max(1, Number(limit) || 1))
+
+const buildEventSearchText = (event, kind) => {
+  if (kind === 'knx') {
+    return normalizeSearchText([
+      event.event,
+      event.source,
+      event.destination,
+      event.devicename,
+      event.dpt,
+      event.payloadmeasureunit,
+      typeof event.payload === 'object' ? JSON.stringify(event.payload) : event.payload
+    ].join(' '))
+  }
+  return normalizeSearchText([
+    event.adapterId,
+    event.adapterTitle,
+    event.providerId,
+    event.providerTitle,
+    event.controllerId,
+    event.controllerName,
+    event.resourceType,
+    event.resourceId,
+    event.resourceName,
+    event.eventType,
+    event.scopeId,
+    event.scopeName,
+    ...(Array.isArray(event.objectTypes) ? event.objectTypes : []),
+    event.details && typeof event.details === 'object' ? JSON.stringify(event.details) : ''
+  ].join(' '))
+}
+
+const buildKnxAiHistoryEventKey = (event, kind = 'adapter') => {
+  if (!event || typeof event !== 'object') return ''
+  if (kind === 'knx') {
+    let payload = ''
+    try { payload = typeof event.payload === 'object' ? JSON.stringify(event.payload) : String(event.payload) } catch (error) { payload = '' }
+    return [Number(event.ts || 0), event.event, event.source, event.destination, payload, event.rawHex].join('|')
+  }
+  return [Number(event.ts || 0), event.adapterId, event.providerId, event.resourceId, event.eventType, event.eventId, event.scopeId, (event.objectTypes || []).join(',')].join('|')
+}
+
+const createKnxAiHistoryAccumulator = ({ kind = 'adapter', question = '', limit = 120 } = {}) => {
+  const normalizedKind = kind === 'knx' ? 'knx' : 'adapter'
+  const maxItems = Math.max(1, Number(limit) || 120)
+  const tokens = historyQuestionTokens(question)
+  const recent = []
+  const relevant = []
+  const counts = {
+    byEvent: new Map(),
+    bySource: new Map(),
+    byResource: new Map(),
+    byObjectType: new Map(),
+    byCombination: new Map()
+  }
+  let total = 0
+  let active = 0
+  let firstTs = 0
+  let lastTs = 0
+
+  const add = event => {
+    if (!event || typeof event !== 'object') return
+    const ts = Number(event.ts || new Date(event.at || '').getTime() || 0)
+    if (!Number.isFinite(ts) || ts <= 0) return
+    total += 1
+    if (event.active !== false) active += 1
+    firstTs = firstTs > 0 ? Math.min(firstTs, ts) : ts
+    lastTs = Math.max(lastTs, ts)
+    const eventName = normalizedKind === 'knx' ? event.event : event.eventType
+    const sourceName = normalizedKind === 'knx'
+      ? event.source
+      : (event.adapterTitle || event.adapterId || event.providerTitle || event.providerId)
+    const resourceName = normalizedKind === 'knx'
+      ? `${event.destination || '?'}${event.devicename ? ` (${event.devicename})` : ''}`
+      : (event.resourceName || event.resourceId || event.controllerName || event.controllerId)
+    incrementCount(counts.byEvent, eventName)
+    incrementCount(counts.bySource, sourceName)
+    incrementCount(counts.byResource, resourceName)
+    ;(Array.isArray(event.objectTypes) ? event.objectTypes : []).forEach(value => incrementCount(counts.byObjectType, value))
+    const combination = normalizedKind === 'knx'
+      ? `${resourceName || '?'} | ${eventName || '?'} | ${clampText(typeof event.payload === 'object' ? JSON.stringify(event.payload) : event.payload, 160)}`
+      : `${resourceName || '?'} | ${eventName || '?'}${event.scopeName ? ` | ${event.scopeName}` : ''}${event.objectTypes && event.objectTypes.length ? ` | ${event.objectTypes.join(',')}` : ''}`
+    incrementCount(counts.byCombination, combination)
+
+    recent.push(event)
+    if (recent.length > maxItems) recent.shift()
+    if (tokens.length) {
+      const haystack = buildEventSearchText(event, normalizedKind)
+      let score = 0
+      tokens.forEach(token => { if (haystack.includes(token)) score += token.length + 2 })
+      if (score > 0) {
+        relevant.push({ event, score, ts })
+        if (relevant.length > maxItems * 4) {
+          relevant.sort((left, right) => right.score - left.score || right.ts - left.ts)
+          relevant.length = maxItems * 2
+        }
+      }
+    }
+  }
+
+  const finish = () => {
+    let events = recent
+    if (relevant.length) {
+      const selected = relevant
+        .sort((left, right) => right.score - left.score || right.ts - left.ts)
+        .slice(0, maxItems)
+        .map(item => item.event)
+      events = selected.sort((left, right) => Number(left.ts || 0) - Number(right.ts || 0))
+    }
+    return {
+      events,
+      summary: {
+        kind: normalizedKind,
+        totalEvents: total,
+        activeEvents: active,
+        inactiveEvents: total - active,
+        firstAt: firstTs ? new Date(firstTs).toISOString() : '',
+        lastAt: lastTs ? new Date(lastTs).toISOString() : '',
+        selection: relevant.length ? 'question-relevant' : 'most-recent',
+        selectedEvents: events.length,
+        byEvent: topCounts(counts.byEvent, 20),
+        bySource: topCounts(counts.bySource, 12),
+        byResource: topCounts(counts.byResource, 30),
+        byObjectType: topCounts(counts.byObjectType, 20),
+        byCombination: topCounts(counts.byCombination, 40)
+      }
+    }
+  }
+
+  return { add, finish }
+}
+
+const formatKnxAiAdapterHistoryEventForPrompt = event => {
+  if (!event || typeof event !== 'object') return ''
+  const resource = event.resourceName || event.resourceId || event.controllerName || event.controllerId || '?'
+  const scope = event.scopeName || event.scopeId
+  const objects = Array.isArray(event.objectTypes) && event.objectTypes.length ? event.objectTypes.join(',') : ''
+  return `${event.at || new Date(event.ts || Date.now()).toISOString()} | adapter ${event.adapterTitle || event.adapterId || '?'} | ${event.resourceType || 'resource'} ${resource} | ${event.eventType || '?'} | ${event.active === false ? 'inactive' : 'active'}${scope ? ` | scope ${scope}` : ''}${objects ? ` | objects ${objects}` : ''}`
+}
+
+module.exports = {
+  KNX_AI_ADAPTER_HISTORY_MIN_HOURS,
+  KNX_AI_HISTORY_DETAILS_MAX_CHARS,
+  buildKnxAiHistoryEventKey,
+  createKnxAiHistoryAccumulator,
+  formatKnxAiAdapterHistoryEventForPrompt,
+  normalizeKnxAiAdapterHistoryEvent,
+  sanitizeHistoryValue
+}

package/package.json

@@ -3,7 +3,7 @@
   "engines": {
     "node": ">=20.18.1"
   },
-  "version": "6.3.18",
+  "version": "6.3.21",
   "description": "KNX Ultimate is the most advanced KNX integration for Node-RED, providing secure KNX/IP communication, routing, ETS project import, Philips Hue, Matter Controller and Matter Bridge (control matter device via KNX and expose KNX GA via Matter), MQTT, diagnostics with AI, virtual devices, and powerful automation nodes. Build professional, reliable, and scalable smart home and building automation projects with minimal effort.",
   "files": [
     "nodes/",