node-red-contrib-knx-ultimate 6.3.32 → 6.4.1

package/nodes/knxUltimateAIHomeAssistant.html

@@ -0,0 +1,38 @@
+<script type="text/javascript">
+    RED.nodes.registerType('knxUltimateAIHomeAssistant', {
+        category: "KNX Ultimate AI",
+        color: '#41BDF5',
+        defaults: {
+            name: { value: "Cerebrum Home Assistant" },
+            requestTimeoutMs: { value: 15000, validate: RED.validators.number() }
+        },
+        inputs: 1,
+        outputs: 1,
+        outputLabels: function () { return "ha-api request"; },
+        icon: "font-awesome/fa-home",
+        label: function () { return this.name || "Cerebrum Home Assistant"; },
+        paletteLabel: "Cerebrum Home Assistant"
+    });
+</script>
+
+<script type="text/html" data-template-name="knxUltimateAIHomeAssistant">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-requestTimeoutMs"><i class="fa fa-clock-o"></i> API timeout</label>
+        <input type="number" id="node-input-requestTimeoutMs" min="3000" max="60000" step="1000">
+    </div>
+    <div class="form-tips">
+        Connect this node's output to a Home Assistant <b>API</b> node (<code>ha-api</code>), then connect the API output back to this node's input. Home Assistant event nodes may also feed this input so Cerebrum can observe their state changes.
+    </div>
+</script>
+
+<script type="text/html" data-help-name="knxUltimateAIHomeAssistant">
+    <p>Connects Cerebrum to the Home Assistant Node-RED API node without storing Home Assistant credentials in KNX Ultimate.</p>
+    <h3>Required round trip</h3>
+    <p><code>Cerebrum Home Assistant → API (ha-api) → Cerebrum Home Assistant</code></p>
+    <p>The bridge sends dynamic WebSocket requests under <code>msg.payload</code>, correlates the returned message and exposes entity, state, service and event capabilities to the in-process Cerebrum registry.</p>
+    <p>Writes are only a provider capability. KNX AI must still apply its normal proposal, validation and confirmation policy before a Home Assistant service call can be executed.</p>
+</script>

package/nodes/knxUltimateAIHomeAssistant.js

@@ -0,0 +1,152 @@
+const {
+  getKnxAiHomeAutomationRegistry,
+  normalizeKnxAiHomeAutomationEvent
+} = require('./utils/knxAiCerebrum')
+
+const HOME_ASSISTANT_ADAPTER_ID = 'home-assistant'
+const DEFAULT_REQUEST_TIMEOUT_MS = 15000
+
+module.exports = function (RED) {
+  function knxUltimateAIHomeAssistant (config) {
+    RED.nodes.createNode(this, config)
+    const node = this
+    const registry = getKnxAiHomeAutomationRegistry()
+    const requestTimeoutMs = Math.max(3000, Math.min(60000, Number(config.requestTimeoutMs) || DEFAULT_REQUEST_TIMEOUT_MS))
+    const pendingRequests = new Map()
+    const listeners = new Set()
+    let requestSequence = 0
+    let closing = false
+
+    node.name = config.name || 'Cerebrum Home Assistant'
+
+    const updateStatus = ({ fill = 'grey', shape = 'ring', text = '' } = {}) => {
+      try { node.status({ fill, shape, text }) } catch (error) { /* ignore */ }
+    }
+
+    const notifyEvent = event => {
+      listeners.forEach(listener => {
+        try { listener(event) } catch (error) { /* ignore */ }
+      })
+    }
+
+    const sendApiRequest = data => new Promise((resolve, reject) => {
+      if (closing) return reject(new Error('Cerebrum Home Assistant is closing'))
+      requestSequence += 1
+      const requestId = `${node.id}:${Date.now()}:${requestSequence}`
+      const timer = setTimeout(() => {
+        pendingRequests.delete(requestId)
+        updateStatus({ fill: 'yellow', shape: 'ring', text: 'ha-api timeout' })
+        reject(new Error('Home Assistant ha-api request timed out; verify the round-trip wiring'))
+      }, requestTimeoutMs)
+      pendingRequests.set(requestId, { resolve, reject, timer })
+      node.send({
+        payload: {
+          protocol: 'websocket',
+          data,
+          location: 'payload',
+          locationType: 'msg'
+        },
+        knxAiCerebrum: {
+          requestId,
+          adapterId: HOME_ASSISTANT_ADAPTER_ID,
+          providerId: node.id,
+          direction: 'request'
+        }
+      })
+      updateStatus({ fill: 'blue', shape: 'dot', text: 'querying ha-api' })
+    })
+
+    const provider = {
+      id: node.id,
+      adapterId: HOME_ASSISTANT_ADAPTER_ID,
+      title: node.name,
+      capabilities: ['entities', 'events', 'services', 'states'],
+      listEntities: () => sendApiRequest({ type: 'get_states' }).then(result => Array.isArray(result) ? result : []),
+      getEntity: entityId => sendApiRequest({ type: 'get_states' }).then(result => {
+        const requested = String(entityId || '').trim().toLowerCase()
+        return (Array.isArray(result) ? result : []).find(entity => String(entity && entity.entity_id || '').trim().toLowerCase() === requested) || null
+      }),
+      listServices: () => sendApiRequest({ type: 'get_services' }),
+      callService: ({ domain, service, serviceData, target, authorization } = {}) => {
+        const safeDomain = String(domain || '').trim()
+        const safeService = String(service || '').trim()
+        if (!safeDomain || !safeService) return Promise.reject(new Error('Home Assistant domain and service are required'))
+        if (!authorization || authorization.confirmed !== true || authorization.source !== 'knxUltimateAI') {
+          return Promise.reject(new Error('Home Assistant service calls require an explicit KNX AI confirmation authorization'))
+        }
+        return sendApiRequest({
+          type: 'call_service',
+          domain: safeDomain,
+          service: safeService,
+          service_data: serviceData && typeof serviceData === 'object' ? serviceData : {},
+          target: target && typeof target === 'object' ? target : {}
+        })
+      },
+      subscribe: listener => {
+        if (typeof listener !== 'function') return () => {}
+        listeners.add(listener)
+        return () => listeners.delete(listener)
+      }
+    }
+
+    registry.registerAdapter({
+      id: HOME_ASSISTANT_ADAPTER_ID,
+      title: 'Home Assistant',
+      packageName: 'node-red-contrib-home-assistant-websocket',
+      capabilities: provider.capabilities
+    })
+    registry.registerProvider(provider)
+
+    node.on('input', function (msg, send, done) {
+      try {
+        const metadata = msg && msg.knxAiCerebrum && typeof msg.knxAiCerebrum === 'object' ? msg.knxAiCerebrum : {}
+        const requestId = String(metadata.requestId || '')
+        const pending = requestId ? pendingRequests.get(requestId) : null
+        if (pending) {
+          clearTimeout(pending.timer)
+          pendingRequests.delete(requestId)
+          if (msg && msg.error) pending.reject(new Error(String(msg.error.message || msg.error)))
+          else pending.resolve(msg ? msg.payload : undefined)
+          updateStatus({ fill: 'green', shape: 'dot', text: 'ha-api ready' })
+          if (typeof done === 'function') done()
+          return
+        }
+
+        const event = normalizeKnxAiHomeAutomationEvent(msg, {
+          adapterId: HOME_ASSISTANT_ADAPTER_ID,
+          providerId: node.id
+        })
+        if (event) {
+          notifyEvent(event)
+          updateStatus({ fill: 'green', shape: 'dot', text: event.entityId || event.eventType })
+        }
+        if (typeof done === 'function') done()
+      } catch (error) {
+        updateStatus({ fill: 'red', shape: 'dot', text: error.message || String(error) })
+        if (typeof done === 'function') done(error)
+        else node.error(error, msg)
+      }
+    })
+
+    node.on('close', function (done) {
+      closing = true
+      registry.unregisterProvider(node.id)
+      pendingRequests.forEach(pending => {
+        clearTimeout(pending.timer)
+        pending.reject(new Error('Cerebrum Home Assistant node closed'))
+      })
+      pendingRequests.clear()
+      listeners.clear()
+      if (typeof done === 'function') done()
+    })
+
+    updateStatus({ fill: 'yellow', shape: 'ring', text: 'wire output → ha-api → input' })
+  }
+
+  RED.nodes.registerType('knxUltimateAIHomeAssistant', knxUltimateAIHomeAssistant)
+}
+
+module.exports.__test = {
+  DEFAULT_REQUEST_TIMEOUT_MS,
+  HOME_ASSISTANT_ADAPTER_ID
+}

