node-red-contrib-knx-ultimate 6.2.0 → 6.2.1

package/nodes/knxUltimateAI.js

@@ -5,6 +5,23 @@ const fs = require('fs')
 const path = require('path')
 const { spawn } = require('child_process')
 const { getRequestAccessToken, normalizeAuthFromAccessTokenQuery } = require('./utils/httpAdminAccessToken')
+const {
+  HOME_MEMORY_MAX_EDUCATION_CHARS,
+  HOME_MEMORY_MAX_SEMANTIC_OBJECTS,
+  addBoundedKnxAiNotification,
+  addBoundedKnxAiObservation,
+  buildKnxAiHomeMemoryMarkdown,
+  buildKnxAiProactiveFallback,
+  clampHomeMemoryKb,
+  classifyKnxAiOpenState,
+  createEmptyKnxAiHomeMemory,
+  enrichKnxAiHomeCatalog,
+  isKnxAiQuietTime,
+  normalizeKnxAiHomeMemory,
+  normalizeHomeLanguage,
+  parseKnxAiHomeMemoryMarkdown,
+  updateKnxAiCoverHabit
+} = require('./utils/knxAiHomeMemory')
 let googleTranslateTTS = null
 try {
   googleTranslateTTS = require('google-translate-tts')
@@ -5036,6 +5053,14 @@ module.exports = function (RED) {
     node.chatAdapterPreset = String(config.chatAdapterPreset || 'none')
     node.chatInputCode = String(config.chatInputCode || '')
     node.chatOutputCode = String(config.chatOutputCode || '')
+    node.proactiveEnabled = config.proactiveEnabled !== undefined ? coerceBoolean(config.proactiveEnabled) : false
+    node.proactiveRecipient = String(config.proactiveRecipient || '').trim()
+    node.proactiveOpenMinutes = Math.max(1, Math.min(1440, Number(config.proactiveOpenMinutes) || 120))
+    node.proactiveCooldownMinutes = Math.max(5, Math.min(10080, Number(config.proactiveCooldownMinutes) || 360))
+    node.proactiveQuietStart = String(config.proactiveQuietStart || '23:00').trim()
+    node.proactiveQuietEnd = String(config.proactiveQuietEnd || '07:00').trim()
+    node.homeMemoryMaxKb = clampHomeMemoryKb(config.homeMemoryMaxKb)
+    node.aiEducation = String(config.aiEducation || '').slice(0, HOME_MEMORY_MAX_EDUCATION_CHARS)
 
     const pushStatus = (status) => {
       if (!status) return
@@ -5122,6 +5147,16 @@ module.exports = function (RED) {
     node._gaLabelCsvCache = { ref: null, map: {} }
     node._busConnectionWatchTimer = null
     node._historyDiskLastPruneAt = 0
+    node._homeMemory = createEmptyKnxAiHomeMemory()
+    node._homeMemoryWriteTimer = null
+    node._homeMemoryPeriodicTimer = null
+    node._proactiveCheckTimer = null
+    node._proactiveStates = new Map()
+    node._proactiveInFlight = new Set()
+    node._proactiveGlobalSentAt = []
+    node._homeCatalogByGa = null
+    node._homeCatalogSnapshotRef = null
+    node._closing = false
     node._busConnectionState = (node.serverKNX && typeof node.serverKNX.linkStatus === 'string')
       ? String(node.serverKNX.linkStatus).toLowerCase()
       : 'unknown'
@@ -6234,6 +6269,7 @@ module.exports = function (RED) {
       const wantsFunctionNodeSourceContext = node.llmIncludeFlowContext && shouldIncludeFunctionNodeSourceContext(question)
       const areasSnapshot = buildAreasSnapshot({ summary })
       const areasContext = buildAreasPromptContext(areasSnapshot)
+      const homeMemoryContext = getHomeMemoryPromptContext({ maxChars: compactMode ? 2200 : 6000 })
       const summaryForPrompt = buildLlmSummarySnapshot(summary)
       const summaryText = truncatePromptText(safeStringify(summaryForPrompt), compactMode ? 4000 : 10000)
       const lines = recent.map(t => {
@@ -6315,6 +6351,8 @@ module.exports = function (RED) {
         '',
         areasContext || '',
         areasContext ? '' : '',
+        homeMemoryContext || '',
+        homeMemoryContext ? '' : '',
         flowContext ? 'Node-RED context:' : '',
         flowContext || '',
         flowContext ? '' : '',
@@ -6355,10 +6393,10 @@ module.exports = function (RED) {
       if (node._gaCatalogCache && node._gaCatalogCache.ref === csv && node._gaCatalogCache.roleOverridesKey === roleOverridesKey && Array.isArray(node._gaCatalogCache.snapshot)) {
         return node._gaCatalogCache.snapshot
       }
-      const snapshot = applyGaRoleOverridesToCatalog({
+      const snapshot = enrichKnxAiHomeCatalog(applyGaRoleOverridesToCatalog({
         catalog: buildGaCatalogFromCsv(csv),
         roleOverrides
-      })
+      }))
       node._gaCatalogCache = { ref: csv, roleOverridesKey, snapshot }
       return snapshot
     }
@@ -6386,6 +6424,147 @@ module.exports = function (RED) {
 
     const getHistoryArchiveFile = (dayKey) => path.join(getHistoryArchiveDir(), `${String(dayKey || '').trim() || formatArchiveDayKey(Date.now())}.jsonl`)
 
+    const getHomeMemoryFile = () => {
+      const baseDir = (node.serverKNX && node.serverKNX.userDir)
+        ? node.serverKNX.userDir
+        : path.join(RED.settings.userDir, 'knxultimatestorage')
+      return path.join(baseDir, 'knxai', 'memory', `knxai-home-memory-${node.id}.md`)
+    }
+
+    const cleanupHomeMemoryTempFiles = () => {
+      try {
+        const filePath = getHomeMemoryFile()
+        const dirPath = path.dirname(filePath)
+        if (!fs.existsSync(dirPath)) return
+        const prefix = `${path.basename(filePath)}.tmp-`
+        fs.readdirSync(dirPath)
+          .filter(name => String(name).startsWith(prefix))
+          .forEach(name => {
+            try { fs.unlinkSync(path.join(dirPath, name)) } catch (error) { /* ignore */ }
+          })
+      } catch (error) {
+        try { node.sysLogger?.warn(`KNX AI home memory temporary-file cleanup error: ${error.message || error}`) } catch (logError) { /* ignore */ }
+      }
+    }
+
+    const getHomeCatalogMap = () => {
+      const snapshot = getGaCatalogSnapshot()
+      if (node._homeCatalogSnapshotRef === snapshot && node._homeCatalogByGa instanceof Map) return node._homeCatalogByGa
+      node._homeCatalogSnapshotRef = snapshot
+      node._homeCatalogByGa = new Map(snapshot.map(item => [String(item && item.ga ? item.ga : '').trim(), item]))
+      return node._homeCatalogByGa
+    }
+
+    const synchronizeHomeMemorySemanticObjects = () => {
+      const semanticObjects = getGaCatalogSnapshot()
+        .filter(item => item && item.semantic && item.semantic.kind !== 'unknown')
+        .sort((a, b) => Number(b.semantic.confidence || 0) - Number(a.semantic.confidence || 0))
+        .slice(0, HOME_MEMORY_MAX_SEMANTIC_OBJECTS)
+        .map(item => ({
+          ga: item.ga,
+          dpt: item.dpt,
+          label: item.label || item.etsName || item.ga,
+          kind: item.semantic.kind,
+          area: item.semantic.area || '',
+          role: item.role || 'neutral',
+          confidence: Number(item.semantic.confidence || 0)
+        }))
+      node._homeMemory.semanticObjects = semanticObjects
+      node._homeMemory.updatedAt = new Date().toISOString()
+    }
+
+    const persistHomeMemoryNow = () => {
+      try {
+        synchronizeHomeMemorySemanticObjects()
+        const rendered = buildKnxAiHomeMemoryMarkdown({
+          memory: node._homeMemory,
+          education: node.aiEducation,
+          maxKb: node.homeMemoryMaxKb
+        })
+        node._homeMemory = rendered.memory
+        const filePath = getHomeMemoryFile()
+        const dirPath = path.dirname(filePath)
+        if (!ensureDirectorySync(dirPath)) throw new Error(`Unable to create ${dirPath}`)
+        const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`
+        try {
+          fs.writeFileSync(tempPath, rendered.markdown, 'utf8')
+          fs.renameSync(tempPath, filePath)
+        } catch (error) {
+          try { if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath) } catch (cleanupError) { /* ignore */ }
+          throw error
+        }
+        return {
+          filePath,
+          bytes: rendered.bytes,
+          maxBytes: rendered.maxBytes
+        }
+      } catch (error) {
+        try { node.sysLogger?.warn(`KNX AI home memory write error: ${error.message || error}`) } catch (logError) { /* ignore */ }
+        return null
+      }
+    }
+
+    const scheduleHomeMemoryPersist = ({ immediate = false } = {}) => {
+      if (node._homeMemoryWriteTimer) {
+        clearTimeout(node._homeMemoryWriteTimer)
+        node._homeMemoryWriteTimer = null
+      }
+      if (immediate) return persistHomeMemoryNow()
+      node._homeMemoryWriteTimer = setTimeout(() => {
+        node._homeMemoryWriteTimer = null
+        persistHomeMemoryNow()
+      }, 1500)
+      return null
+    }
+
+    const loadHomeMemoryFromDisk = () => {
+      const filePath = getHomeMemoryFile()
+      try {
+        cleanupHomeMemoryTempFiles()
+        if (!fs.existsSync(filePath)) {
+          node._homeMemory = createEmptyKnxAiHomeMemory()
+          return scheduleHomeMemoryPersist({ immediate: true })
+        }
+        const stat = fs.statSync(filePath)
+        const absoluteReadLimit = 4 * 1024 * 1024
+        if (Number(stat.size || 0) > absoluteReadLimit) {
+          throw new Error(`memory file exceeds the safe read limit (${absoluteReadLimit} bytes)`)
+        }
+        node._homeMemory = normalizeKnxAiHomeMemory(parseKnxAiHomeMemoryMarkdown(fs.readFileSync(filePath, 'utf8')))
+        return scheduleHomeMemoryPersist({ immediate: true })
+      } catch (error) {
+        node._homeMemory = createEmptyKnxAiHomeMemory()
+        try { node.sysLogger?.warn(`KNX AI home memory load error: ${error.message || error}`) } catch (logError) { /* ignore */ }
+        return scheduleHomeMemoryPersist({ immediate: true })
+      }
+    }
+
+    const getHomeMemoryPromptContext = ({ maxChars = 6000 } = {}) => {
+      const memory = normalizeKnxAiHomeMemory(node._homeMemory)
+      const education = String(node.aiEducation || '').trim().slice(0, HOME_MEMORY_MAX_EDUCATION_CHARS)
+      const habitLines = memory.habits.slice(-20).map(item => {
+        return `- ${item.label || item.ga}: average open ${Number(item.averageMinutes || 0).toFixed(1)} min (${Number(item.samples || 0)} samples), last ${Number(item.lastMinutes || 0).toFixed(1)} min`
+      })
+      const observationLines = memory.observations.slice(-20).map(item => {
+        return `- ${item.at || ''} ${item.label || item.ga || ''}: ${item.event || item.value || item.type || ''}`
+      })
+      const educationContext = [
+        'USER-MANAGED AI EDUCATION (authoritative; never rewrite or contradict it):',
+        education || '(none)'
+      ].join('\n')
+      const learnedContext = [
+        'BOUNDED LEARNED HOME MEMORY:',
+        habitLines.length ? habitLines.join('\n') : '(no stable habits learned yet)',
+        observationLines.length ? `\nRecent significant observations:\n${observationLines.join('\n')}` : ''
+      ].join('\n')
+      const targetChars = Math.max(500, Number(maxChars) || 6000)
+      const remainingChars = Math.max(0, targetChars - educationContext.length - 2)
+      return [
+        educationContext,
+        remainingChars > 0 ? truncatePromptText(learnedContext, remainingChars) : ''
+      ].filter(Boolean).join('\n\n')
+    }
+
     const pruneHistoryArchiveFiles = ({ force = false } = {}) => {
       if (node.historyStoreToDisk !== true) return
       const retentionDays = Math.max(1, Math.round(Number.isFinite(Number(node.historyStoreRetentionDays)) ? Number(node.historyStoreRetentionDays) : 1))
@@ -8593,11 +8772,15 @@ module.exports = function (RED) {
         const role = String(item && item.role ? item.role : 'neutral').trim()
         const dpt = String(item && item.dpt ? item.dpt : '').trim() || '?'
         const label = String(item && item.label ? item.label : item && item.ga ? item.ga : '').trim()
+        const semantic = item && item.semantic && typeof item.semantic === 'object' ? item.semantic : {}
         const valueOptions = (Array.isArray(item && item.valueOptions) ? item.valueOptions : [])
           .slice(0, 20)
           .map(option => `${option.value}=${option.label}`)
           .join(', ')
-        return `${item.ga} | dpt ${dpt} | role ${role} | ${label}${valueOptions ? ` | values ${valueOptions}` : ''}`
+        const semanticText = semantic.kind && semantic.kind !== 'unknown'
+          ? ` | semantic ${semantic.kind}${semantic.area ? `/${semantic.area}` : ''} confidence=${Number(semantic.confidence || 0).toFixed(2)}`
+          : ''
+        return `${item.ga} | dpt ${dpt} | role ${role} | ${label}${semanticText}${valueOptions ? ` | values ${valueOptions}` : ''}`
       })
       const conversationLines = history.flatMap(turn => [
         `User: ${turn.question}`,
@@ -8628,6 +8811,8 @@ module.exports = function (RED) {
         history.length ? 'RECENT CONVERSATION:' : '',
         history.length ? conversationLines.join('\n') : '',
         history.length ? '' : '',
+        getHomeMemoryPromptContext({ maxChars: 6000 }),
+        '',
         analysisContext,
         '',
         `AVAILABLE KNX OBJECTS (showing ${Math.min(catalog.length, gaLimit)} of ${catalog.length}; every exact object may be read, but only role command may be written):`,
@@ -9136,6 +9321,267 @@ module.exports = function (RED) {
       node._gaState.set(ga, state)
     }
 
+    const rememberHomeOwner = ({ sessionId, language } = {}) => {
+      try {
+        const normalizedSessionId = String(sessionId || '').trim()
+        if (normalizedSessionId && normalizedSessionId !== 'default') {
+          node._homeMemory.ownerSessionId = normalizedSessionId
+        }
+        if (language) node._homeMemory.ownerLanguage = normalizeHomeLanguage(language)
+        scheduleHomeMemoryPersist()
+      } catch (error) {
+        try { node.sysLogger?.warn(`KNX AI home owner memory error: ${error.message || error}`) } catch (logError) { /* ignore */ }
+      }
+    }
+
+    const recordProactiveObservation = ({ catalogItem, telegram, event }) => {
+      const semantic = catalogItem && catalogItem.semantic ? catalogItem.semantic : {}
+      node._homeMemory = addBoundedKnxAiObservation(node._homeMemory, {
+        at: new Date(Number(telegram.ts || nowMs())).toISOString(),
+        type: 'semantic_state_change',
+        event,
+        ga: catalogItem.ga,
+        dpt: catalogItem.dpt,
+        label: catalogItem.label || telegram.devicename || catalogItem.ga,
+        kind: semantic.kind || '',
+        area: semantic.area || '',
+        value: normalizeValueForCompare(telegram.payload)
+      })
+      scheduleHomeMemoryPersist()
+    }
+
+    const processProactiveTelegram = (telegram) => {
+      if (!telegram || !telegram.destination) return
+      const catalogItem = getHomeCatalogMap().get(String(telegram.destination).trim())
+      if (!catalogItem || !catalogItem.semantic) return
+      const openState = classifyKnxAiOpenState({
+        semantic: catalogItem.semantic,
+        dpt: telegram.dpt || catalogItem.dpt,
+        payload: telegram.payload,
+        valueOptions: catalogItem.valueOptions
+      })
+      if (!openState || Number(openState.confidence || 0) < 0.7) return
+      const ga = String(catalogItem.ga || telegram.destination).trim()
+      const now = Number(telegram.ts || nowMs())
+      const previous = node._proactiveStates.get(ga)
+      if (openState.open) {
+        if (previous && previous.open === true) {
+          previous.lastSeenAt = now
+          previous.value = openState.value
+          node._proactiveStates.set(ga, previous)
+          return
+        }
+        const lastNotification = normalizeKnxAiHomeMemory(node._homeMemory).notifications
+          .filter(item => item && item.ga === ga)
+          .sort((a, b) => String(a.at || '').localeCompare(String(b.at || '')))
+          .pop()
+        node._proactiveStates.set(ga, {
+          ga,
+          open: true,
+          openedAt: now,
+          lastSeenAt: now,
+          lastSentAt: lastNotification ? Date.parse(lastNotification.at || '') || 0 : 0,
+          value: openState.value,
+          confidence: openState.confidence,
+          catalogItem
+        })
+        recordProactiveObservation({
+          catalogItem,
+          telegram,
+          event: openState.reason || 'opened'
+        })
+        return
+      }
+      if (previous && previous.open === true) {
+        const durationMinutes = Math.max(0, (now - Number(previous.openedAt || now)) / 60000)
+        node._homeMemory = updateKnxAiCoverHabit(node._homeMemory, {
+          ga,
+          label: catalogItem.label || ga,
+          area: catalogItem.semantic.area || '',
+          durationMinutes,
+          at: new Date(now).toISOString()
+        })
+        recordProactiveObservation({
+          catalogItem,
+          telegram,
+          event: `${openState.reason || 'closed'} after ${durationMinutes.toFixed(1)} minutes`
+        })
+      }
+      node._proactiveStates.set(ga, {
+        ga,
+        open: false,
+        openedAt: 0,
+        lastSeenAt: now,
+        lastSentAt: previous ? Number(previous.lastSentAt || 0) : 0,
+        value: openState.value,
+        confidence: openState.confidence,
+        catalogItem
+      })
+    }
+
+    const createProactiveNotificationText = async ({ state, durationMinutes, language }) => {
+      const label = state.catalogItem.label || state.ga
+      const fallback = buildKnxAiProactiveFallback({ language, label, durationMinutes })
+      const hasAuthoritativeEducation = String(node.aiEducation || '').trim() !== ''
+      if (node.llmEnabled !== true) {
+        return hasAuthoritativeEducation
+          ? { notify: false, content: '' }
+          : { notify: true, content: fallback }
+      }
+      try {
+        const ret = await callLLMChat({
+          systemPrompt: [
+            'You decide whether to send one concise proactive smart-home notification.',
+            `Use language ${normalizeHomeLanguage(language)}.`,
+            'Return JSON only with exactly: {"notify":boolean,"message":"text"}.',
+            'Set notify=false when the authoritative user-managed AI Education says this condition is normal, allowed, unwanted, or should not generate a notification.',
+            'When notify=false, set message to an empty string.',
+            'Do not claim that a KNX command was sent or that an actuator changed.',
+            'The message must not contain Markdown, lists, addresses, DPTs, or technical details.',
+            'Explain the observed condition and end by asking whether the user wants help.',
+            'The user-managed AI Education is authoritative.'
+          ].join('\n'),
+          userContent: [
+            getHomeMemoryPromptContext({ maxChars: 3500 }),
+            '',
+            `Observed object: ${label}`,
+            `Semantic type: ${state.catalogItem.semantic.kind}`,
+            `Semantic area: ${state.catalogItem.semantic.area || 'unknown'}`,
+            `Condition duration: ${Math.max(1, Math.round(durationMinutes))} minutes`,
+            'Return the JSON decision now.'
+          ].join('\n'),
+          jsonSchema: {
+            name: 'knx_ai_proactive_decision',
+            strict: true,
+            schema: {
+              type: 'object',
+              additionalProperties: false,
+              properties: {
+                notify: { type: 'boolean' },
+                message: { type: 'string' }
+              },
+              required: ['notify', 'message']
+            }
+          },
+          maxTokensOverride: 2000
+        })
+        const decision = extractJsonFragmentFromText(ret && ret.content)
+        if (!decision || typeof decision !== 'object' || Array.isArray(decision) || typeof decision.notify !== 'boolean') {
+          throw new Error('The proactive decision is not a valid JSON object')
+        }
+        if (decision.notify === false) return { notify: false, content: '' }
+        const candidate = String(decision.message || '').trim()
+        if (!candidate || candidate.length > 1200 || candidate.startsWith('{') || candidate.startsWith('```')) {
+          return { notify: true, content: fallback }
+        }
+        return { notify: true, content: candidate }
+      } catch (error) {
+        try { node.sysLogger?.warn(`KNX AI proactive wording fallback: ${error.message || error}`) } catch (logError) { /* ignore */ }
+        return hasAuthoritativeEducation
+          ? { notify: false, content: '' }
+          : { notify: true, content: fallback }
+      }
+    }
+
+    const emitProactiveNotification = async ({ state, durationMinutes }) => {
+      if (node._closing === true) return false
+      const recipient = String(node.proactiveRecipient || node._homeMemory.ownerSessionId || '').trim()
+      if (node.chatAdapterPreset === 'windkh-telegrambot' && !recipient) return false
+      const language = normalizeHomeLanguage(node._homeMemory.ownerLanguage || node.llmDocsLanguage || 'en')
+      const notification = await createProactiveNotificationText({ state, durationMinutes, language })
+      if (!notification.notify) return 'suppressed'
+      const content = notification.content
+      if (node._closing === true) return false
+      const syntheticInputMessage = {
+        topic: 'proactive',
+        payload: Object.assign({
+          type: 'message',
+          content: ''
+        }, recipient ? { chatId: recipient } : {}),
+        sessionId: recipient || 'proactive',
+        language,
+        knxAi: {
+          type: 'proactive_observation',
+          destination: state.ga
+        }
+      }
+      const metadata = {
+        type: 'proactive_notification',
+        reason: 'open_too_long',
+        destination: state.ga,
+        dpt: state.catalogItem.dpt,
+        label: state.catalogItem.label || state.ga,
+        semantic: state.catalogItem.semantic,
+        openedAt: new Date(state.openedAt).toISOString(),
+        durationMinutes: Number(durationMinutes.toFixed(1)),
+        recipient,
+        sessionId: recipient || 'proactive',
+        language,
+        requiresConfirmationForCommands: true
+      }
+      const replyMessage = buildKnxAiReplyMessage({
+        inputMessage: syntheticInputMessage,
+        content,
+        metadata
+      })
+      if (!sendKnxAiOutputs([null, null, replyMessage, null], syntheticInputMessage)) return false
+      node._homeMemory = addBoundedKnxAiNotification(node._homeMemory, {
+        at: new Date().toISOString(),
+        type: 'proactive_notification',
+        reason: 'open_too_long',
+        ga: state.ga,
+        dpt: state.catalogItem.dpt,
+        label: state.catalogItem.label || state.ga,
+        durationMinutes: Number(durationMinutes.toFixed(1)),
+        recipient
+      })
+      rememberConversationTurn({
+        sessionId: recipient || 'proactive',
+        question: '[Proactive home observation]',
+        reply: content
+      })
+      scheduleHomeMemoryPersist({ immediate: true })
+      return true
+    }
+
+    const checkProactiveHomeState = () => {
+      if (node._closing === true || node.proactiveEnabled !== true) return
+      if (isKnxAiQuietTime({
+        date: new Date(),
+        start: node.proactiveQuietStart,
+        end: node.proactiveQuietEnd
+      })) return
+      const now = nowMs()
+      const thresholdMs = node.proactiveOpenMinutes * 60 * 1000
+      const cooldownMs = node.proactiveCooldownMinutes * 60 * 1000
+      node._proactiveGlobalSentAt = node._proactiveGlobalSentAt.filter(ts => (now - ts) < (60 * 60 * 1000))
+      if (node._proactiveGlobalSentAt.length >= 3) return
+      const candidate = Array.from(node._proactiveStates.values())
+        .filter(state => {
+          if (!state || state.open !== true || node._proactiveInFlight.has(state.ga)) return false
+          if ((now - Number(state.openedAt || now)) < thresholdMs) return false
+          if (Number(state.lastSentAt || 0) > 0 && (now - Number(state.lastSentAt)) < cooldownMs) return false
+          return true
+        })
+        .sort((a, b) => Number(a.openedAt || 0) - Number(b.openedAt || 0))[0]
+      if (!candidate) return
+      candidate.lastSentAt = now
+      node._proactiveInFlight.add(candidate.ga)
+      const durationMinutes = Math.max(1, (now - Number(candidate.openedAt || now)) / 60000)
+      Promise.resolve(emitProactiveNotification({ state: candidate, durationMinutes }))
+        .then(result => {
+          if (result === true) node._proactiveGlobalSentAt.push(now)
+          else if (result !== 'suppressed') candidate.lastSentAt = 0
+        })
+        .catch(error => {
+          candidate.lastSentAt = 0
+          try { node.sysLogger?.warn(`KNX AI proactive notification error: ${error.message || error}`) } catch (logError) { /* ignore */ }
+        })
+        .finally(() => {
+          node._proactiveInFlight.delete(candidate.ga)
+        })
+    }
+
     // Called by knxUltimate-config.js
     node.handleSend = (msg) => {
       try {
@@ -9149,6 +9595,7 @@ module.exports = function (RED) {
         trimHistory(now)
         maybeEmitGAAnomalies(telegram)
         maybeEmitOverallAnomaly(now)
+        processProactiveTelegram(telegram)
         scheduleRealtimeSummaryRebuild()
       } catch (error) {
         try { node.sysLogger?.error(`knxUltimateAI handleSend error: ${error.message || error}`) } catch (e) { /* ignore */ }
@@ -9174,6 +9621,11 @@ module.exports = function (RED) {
           node._lastSummaryAt = 0
           node._conversationSessions = new Map()
           node._pendingKnxCommands = new Map()
+          node._homeMemory = createEmptyKnxAiHomeMemory()
+          node._proactiveStates = new Map()
+          node._proactiveInFlight = new Set()
+          node._proactiveGlobalSentAt = []
+          scheduleHomeMemoryPersist({ immediate: true })
           if (node._summaryRebuildTimer) {
             clearTimeout(node._summaryRebuildTimer)
             node._summaryRebuildTimer = null
@@ -9225,6 +9677,7 @@ module.exports = function (RED) {
             const readCommands = preparedCommands.filter(command => command && command.event === 'GroupValue_Read')
             const writeCommands = preparedCommands.filter(command => !command || command.event !== 'GroupValue_Read')
             const language = resolveKnxAiLanguage(msg, node.llmDocsLanguage || 'en', question, ret.language)
+            rememberHomeOwner({ sessionId, language })
             const copy = getKnxAiConfirmationCopy(language)
             const awaitingConfirmation = node.llmAllowKnxCommands &&
               node.llmRequireCommandConfirmation &&
@@ -9542,8 +9995,16 @@ module.exports = function (RED) {
 
     node.on('close', function (done) {
       try {
+        node._closing = true
         if (node._timerEmit) clearInterval(node._timerEmit)
         if (node._busConnectionWatchTimer) clearInterval(node._busConnectionWatchTimer)
+        if (node._homeMemoryPeriodicTimer) clearInterval(node._homeMemoryPeriodicTimer)
+        if (node._proactiveCheckTimer) clearInterval(node._proactiveCheckTimer)
+        if (node._homeMemoryWriteTimer) {
+          clearTimeout(node._homeMemoryWriteTimer)
+          node._homeMemoryWriteTimer = null
+        }
+        persistHomeMemoryNow()
         if (node._summaryRebuildTimer) {
           clearTimeout(node._summaryRebuildTimer)
           node._summaryRebuildTimer = null
@@ -9579,10 +10040,23 @@ module.exports = function (RED) {
     try {
       pruneHistoryArchiveFiles({ force: true })
       loadRecentHistoryFromDisk()
+      loadHomeMemoryFromDisk()
     } catch (error) {
       node.sysLogger?.warn(`KNX AI history startup error: ${error.message || error}`)
     }
 
+    if (node._homeMemoryPeriodicTimer) clearInterval(node._homeMemoryPeriodicTimer)
+    node._homeMemoryPeriodicTimer = setInterval(() => {
+      try { persistHomeMemoryNow() } catch (error) { /* persistHomeMemoryNow already guards */ }
+    }, 15 * 60 * 1000)
+
+    if (node._proactiveCheckTimer) clearInterval(node._proactiveCheckTimer)
+    node._proactiveCheckTimer = setInterval(() => {
+      try { checkProactiveHomeState() } catch (error) {
+        try { node.sysLogger?.warn(`KNX AI proactive check error: ${error.message || error}`) } catch (logError) { /* ignore */ }
+      }
+    }, 30 * 1000)
+
     if (node._busConnectionWatchTimer) clearInterval(node._busConnectionWatchTimer)
     node._busConnectionWatchTimer = setInterval(() => {
       pollBusConnectionStatus()

package/nodes/locales/de/knxUltimateAI.html

@@ -1,7 +1,7 @@
 <script type="text/markdown" data-help-name="knxUltimateAI">
 Dieser Node überwacht **alle KNX-Telegramme** des ausgewählten KNX-Ultimate-Gateways, erstellt Verkehrsstatistiken, erkennt Anomalien und kann optional ein LLM befragen.
 
-Die Editor-Bereiche verwenden dieselben vertikalen Tabs auf der linken Seite wie die Matter-Nodes. **Schnelleinrichtung** enthält nur die üblichen KI-Einstellungen (Aktivierung, Anbieter, Zugangsdaten, Modell, KNX-Zustandsabfrage/Aktorsteuerung und Bestätigung); technische Parameter sind thematisch in den übrigen Tabs gruppiert.
+Der Editor verwendet drei Hauptbereiche als Akkordeon: **KI-Assistent** enthält Einrichtung, Wissen/Kontext und Anbietergrenzen; **Gespräche & Zuhause** enthält Chat-Kanäle, proaktives Zuhause und begrenztes Gedächtnis; **KNX-Verkehrsanalyse** enthält Bus-Telegramme, Verlauf/Zusammenfassungen und Anomalien/Muster. Beim Öffnen eines Hauptbereichs werden alle zugehörigen Optionen gemeinsam angezeigt. Gespeicherte Feld-IDs und Werte bleiben unverändert.
 
 ## Ausgänge
 1. **Zusammenfassung/Statistik** (`msg.payload` JSON)
@@ -14,7 +14,7 @@ Jede an den Ausgängen 3 und 4 ausgegebene Nachricht enthält außerdem eine Kop
 ## Befehle (Eingang)
 Sende `msg.topic`:
 - `summary` (oder leer): Summary sofort senden
-- `reset`: internen Verlauf/Zähler zurücksetzen
+- `reset`: internen Verlauf, Zähler und gelerntes Hausgedächtnis löschen; die KI-Erziehung bleibt unverändert
 - `ask`: Frage an das konfigurierte LLM senden
 - `confirm` / `cancel`: ausstehende KNX-Befehle ohne erneuten LLM-Aufruf bestätigen oder abbrechen
 - `clear_chat`: Gesprächsspeicher der aktuellen Sitzung löschen
@@ -35,6 +35,40 @@ Der Tab **Chat-Adapter** lädt seine auswählbaren Zuordnungen aus `resources/KN
 
 Die enthaltene Vorlage **windkh/node-red-contrib-telegrambot** folgt dem Receiver-/Sender-Vertrag des Pakets. Verbinden Sie einen `telegram receiver` direkt mit KNX AI und Ausgang 3 direkt mit einem `telegram sender`. Für Inline-Bestätigungsschaltflächen verbinden Sie zusätzlich einen als `callback_query` konfigurierten `telegram event` mit demselben KNX-AI-Eingang. Die Eingangszuordnung liest `msg.payload.content`, `msg.payload.chatId` und die Telegram-Sprache. Die Ausgangszuordnung erstellt `msg.payload.chatId`, `type` und `content` und ergänzt bei ausstehender Schreibbestätigung `options.reply_markup` aus `msg.knxAi.confirmationRequest`. Das Telegram-Paket bleibt eine separate optionale Abhängigkeit.
 
+## Proaktive Hausintelligenz und begrenztes Gedächtnis
+Der Unterbereich **Proaktives Zuhause & Gedächtnis** in **Gespräche & Zuhause** aktiviert proaktive Benachrichtigungen auf Wunsch des Benutzers. Aus ETS-Hierarchie, Namen, Rollen und DPTs erstellt der Node ein deterministisches semantisches Modell für Rollläden, Fenster, Türen, Licht, Temperatur, Klima, Anwesenheit und Alarme mit italienischen, englischen, deutschen, französischen, spanischen und chinesischen Begriffen. Der erste proaktive Detektor überwacht nur zuverlässig erkannte Nicht-Befehlszustände von Rollläden/Fenstern/Türen. Nach der konfigurierten Offenzeit und außerhalb der Ruhezeiten gibt Ausgang 3 eine lokalisierte Nachricht mit `msg.knxAi.type = "proactive_notification"` aus. Ausgang 4 wird niemals proaktiv verwendet und KNX wird nicht selbstständig verändert; eine spätere Benutzeranfrage durchläuft weiterhin die normale Validierung und Bestätigung.
+
+Die letzte Chat-Sitzung wird als Eigentümer gespeichert; alternativ kann **Hauptempfänger / Chat-ID** sie ausdrücklich festlegen. Ein synthetisches `msg.inputMessage` bewahrt den Empfänger, damit der Telegram-Adapter eine spontane Nachricht senden kann. Cooldown und höchstens drei proaktive Nachrichten pro Stunde verhindern eine Nachrichtenflut.
+
+Die gelernte Referenz wird beim Start aus `<userDir>/knxai/memory/knxai-home-memory-<node-id>.md` geladen, alle 15 Minuten atomar neu geschrieben und strikt auf konfigurierbare 64–1.024 KB begrenzt (standardmäßig 256 KB). Sie enthält höchstens 120 wichtige Beobachtungen, 80 aggregierte Gewohnheiten, 80 Benachrichtigungen und 300 semantische ETS-Objekte, niemals einen unbegrenzten Rohtelegrammstrom. Alte Einträge mit niedriger Priorität werden zuerst entfernt. **KI-Erziehung** ist auf 16.000 Zeichen begrenzt und stammt immer aus der Node-Konfiguration: Die KI darf sie als verbindliche Vorgabe lesen, aber weder ändern noch überschreiben. Ist eine Erziehung vorhanden, kann das LLM sie aber nicht auswerten, wird die mögliche Benachrichtigung unterdrückt, statt ihr möglicherweise zu widersprechen.
+
+## Praktisches Konfigurationsbeispiel
+Dieses Beispiel erstellt einen knappen Assistenten, der wichtige Öffnungen meldet, aber akzeptiert, dass der Rollladen im Büro offen bleiben darf:
+
+| Editor-Feld | Beispielwert | Wirkung |
+|---|---|---|
+| **Proaktive Hausbenachrichtigungen aktivieren** (`proactiveEnabled`) | aktiv | Zuverlässig erkannte offene Rollladen-/Fenster-/Türzustände werden bewertet. |
+| **Hauptempfänger / Chat-ID** (`proactiveRecipient`) | `123456789` | Spontane Nachrichten gehen an diesen Chat; leer bedeutet: letzte Ask-Sitzung merken. |
+| **Nach offener Dauer benachrichtigen** (`proactiveOpenMinutes`) | `120` | Nach zwei Stunden wird eine mögliche Meldung bewertet. |
+| **Ruhezeit Beginn / Ende** | `23:00` / `07:00` | Nachts werden keine proaktiven Nachrichten ausgegeben. |
+| **Wiederholungs-Cooldown** (`proactiveCooldownMinutes`) | `360` | Dasselbe Objekt meldet sich sechs Stunden lang nicht erneut. |
+| **Maximale Hausgedächtnis-Datei** (`homeMemoryMaxKb`) | `256` | Die Markdown-Referenz dieses Nodes bleibt unter 256 KB. |
+
+Beispiel für **KI-Erziehung** (`aiEducation`):
+
+```text
+Nenne mich Alex und antworte in derselben Sprache wie ich.
+Antworte kurz, außer ich bitte um technische Einzelheiten.
+Der Büro-Rollladen darf tagsüber offen bleiben: benachrichtige mich nicht.
+Melde andere Rollläden, Fenster oder Türen, die ungewöhnlich lange offen bleiben.
+Wenn „Wohnzimmerlicht“ mehrdeutig ist, frage nach der gemeinten Leuchte.
+Behaupte nie eine Aktoränderung, bevor ein KNX-Statusobjekt sie bestätigt.
+```
+
+Damit kann Ausgang 3 nach 120 Minuten eine lokalisierte `proactive_notification` für den Wohnzimmer-Rollladen ausgeben, während eine Meldung für den Büro-Rollladen durch die Erziehung unterdrückt wird. Bittet Alex danach um das Schließen, erstellt KNX AI den exakten ETS-Befehl, behält aber Validierung und Bestätigung vor Ausgang 4 bei.
+
+Verwenden Sie aussagekräftige ETS-Hierarchien und Objektnamen sowie korrekte Status-/Befehlsrollen. Die Erziehung personalisiert Entscheidungen und Formulierungen, kann aber keine Gruppenadresse erfinden, keinen DPT ändern und die KNX-Validierung nicht umgehen.
+
 ## Kurzer Ablauf: KNX-Steuerung
 1. Importieren Sie die ETS-CSV in das Gateway und konfigurieren Sie LLM-Anbieter, Modell und Zugangsdaten.
 2. Aktivieren Sie **LLM-Assistent** und **KNX-Zustände lesen und Aktoren steuern**; lassen Sie die Bestätigung aktiviert.
@@ -90,6 +124,13 @@ Hier sind alle Felder aufgeführt, wie sie im KNX-AI-Editor sichtbar sind.
 - **Adapter-Vorlage**: Lädt ein Paar aus Ein- und Ausgangszuordnung aus der mitgelieferten Chat-Adapter-Datei. Die Auswahl ersetzt bewusst beide Textfelder; der Code bleibt danach bearbeitbar.
 - **Eingangszuordnung (Chat → KNX AI)**: Synchrones JavaScript vor der Verarbeitung des Eingangsbefehls.
 - **Ausgangszuordnung (KNX AI → Chat)**: Synchrones JavaScript ausschließlich für Nachrichten an Ausgang 3.
+- **Proaktive Hausbenachrichtigungen aktivieren**: Optionaler Detektor für zuverlässig erkannte offene Rollladen-/Fenster-/Türzustände; er schreibt nie selbstständig auf KNX.
+- **Hauptempfänger / Chat-ID**: Optionales Ziel für unaufgeforderte Chatnachrichten; andernfalls wird die letzte Ask-Sitzung gespeichert.
+- **Nach offener Dauer benachrichtigen (Minuten)**: Schwelle, bevor eine proaktive Nachricht erwogen wird.
+- **Ruhezeit Beginn / Ende**: Täglicher Zeitraum, in dem proaktive Nachrichten unterdrückt werden.
+- **KI-Erziehung**: Verbindliche, ausschließlich vom Benutzer verwaltete Hinweise, die die KI lesen, aber nie ändern darf.
+- **Wiederholungs-Cooldown (Minuten)**: Mindestintervall vor einer weiteren Meldung desselben Objekts.
+- **Maximale Hausgedächtnis-Datei (KB)**: Harte Grenze von 64 bis 1.024 KB; standardmäßig 256 KB.
 - Wenn das Festplattenarchiv aktiv ist, nutzt **Ask** standardmäßig dieses Archiv: explizite Datumsangaben/Zeitbereiche werden beachtet, sonst durchsucht der Assistent die letzten 24 Stunden plus aktuelle RAM-Events.
 - **Include raw payload hex**: Rohe Hex-Payload im Prompt einfügen.
 - **Node-RED-Projektinventar einbeziehen**: Nimmt das gesamte Node-RED-Projektinventar in den Prompt auf, einschließlich KNX-Nodes und anderer hilfreicher Nodes wie function/change/inject/template, wenn sie KNX-Logik oder Gruppenadressen enthalten.