package/nodes/locales/de/knxUltimateAI.json

@@ -3,12 +3,13 @@
     "title": "KNX AI (Traffic Analyzer)",
     "sections": {
       "groupAssistant": "KI-Assistent",
-      "groupChatHome": "Gespräche & Zuhause",
+      "groupChatHome": "Cerebrum (BETA)",
       "setupDoctor": "Setup Doctor",
       "webIntelligence": "Web-Intelligenz",
       "detectedAdapters": "Erkannte und im Chat verwendete kompatible Nodes",
       "chatContextOverview": "Übersicht des Chat-Kontexts",
       "chatLearning": "KI-Chat-Lernen",
+      "cerebrumMemory": "Cerebrum-Speicher",
       "quickSetup": "Assistent einrichten",
       "etsAccess": "Zugriff auf ETS-Objekte",
       "llmConnection": "KI-Assistent-Verbindung",
@@ -129,6 +130,7 @@
       "chatContextLoading": "Zusammenfassung des Chat-Kontexts wird geladen…",
       "chatContextUnavailable": "Die Zusammenfassung des Chat-Kontexts ist vorübergehend nicht verfügbar.",
       "chatLearningOpenHint": "Öffnet die Weboberfläche direkt im gemeinsamen CHAT-Lerneditor, um die persistente Datei anzuzeigen, zu bearbeiten, zu kopieren oder zu sichern.",
+      "cerebrumMemoryOpenHint": "Öffnet den lesbaren Cerebrum-Speicher für gelernte Gewohnheiten, Entscheidungen der Bewohner und zwischengespeicherte Hauszustände.",
       "chatContextIntro": "Der Chat erhält diese Quellen automatisch. Die folgenden Pfade werden von dieser Node-RED-Installation tatsächlich verwendet.",
       "chatContextLimitLabel": "Maximaler operativer Kontext",
       "chatContextProviderManaged": "vom ausgewählten Anbieter/Modell verwaltet",
@@ -151,7 +153,7 @@
       "chatContextFileHomeMemory": "Nur begrenztes gelerntes Hausgedächtnis; die KI-Erziehung bleibt in der Node-Eigenschaft.",
       "chatContextFileSchedules": "Verbindlicher dauerhafter Laufzeitstatus der Pläne und Erinnerungen dieses Nodes.",
       "chatContextFileSchedulesReadable": "Erzeugte menschenlesbare Ansicht der Pläne und Erinnerungen dieses Nodes.",
-      "chatContextFileAssistantConfig": "Dauerhafte Konfiguration des Web-Assistenten und semantische Bereiche dieses Nodes.",
+      "chatContextFileAssistantConfig": "Dauerhafte Cerebrum-Konfiguration und semantische Bereiche dieses Nodes.",
       "chatContextFileLastChatPrompt": "Temporäre lokale Kopie der letzten System- und Benutzernachricht an das Chatmodell; wird bei jeder Chatanfrage überschrieben.",
       "chatContextFileBadge": "Datei",
       "chatContextDirectoryRoot": "Stammverzeichnis des Telegrammarchivs",
@@ -219,6 +221,7 @@
       "ollamaLibrary": "Model library",
       "downloadOllamaModel": "1) Download model",
       "openChatLearning": "KI-Chat-Lernen öffnen",
+      "openCerebrumMemory": "Cerebrum-Speicher öffnen",
       "etsSelectAll": "Alle auswählen",
       "etsSelectNone": "Alle abwählen",
       "etsReadOnlyAll": "Nur lesen setzen",

package/nodes/locales/en/knxUltimateAI.html

@@ -1,7 +1,7 @@
 <script type="text/markdown" data-help-name="knxUltimateAI">
 This node listens to **all KNX telegrams** from the selected KNX Ultimate gateway, builds traffic statistics, detects anomalies, and can optionally query an LLM.
 
-The editor uses two horizontal tabs: **AI assistant** contains setup, knowledge/context and provider limits; **Conversations & home** contains chat input/output pins, proactive home and bounded memory.
+The editor uses two horizontal tabs: **AI assistant** contains setup, knowledge/context and provider limits; **Cerebrum (BETA)** contains chat input/output pins, proactive home and bounded memory.
 
 ## Outputs
 1. **Summary/Stats** (`msg.payload` JSON)
@@ -12,6 +12,8 @@ The editor uses two horizontal tabs: **AI assistant** contains setup, knowledge/
 
 Every message emitted by outputs 3 and 4 also contains a clone of the original input message in `msg.inputMessage`. This preserves the original payload, topic, chat metadata, and any other input properties for downstream nodes. Cloning and output errors are contained and reported instead of escaping into the Node-RED runtime.
 
+At node startup, output 3 emits a short Cerebrum supervision notice with `msg.boot = true`. When AI is enabled, the notice is generated by the selected model as a live inference test; `msg.knxAi.llmTest` is `passed`, while provider and model identify what answered. If AI is disabled or the call fails, the startup message is still emitted with an honest localized fallback and `llmTest` set to `disabled` or `failed`. This check never reads or writes KNX.
+
 ### Setup Doctor and safe first run
 The automatic **Setup Doctor** checks the selected gateway and ETS import, AI enablement, provider, model and API key, provider reachability, flow wiring, detected cameras and the optional TTS Ultimate connection. Its no-cost provider preflight calls only the provider's model-list endpoint: it never sends a chat request or consumes inference tokens. Cameras and TTS are optional, so leaving them unused does not reduce core readiness.
 
@@ -103,12 +105,14 @@ The node editor shows a compact card summarizing the sources available to the ch
 The model receives local ETS catalog retrieval, KNX read/write operations, camera adapters, TTS announcements, persistent memory, Web access and plans/reminders as structured tools. It can select and combine them semantically from the current request and trusted learned guidance, without linguistic intent routing. Catalog retrieval is deterministic and local; the runtime validates tool arguments, camera-adapter availability and safety boundaries, while KNX writes still use complete local ETS/DPT validation and the configured confirmation step.
 
 ### Editing and backing up CHAT learning
-The **Conversations & home** tab in the Node-RED KNX AI configuration includes an **Open AI Chat Learning** button that opens the Vue Web UI directly on this editor for the current node.
+The **Cerebrum (BETA)** tab in the Node-RED KNX AI configuration includes an **Open AI Chat Learning** button that opens the Vue Web UI directly on this editor for the current node.
 
-In the Vue web UI, open **Settings → AI Chat Learning** to view and edit the exact shared `knxai-chat-context.knxctx` file and its absolute path. The file can be copied, downloaded as a backup or restored from another `.knxctx` file. **Reinitialize Memory**, protected by an explicit confirmation, replaces it with a new empty context and clears saved sessions, instructions, camera watches and pending chat confirmations across every KNX AI node using the same storage. The native tab-separated `KNXAI_CHAT_CONTEXT 3` records are authoritative and directly editable: `SESSION` contains `INSTRUCTION`, `TURN` and `CAMERA_WATCH` records until `END_SESSION`. Saving validates and bounds these records, atomically rewrites the file and updates the live context of every KNX AI node using the same storage. A revision check refuses to overwrite or reset learning that changed after the editor loaded it.
+In the Vue web UI, open **Cerebrum → AI Chat Learning** to inspect the exact shared `knxai-chat-context.knxctx`. **Native file** exposes the authoritative editable records; **Simplified text** explains the same conversations, learned instructions and camera watches in a localized read-only view. Copy follows the selected view, while download and restore always use the complete native backup. **Reinitialize Memory**, protected by an explicit confirmation, replaces it with a new empty context and clears saved sessions, instructions, camera watches and pending chat confirmations across every KNX AI node using the same storage. Saving validates and bounds the native V3 records, atomically rewrites the file and updates every live KNX AI node sharing that storage. A revision check protects newer learning.
 
 Only the native V3 format is supported. Previous Markdown/JSON V2 and Base64 V1 files are deliberately not read, imported or migrated; the old `.md` file is left untouched and KNX AI starts a new `.knxctx` context. The 50-session and 512 KB limits still apply.
 
+Open **Cerebrum → Cerebrum Memory** to inspect the shared `knxai-home-memory.md`. The **JSON** view contains the authoritative editable data, while **Simplified text** presents the same habits, occupant decisions, states, observations, notifications and known home objects as a localized read-only explanation. The browser remembers the selected view. Saving validates JSON; copy follows the current view, while download and restore remain complete backups. **Settings** contains only the strict KNX AI and Cerebrum backup import/export; it includes configuration, chat learning, home memory and schedule files.
+
 ### ETS object access
 ETS object access is the only operational authority. Every address selected in **ETS object access** is active and readable; a selected address is writable unless it is marked **Read only**. No inferred role classification is sent to the chat model or used to authorize a write.
 
@@ -117,6 +121,10 @@ From ETS hierarchy, names, roles and DPTs, the node builds a deterministic seman
 
 There is no separate switch or advanced proactive configuration. A candidate is evaluated only when the LLM is enabled and **AI Education** explicitly requests that notification. Education is the sole policy for conditions, open duration, quiet hours and repetition. The AI receives the current duration, local date/time and recent notification history; it decides whether to notify and when to reconsider the same open condition. Without an explicit Education rule, or when the LLM cannot evaluate it, no notification is sent.
 
+Cerebrum also learns bounded weekday/weekend time patterns from KNX writes and HUE, Matter or Home Assistant state changes. A pattern becomes eligible only after at least eight consistent observations spread across six distinct dates and a minimum 14-day span, with confidence of at least 0.70. Repeated telegrams on the same day cannot accelerate confirmation. If **AI Education** explicitly asks Cerebrum to anticipate learned habits, it may send one suggestion up to 30 minutes before the usual time. The suggestion is never an execution: KNX and Home Assistant actions still require the normal authorization and confirmation path, and the global limit of three proactive messages per hour still applies.
+
+Cerebrum passively observes bounded, sanitized outputs from useful Node-RED logic, HUE, Matter and Home Assistant event nodes through a runtime hook; no extra monitoring wires are required. Credentials, authorization headers, opaque media and binary payloads are discarded. For live Home Assistant state, add **Cerebrum Home Assistant** and wire `Cerebrum Home Assistant → API (ha-api) → Cerebrum Home Assistant`. Setup Doctor detects the Home Assistant add-on and reports the next missing step.
+
 The most recent chat session is remembered as the owner and receives spontaneous messages. Output 3 emits a localized message with `msg.knxAi.type = "proactive_notification"`; a synthetic `msg.inputMessage` preserves the session for the chat adapter. A hard safety limit of three proactive messages per hour prevents flooding. The node never emits output 4 or changes KNX autonomously; a subsequent user request still uses the normal validation and confirmation workflow.
 
 The shared learned reference is loaded at startup from `<userDir>/knxai/memory/knxai-home-memory.md`, rewritten atomically every 15 minutes and always hard-capped at 5 MB. It stores at most 120 significant observations, 80 aggregate habits, 80 notifications and 300 semantic ETS objects—never a raw unlimited telegram stream. Older low-priority entries are removed first.

package/nodes/locales/en/knxUltimateAI.json

@@ -3,12 +3,13 @@
     "title": "KNX AI (Traffic Analyzer)",
     "sections": {
       "groupAssistant": "AI assistant",
-      "groupChatHome": "Conversations & home",
+      "groupChatHome": "Cerebrum (BETA)",
       "setupDoctor": "Setup Doctor",
       "webIntelligence": "Web intelligence",
       "detectedAdapters": "Compatible nodes detected and used in chat",
       "chatContextOverview": "Chat context overview",
       "chatLearning": "AI Chat Learning",
+      "cerebrumMemory": "Cerebrum memory",
       "quickSetup": "Assistant setup",
       "etsAccess": "ETS object access",
       "llmConnection": "AI Assistant Connection",
@@ -83,6 +84,7 @@
       "ollamaLibrary": "Model library",
       "downloadOllamaModel": "1) Download model",
       "openChatLearning": "Open AI Chat Learning",
+      "openCerebrumMemory": "Open Cerebrum memory",
       "etsSelectAll": "Select all",
       "etsSelectNone": "Select none",
       "etsReadOnlyAll": "Set read only",
@@ -136,6 +138,7 @@
       "chatContextLoading": "Loading chat context summary…",
       "chatContextUnavailable": "The chat context summary is temporarily unavailable.",
       "chatLearningOpenHint": "Open the Web UI directly on the shared CHAT learning editor to view, edit, copy or back up its persistent file.",
+      "cerebrumMemoryOpenHint": "Open the user-readable Cerebrum memory to inspect or edit learned habits, occupant decisions and cached home states.",
       "chatContextIntro": "The chat automatically receives these sources. The paths below are the actual paths used by this Node-RED installation.",
       "chatContextLimitLabel": "Maximum operational context",
       "chatContextProviderManaged": "managed by the selected provider/model",
@@ -158,7 +161,7 @@
       "chatContextFileHomeMemory": "Bounded learned home memory only; AI Education remains in the node property.",
       "chatContextFileSchedules": "Authoritative persistent runtime state for this node's plans and reminders.",
       "chatContextFileSchedulesReadable": "Generated human-readable view of this node's plans and reminders.",
-      "chatContextFileAssistantConfig": "Persistent web Assistant configuration and semantic areas for this node.",
+      "chatContextFileAssistantConfig": "Persistent Cerebrum configuration and semantic areas for this node.",
       "chatContextFileLastChatPrompt": "Temporary local copy of the latest system and user messages sent to the chat model; overwritten on every chat request.",
       "chatContextFileBadge": "File",
       "chatContextDirectoryRoot": "Telegram archive root",

package/nodes/locales/es/knxUltimateAI.json

@@ -3,12 +3,13 @@
     "title": "KNX AI (Traffic Analyzer)",
     "sections": {
       "groupAssistant": "Asistente IA",
-      "groupChatHome": "Conversaciones y hogar",
+      "groupChatHome": "Cerebrum (BETA)",
       "setupDoctor": "Setup Doctor",
       "webIntelligence": "Inteligencia Web",
       "detectedAdapters": "Nodos compatibles detectados y utilizados en el chat",
       "chatContextOverview": "Resumen del contexto del chat",
       "chatLearning": "Aprendizaje del chat IA",
+      "cerebrumMemory": "Memoria Cerebrum",
       "quickSetup": "Configurar el asistente",
       "etsAccess": "Acceso a objetos ETS",
       "llmConnection": "Conexion del Asistente IA",
@@ -122,6 +123,7 @@
       "chatContextLoading": "Cargando el resumen del contexto del chat…",
       "chatContextUnavailable": "El resumen del contexto del chat no está disponible temporalmente.",
       "chatLearningOpenHint": "Abre la interfaz web directamente en el editor de aprendizaje CHAT compartido para ver, editar, copiar o guardar una copia de su archivo persistente.",
+      "cerebrumMemoryOpenHint": "Abre la memoria Cerebrum legible para consultar o editar hábitos, decisiones de los ocupantes y estados de la casa.",
       "chatContextIntro": "El chat recibe automáticamente estas fuentes. Las rutas siguientes son las que usa realmente esta instalación de Node-RED.",
       "chatContextLimitLabel": "Contexto operativo máximo",
       "chatContextProviderManaged": "gestionado por el proveedor/modelo seleccionado",
@@ -144,7 +146,7 @@
       "chatContextFileHomeMemory": "Solo memoria doméstica aprendida y limitada; la Educación IA permanece en la propiedad del nodo.",
       "chatContextFileSchedules": "Estado de ejecución persistente y autoritativo de las planificaciones y recordatorios de este nodo.",
       "chatContextFileSchedulesReadable": "Vista legible generada de las planificaciones y recordatorios de este nodo.",
-      "chatContextFileAssistantConfig": "Configuración persistente del Asistente web y áreas semánticas de este nodo.",
+      "chatContextFileAssistantConfig": "Configuración persistente de Cerebrum y áreas semánticas de este nodo.",
       "chatContextFileLastChatPrompt": "Copia local temporal de los últimos mensajes system y user enviados al modelo de chat; se sobrescribe en cada solicitud.",
       "chatContextFileBadge": "Archivo",
       "chatContextDirectoryRoot": "Raíz del archivo de telegramas",
@@ -219,6 +221,7 @@
       "ollamaLibrary": "Model library",
       "downloadOllamaModel": "1) Download model",
       "openChatLearning": "Abrir aprendizaje del chat IA",
+      "openCerebrumMemory": "Abrir memoria Cerebrum",
       "etsSelectAll": "Seleccionar todo",
       "etsSelectNone": "Deseleccionar todo",
       "etsReadOnlyAll": "Marcar solo lectura",

package/nodes/locales/fr/knxUltimateAI.json

@@ -3,12 +3,13 @@
     "title": "KNX AI (Traffic Analyzer)",
     "sections": {
       "groupAssistant": "Assistant IA",
-      "groupChatHome": "Conversations et maison",
+      "groupChatHome": "Cerebrum (BETA)",
       "setupDoctor": "Setup Doctor",
       "webIntelligence": "Intelligence Web",
       "detectedAdapters": "Nœuds compatibles détectés et utilisés dans le chat",
       "chatContextOverview": "Aperçu du contexte du chat",
       "chatLearning": "Apprentissage du chat IA",
+      "cerebrumMemory": "Mémoire Cerebrum",
       "quickSetup": "Configurer l'assistant",
       "etsAccess": "Accès aux objets ETS",
       "llmConnection": "Connexion Assistant IA",
@@ -122,6 +123,7 @@
       "chatContextLoading": "Chargement du résumé du contexte du chat…",
       "chatContextUnavailable": "Le résumé du contexte du chat est temporairement indisponible.",
       "chatLearningOpenHint": "Ouvre l’interface web directement dans l’éditeur d’apprentissage CHAT partagé pour afficher, modifier, copier ou sauvegarder son fichier persistant.",
+      "cerebrumMemoryOpenHint": "Ouvre la mémoire Cerebrum lisible pour consulter ou modifier les habitudes, les décisions des occupants et les états du logement.",
       "chatContextIntro": "Le chat reçoit automatiquement ces sources. Les chemins ci-dessous sont ceux réellement utilisés par cette installation Node-RED.",
       "chatContextLimitLabel": "Contexte opérationnel maximal",
       "chatContextProviderManaged": "géré par le fournisseur/modèle sélectionné",
@@ -144,7 +146,7 @@
       "chatContextFileHomeMemory": "Mémoire domestique apprise et limitée uniquement ; l’Éducation IA reste dans la propriété du nœud.",
       "chatContextFileSchedules": "État d’exécution persistant faisant autorité pour les planifications et rappels de ce nœud.",
       "chatContextFileSchedulesReadable": "Vue lisible générée des planifications et rappels de ce nœud.",
-      "chatContextFileAssistantConfig": "Configuration persistante de l'Assistant web et zones sémantiques de ce nœud.",
+      "chatContextFileAssistantConfig": "Configuration persistante de Cerebrum et zones sémantiques de ce nœud.",
       "chatContextFileLastChatPrompt": "Copie locale temporaire des derniers messages système et utilisateur envoyés au modèle de chat ; remplacée à chaque requête.",
       "chatContextFileBadge": "Fichier",
       "chatContextDirectoryRoot": "Racine de l'archive des télégrammes",
@@ -219,6 +221,7 @@
       "ollamaLibrary": "Model library",
       "downloadOllamaModel": "1) Download model",
       "openChatLearning": "Ouvrir l’apprentissage du chat IA",
+      "openCerebrumMemory": "Ouvrir la mémoire Cerebrum",
       "etsSelectAll": "Tout sélectionner",
       "etsSelectNone": "Tout désélectionner",
       "etsReadOnlyAll": "Activer lecture seule",

package/nodes/locales/it/knxUltimateAI.html

@@ -1,7 +1,7 @@
 <script type="text/markdown" data-help-name="knxUltimateAI">
 Questo nodo ascolta **tutti i telegrammi KNX** dal gateway KNX Ultimate selezionato, costruisce statistiche di traffico, rileva anomalie e può interrogare opzionalmente un LLM.
 
-L'editor usa due schede orizzontali: **Assistente AI** contiene configurazione, conoscenza/contesto, provider e limiti; **Conversazioni e casa** contiene i PIN di input e output della chat, casa proattiva e memoria limitata.
+L'editor usa due schede orizzontali: **Assistente AI** contiene configurazione, conoscenza/contesto, provider e limiti; **Cerebrum (BETA)** contiene i PIN di input e output della chat, casa proattiva e memoria limitata.
 
 ## Output
 1. **Summary/Statistiche** (`msg.payload` JSON)
@@ -12,6 +12,8 @@ L'editor usa due schede orizzontali: **Assistente AI** contiene configurazione,
 
 Ogni messaggio emesso dalle uscite 3 e 4 contiene anche una copia del messaggio originale in ingresso in `msg.inputMessage`. In questo modo payload, topic, metadati della chat e qualsiasi altra proprietà di ingresso restano disponibili per i nodi successivi. Gli errori di clonazione o di invio vengono intercettati e segnalati senza propagarsi al runtime di Node-RED.
 
+All'avvio del nodo, l'uscita 3 emette un breve messaggio di supervisione Cerebrum con `msg.boot = true`. Quando l'AI è attiva, il testo viene generato dal modello selezionato come test reale di inferenza; `msg.knxAi.llmTest` vale `passed`, mentre provider e modello indicano chi ha risposto. Se l'AI è disattivata o la chiamata fallisce, il messaggio di avvio viene comunque emesso con un fallback localizzato e trasparente e `llmTest` vale `disabled` o `failed`. Questo controllo non legge e non scrive sul bus KNX.
+
 ### Setup Doctor e primo avvio sicuro
 Il **Setup Doctor** automatico controlla gateway selezionato e importazione ETS, attivazione AI, provider, modello e chiave API, raggiungibilità del provider, collegamenti del flow, telecamere rilevate e collegamento TTS Ultimate opzionale. Il preflight del provider, senza costi, chiama soltanto l'endpoint che elenca i modelli: non invia mai una richiesta chat e non consuma token di inferenza. Telecamere e TTS sono opzionali, quindi non usarli non riduce la prontezza di base.
 
@@ -103,12 +105,14 @@ L'editor del nodo mostra una scheda compatta con le fonti disponibili alla chat:
 Il modello riceve retrieval locale del catalogo ETS, letture e scritture KNX, adapter telecamera, annunci TTS, memoria persistente, accesso Web e pianificazioni/promemoria come strumenti strutturati. Può sceglierli e combinarli semanticamente partendo dalla richiesta corrente e dalle indicazioni autorevoli apprese, senza routing per intent linguistici. Il retrieval del catalogo è deterministico e locale; il runtime valida argomenti, disponibilità degli adapter telecamera e confini di sicurezza, mentre le scritture KNX conservano la validazione completa ETS/DPT locale e la conferma configurata.
 
 ### Modifica e backup dell'apprendimento CHAT
-La scheda **Conversazioni e casa** nella configurazione Node-RED di KNX AI include il pulsante **Apri Apprendimento AI Chat**, che apre la Web UI Vue direttamente su questo editor per il nodo corrente.
+La scheda **Cerebrum (BETA)** nella configurazione Node-RED di KNX AI include il pulsante **Apri Apprendimento AI Chat**, che apre la Web UI Vue direttamente su questo editor per il nodo corrente.
 
-Nella UI web Vue, apri **Impostazioni → Apprendimento AI Chat** per visualizzare e modificare il file condiviso esatto `knxai-chat-context.knxctx` e il suo percorso assoluto. Il file può essere copiato, scaricato come backup o ripristinato da un altro file `.knxctx`. **Re-inizializza memoria**, protetto da una conferma esplicita, lo sostituisce con un nuovo contesto vuoto e cancella sessioni, istruzioni, sorveglianze telecamera e conferme chat pendenti in ogni nodo KNX AI che usa lo stesso archivio. I record nativi separati da tabulazioni `KNXAI_CHAT_CONTEXT 3` sono autorevoli e direttamente modificabili: `SESSION` contiene record `INSTRUCTION`, `TURN` e `CAMERA_WATCH` fino a `END_SESSION`. Il salvataggio valida e limita questi record, riscrive atomicamente il file e aggiorna il contesto attivo di ogni nodo KNX AI che usa lo stesso archivio. Un controllo di revisione impedisce di sovrascrivere o azzerare l'apprendimento cambiato dopo il caricamento nell'editor.
+Nella UI web Vue, apri **Cerebrum → Apprendimento AI Chat** per esaminare il file condiviso esatto `knxai-chat-context.knxctx`. **File nativo** espone i record autorevoli modificabili; **Testo semplificato** spiega le stesse conversazioni, istruzioni apprese e sorveglianze telecamera in una vista localizzata di sola lettura. La copia segue la vista selezionata, mentre download e ripristino usano sempre il backup nativo completo. **Re-inizializza memoria**, protetto da una conferma esplicita, sostituisce il file con un nuovo contesto vuoto e cancella sessioni, istruzioni, sorveglianze telecamera e conferme chat pendenti in ogni nodo KNX AI che usa lo stesso archivio. Il salvataggio valida e limita i record nativi V3, riscrive atomicamente il file e aggiorna tutti i nodi KNX AI attivi che condividono l’archivio. Un controllo di revisione protegge l’apprendimento più recente.
 
 È supportato soltanto il formato nativo V3. I precedenti file Markdown/JSON V2 e Base64 V1 non vengono volutamente letti, importati né migrati; il vecchio file `.md` resta intatto e KNX AI avvia un nuovo contesto `.knxctx`. Restano validi i limiti di 50 sessioni e 512 KB.
 
+Apri **Cerebrum → Memoria Cerebrum** per esaminare il file condiviso `knxai-home-memory.md`. La vista **JSON** contiene i dati autorevoli modificabili, mentre **Testo semplificato** presenta le stesse abitudini, decisioni degli occupanti, stati, osservazioni, notifiche e oggetti conosciuti come spiegazione localizzata di sola lettura. Il browser ricorda la vista scelta. Il salvataggio valida il JSON; la copia segue la vista corrente, mentre download e ripristino restano backup completi. **Impostazioni** contiene soltanto l’import/export del backup rigoroso KNX AI e Cerebrum, che comprende configurazione, apprendimento chat, memoria della casa e file delle pianificazioni.
+
 ### Accesso agli oggetti ETS
 L'accesso agli oggetti ETS è l'unica autorità operativa. Ogni indirizzo selezionato in **Accesso agli oggetti ETS** è attivo e leggibile; è anche scrivibile, a meno che sia marcato **Sola lettura**. Nessuna classificazione di ruolo dedotta viene inviata al modello della chat o usata per autorizzare una scrittura.
 
@@ -117,6 +121,10 @@ Da gerarchia ETS, nomi, ruoli e DPT, il nodo crea un modello semantico determini
 
 Non esistono un interruttore o impostazioni proattive avanzate separate. Una condizione viene valutata soltanto quando l'LLM è attivo e **Educazione AI** richiede esplicitamente quella notifica. L'Educazione è l'unica policy per condizioni, durata dell'apertura, ore silenziose e ripetizione. L'AI riceve durata attuale, data/ora locale e storico recente delle notifiche; decide se avvisare e quando rivalutare la stessa apertura. Senza una regola esplicita nell'Educazione, o se l'LLM non riesce a valutarla, non viene inviato alcun messaggio.
 
+Cerebrum apprende anche pattern temporali limitati fra giorni feriali e fine settimana, ricavati dalle scritture KNX e dai cambi di stato HUE, Matter o Home Assistant. Un pattern diventa utilizzabile solo dopo almeno otto osservazioni coerenti, distribuite su sei date distinte e su un intervallo minimo di 14 giorni, con confidenza non inferiore a 0,70. Telegrammi ripetuti nella stessa giornata non possono anticipare la richiesta di conferma. Se **Educazione AI** chiede esplicitamente a Cerebrum di anticipare le abitudini apprese, può inviare un suggerimento fino a 30 minuti prima dell'orario abituale. Il suggerimento non è mai un'esecuzione: le azioni KNX e Home Assistant richiedono ancora il normale percorso di autorizzazione e conferma, e resta valido il limite globale di tre messaggi proattivi all'ora.
+
+Cerebrum osserva passivamente, tramite un hook runtime, gli output limitati e sanificati dei nodi utili di logica Node-RED, HUE, Matter e degli eventi Home Assistant; non servono collegamenti di monitoraggio aggiuntivi. Credenziali, header di autorizzazione, contenuti multimediali opachi e payload binari vengono scartati. Per lo stato Home Assistant live, aggiungi **Cerebrum Home Assistant** e collega `Cerebrum Home Assistant → API (ha-api) → Cerebrum Home Assistant`. Setup Doctor rileva l'add-on Home Assistant e indica il prossimo passaggio mancante.
+
 L'ultima sessione chat viene ricordata come proprietario e riceve i messaggi spontanei. L'uscita 3 emette un messaggio localizzato con `msg.knxAi.type = "proactive_notification"`; un `msg.inputMessage` sintetico conserva la sessione per l'adattatore chat. Un limite rigido di tre notifiche proattive all'ora evita abusi. Il nodo non emette mai l'uscita 4 e non modifica autonomamente KNX; un'eventuale richiesta successiva passa sempre dalla normale validazione e conferma.
 
 Il riferimento appreso condiviso viene caricato all'avvio da `<userDir>/knxai/memory/knxai-home-memory.md`, riscritto atomicamente ogni 15 minuti e sempre limitato rigidamente a 5 MB. Conserva al massimo 120 osservazioni significative, 80 abitudini aggregate, 80 notifiche e 300 oggetti ETS semantici, mai un flusso illimitato di telegrammi raw. Gli elementi vecchi e meno importanti vengono eliminati per primi.

package/nodes/locales/it/knxUltimateAI.json

@@ -3,12 +3,13 @@
     "title": "KNX AI (Analisi Traffico)",
     "sections": {
       "groupAssistant": "Assistente AI",
-      "groupChatHome": "Conversazioni e casa",
+      "groupChatHome": "Cerebrum (BETA)",
       "setupDoctor": "Setup Doctor",
       "webIntelligence": "Intelligenza Web",
       "detectedAdapters": "Nodi compatibili rilevati ed usati in chat",
       "chatContextOverview": "Contesto disponibile alla chat",
       "chatLearning": "Apprendimento AI Chat",
+      "cerebrumMemory": "Memoria Cerebrum",
       "quickSetup": "Configurazione assistente",
       "etsAccess": "Accesso agli oggetti ETS",
       "llmConnection": "Connessione Assistente AI",
@@ -83,6 +84,7 @@
       "ollamaLibrary": "Libreria modelli",
       "downloadOllamaModel": "1) Scarica il modello",
       "openChatLearning": "Apri Apprendimento AI Chat",
+      "openCerebrumMemory": "Apri memoria Cerebrum",
       "etsSelectAll": "Seleziona tutti",
       "etsSelectNone": "Deseleziona tutti",
       "etsReadOnlyAll": "Imposta sola lettura",
@@ -136,6 +138,7 @@
       "chatContextLoading": "Caricamento del riepilogo del contesto…",
       "chatContextUnavailable": "Il riepilogo del contesto della chat non è momentaneamente disponibile.",
       "chatLearningOpenHint": "Apri la Web UI direttamente nell’editor dell’apprendimento CHAT condiviso per visualizzare, modificare, copiare o salvare il suo file persistente.",
+      "cerebrumMemoryOpenHint": "Apri la memoria Cerebrum leggibile dall’utente per esaminare o modificare abitudini, decisioni degli occupanti e stati della casa.",
       "chatContextIntro": "La chat riceve automaticamente queste fonti. I percorsi sottostanti sono quelli effettivi usati da questa installazione Node-RED.",
       "chatContextLimitLabel": "Contesto operativo massimo",
       "chatContextProviderManaged": "gestito dal provider/modello selezionato",
@@ -158,7 +161,7 @@
       "chatContextFileHomeMemory": "Solo memoria domestica appresa e limitata; l'Educazione AI resta nella proprietà del nodo.",
       "chatContextFileSchedules": "Stato di runtime persistente e autorevole delle pianificazioni e dei promemoria di questo nodo.",
       "chatContextFileSchedulesReadable": "Vista leggibile generata delle pianificazioni e dei promemoria di questo nodo.",
-      "chatContextFileAssistantConfig": "Configurazione persistente dell'Assistente web e aree semantiche di questo nodo.",
+      "chatContextFileAssistantConfig": "Configurazione persistente di Cerebrum e aree semantiche di questo nodo.",
       "chatContextFileLastChatPrompt": "Copia locale temporanea degli ultimi messaggi system e user inviati al modello chat; viene sovrascritta a ogni richiesta.",
       "chatContextFileBadge": "File",
       "chatContextDirectoryRoot": "Radice archivio telegrammi",

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

@@ -3,12 +3,13 @@
     "title": "KNX AI (Traffic Analyzer)",
     "sections": {
       "groupAssistant": "AI 助手",
-      "groupChatHome": "对话与家庭",
+      "groupChatHome": "Cerebrum (BETA)",
       "setupDoctor": "Setup Doctor",
       "webIntelligence": "Web 智能",
       "detectedAdapters": "已检测并用于聊天的兼容节点",
       "chatContextOverview": "聊天上下文概览",
       "chatLearning": "AI 聊天学习",
+      "cerebrumMemory": "Cerebrum 记忆",
       "quickSetup": "助手配置",
       "etsAccess": "ETS 对象访问",
       "llmConnection": "AI 助手连接",
@@ -122,6 +123,7 @@
       "chatContextLoading": "正在加载聊天上下文摘要…",
       "chatContextUnavailable": "聊天上下文摘要暂时不可用。",
       "chatLearningOpenHint": "直接在 Web UI 中打开共享 CHAT 学习编辑器，以查看、编辑、复制或备份其持久文件。",
+      "cerebrumMemoryOpenHint": "打开用户可读的 Cerebrum 记忆，以查看或编辑学习到的习惯、住户决定和家庭状态。",
       "chatContextIntro": "聊天会自动接收这些来源。以下路径是此 Node-RED 安装实际使用的路径。",
       "chatContextLimitLabel": "最大运行上下文",
       "chatContextProviderManaged": "由所选提供商/模型管理",
@@ -144,7 +146,7 @@
       "chatContextFileHomeMemory": "仅包含有界的家庭学习记忆；AI 教育保留在节点属性中。",
       "chatContextFileSchedules": "此节点计划和提醒的权威持久运行时状态。",
       "chatContextFileSchedulesReadable": "此节点计划和提醒自动生成的易读视图。",
-      "chatContextFileAssistantConfig": "此节点的持久化 Web 助手配置和语义区域。",
+      "chatContextFileAssistantConfig": "此节点的持久化 Cerebrum 配置和语义区域。",
       "chatContextFileLastChatPrompt": "发送给聊天模型的最新 system 和 user 消息的临时本地副本；每次聊天请求都会覆盖。",
       "chatContextFileBadge": "文件",
       "chatContextDirectoryRoot": "报文归档根目录",
@@ -219,6 +221,7 @@
       "ollamaLibrary": "Model library",
       "downloadOllamaModel": "1) Download model",
       "openChatLearning": "打开 AI 聊天学习",
+      "openCerebrumMemory": "打开 Cerebrum 记忆",
       "etsSelectAll": "全选",
       "etsSelectNone": "全部取消",
       "etsReadOnlyAll": "设为只读",

package/nodes/plugins/knxUltimate-cerebrum-runtime-plugin.js

@@ -0,0 +1,79 @@
+const {
+  getKnxAiHomeAutomationRegistry,
+  normalizeKnxAiFlowSendEvent
+} = require('../utils/knxAiCerebrum')
+
+const HOOK_ID = 'onSend.knxUltimateCerebrum'
+const PROVIDER_ID = 'knx-ultimate:cerebrum-runtime'
+const ADAPTER_ID = 'node-red-flow'
+const DUPLICATE_WINDOW_MS = 750
+const MAX_EVENTS_PER_MINUTE = 240
+
+module.exports = RED => {
+  const listeners = new Set()
+  const recentFingerprints = new Map()
+  let eventWindowStartedAt = Date.now()
+  let eventWindowCount = 0
+
+  const provider = {
+    id: PROVIDER_ID,
+    adapterId: ADAPTER_ID,
+    title: 'Node-RED flow observer',
+    subscribe (listener) {
+      if (typeof listener !== 'function') return () => {}
+      listeners.add(listener)
+      return () => listeners.delete(listener)
+    }
+  }
+
+  const refreshEventWindow = now => {
+    if ((now - eventWindowStartedAt) >= 60 * 1000) {
+      eventWindowStartedAt = now
+      eventWindowCount = 0
+      recentFingerprints.clear()
+    }
+  }
+
+  const allowEvent = (event, now) => {
+    refreshEventWindow(now)
+    if (eventWindowCount >= MAX_EVENTS_PER_MINUTE) return false
+    const fingerprint = `${event.resourceId}|${event.details && event.details.topic}|${event.state}`
+    const previous = Number(recentFingerprints.get(fingerprint) || 0)
+    if (previous > 0 && (now - previous) < DUPLICATE_WINDOW_MS) return false
+    recentFingerprints.set(fingerprint, now)
+    eventWindowCount += 1
+    return true
+  }
+
+  const observeSendEvents = sendEvents => {
+    const events = Array.isArray(sendEvents) ? sendEvents : [sendEvents]
+    events.forEach(sendEvent => {
+      try {
+        const now = Date.now()
+        refreshEventWindow(now)
+        if (eventWindowCount >= MAX_EVENTS_PER_MINUTE) return
+        const event = normalizeKnxAiFlowSendEvent(sendEvent, { at: new Date(now).toISOString() })
+        if (!event || !allowEvent(event, now)) return
+        listeners.forEach(listener => {
+          try { listener(event) } catch (error) { /* observer listeners cannot interrupt the flow */ }
+        })
+      } catch (error) { /* observing must never alter Node-RED message delivery */ }
+    })
+  }
+
+  RED.plugins.registerPlugin('knxUltimateCerebrumRuntime', {
+    type: 'runtime',
+    onadd () {
+      const registry = getKnxAiHomeAutomationRegistry()
+      registry.registerAdapter({
+        id: ADAPTER_ID,
+        title: 'Node-RED flow observer',
+        capabilities: ['flow-events', 'hue-events', 'matter-events', 'home-assistant-events'],
+        access: 'observe'
+      })
+      registry.registerProvider(provider)
+      if (RED.hooks && typeof RED.hooks.remove === 'function') RED.hooks.remove(HOOK_ID)
+      if (RED.hooks && typeof RED.hooks.add === 'function') RED.hooks.add(HOOK_ID, observeSendEvents)
+    }
+  })
+}