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

package/CHANGELOG.md

@@ -6,6 +6,11 @@
 
 # CHANGELOG
 
+**Version 6.3.21** - August 2026<br/>
+
+- **KNX AI — persistent adapter-event history**: every event published by an automatically detected adapter is now normalized into vendor-neutral metadata and appended to a node-specific daily JSONL archive. The archive follows the 10-day KNX retention, guaranteeing at least 24 hours of camera and future adapter events across Node-RED restarts without storing snapshot image data. The editor context card exposes the actual adapter-history directories.<br/>
+- **KNX AI — authoritative historical queries**: web Assistant, Telegram, RedBot and custom CHAT channels now query both the adapter-event archive and the existing KNX daily telegram files. Historical prompts include totals calculated across every stored row in the requested interval plus relevance-selected detail samples, preventing sample size from being reported as the total. Natural-language ranges now include multilingual “last N hours” requests and are bounded by available retention.<br/>
+
 **Version 6.3.19** - August 2026<br/>
 
 - **KNX AI — conversational multi-step routines**: added coordinated routines such as leaving home, bedtime and cinema mode. KNX AI can now perform a first pass with up to 20 fresh KNX state reads, use the authoritative bus results to prepare an ordered plan of up to 12 validated writes, request one confirmation and then execute the complete routine. After confirmation it waits up to four seconds for immediate matching bus feedback, reports verified and unverified operations without treating missing immediate feedback as a device failure, and dispatches any explicitly requested TTS Ultimate announcement only after execution. Routine details, preliminary readings and execution results are exposed as structured chat metadata. The importable confirmation example, editor help and wiki documentation were updated in EN, IT, DE, FR, ES and zh-CN.<br/>

package/nodes/knxUltimateAI.html

@@ -635,6 +635,7 @@
 
                 const sourceLabels = {
                     knxTraffic: t("knxUltimateAI.messages.chatContextSourceKnxTraffic", "Live KNX summary, anomalies, topology and selected telegrams."),
+                    adapterHistory: t("knxUltimateAI.messages.chatContextSourceAdapterHistory", "Persistent history of automatically detected adapter events."),
                     etsProject: t("knxUltimateAI.messages.chatContextSourceEtsProject", "ETS semantics and the full Node-RED project inventory."),
                     memoryEducation: t("knxUltimateAI.messages.chatContextSourceMemoryEducation", "Session context, AI Education and bounded home memory."),
                     camerasDocs: t("knxUltimateAI.messages.chatContextSourceCamerasDocs", "Detected cameras and relevant help, README and example snippets."),
@@ -668,7 +669,9 @@
 
                 const directoryLabels = {
                     archiveRoot: t("knxUltimateAI.messages.chatContextDirectoryRoot", "Telegram archive root"),
-                    nodeArchive: t("knxUltimateAI.messages.chatContextDirectoryNode", "This node's telegram archive")
+                    nodeArchive: t("knxUltimateAI.messages.chatContextDirectoryNode", "This node's telegram archive"),
+                    adapterArchiveRoot: t("knxUltimateAI.messages.chatContextDirectoryAdapterRoot", "Adapter event archive root"),
+                    adapterNodeArchive: t("knxUltimateAI.messages.chatContextDirectoryAdapterNode", "This node's adapter event archive")
                 };
                 (Array.isArray(overview.telegramDirectories) ? overview.telegramDirectories : []).forEach(function (item) {
                     if (!item || !item.path) return;
@@ -677,7 +680,9 @@
                         directoryLabels[item.id] || String(item.id || ""),
                         "",
                         item.path,
-                        t("knxUltimateAI.messages.chatContextDirectoryBadge", "KNX")
+                        /^adapter/.test(String(item.id || ""))
+                            ? t("knxUltimateAI.messages.chatContextDirectoryAdapterBadge", "Adapter")
+                            : t("knxUltimateAI.messages.chatContextDirectoryBadge", "KNX")
                     );
                 });
 

package/nodes/knxUltimateAI.js

@@ -46,6 +46,13 @@ const {
   normalizeSearchText,
   resolveKnxAiCamera
 } = require('./utils/knxAiCamera')
+const {
+  KNX_AI_ADAPTER_HISTORY_MIN_HOURS,
+  buildKnxAiHistoryEventKey,
+  createKnxAiHistoryAccumulator,
+  formatKnxAiAdapterHistoryEventForPrompt,
+  normalizeKnxAiAdapterHistoryEvent
+} = require('./utils/knxAiEventHistory')
 let googleTranslateTTS = null
 try {
   googleTranslateTTS = require('google-translate-tts')
@@ -72,6 +79,7 @@ const KNX_AI_LOCAL_LLM_TIMEOUT_MIN_MS = 10 * 60 * 1000
 const KNX_AI_MINIMAL_CONTEXT_MAX_TOKENS = 16 * 1024
 const KNX_AI_COMPACT_CONTEXT_MAX_TOKENS = 64 * 1024
 const KNX_AI_ROUTINE_FEEDBACK_TIMEOUT_MS = 4000
+const KNX_AI_ADAPTER_HISTORY_RETENTION_DAYS = Math.max(1, KNX_AI_TRAFFIC_DEFAULTS.historyStoreRetentionDays)
 
 const resolveKnxAiLlmTimeoutMs = ({ provider, configuredTimeoutMs } = {}) => {
   const configured = Number(configuredTimeoutMs)
@@ -324,6 +332,8 @@ const summarizeKnxAiChatContext = ({ node, nodeId, redUserDir } = {}) => {
   const configDir = path.join(knxAiDir, 'config')
   const telegramArchiveRoot = path.join(knxAiDir, 'history')
   const telegramNodeDir = safeNodeId ? path.join(telegramArchiveRoot, safeNodeId) : ''
+  const adapterArchiveRoot = path.join(knxAiDir, 'adapter-history')
+  const adapterNodeDir = safeNodeId ? path.join(adapterArchiveRoot, safeNodeId) : ''
 
   const files = [
     {
@@ -346,11 +356,13 @@ const summarizeKnxAiChatContext = ({ node, nodeId, redUserDir } = {}) => {
   }
 
   return {
-    sources: ['knxTraffic', 'etsProject', 'memoryEducation', 'camerasDocs', 'ttsUltimate'],
+    sources: ['knxTraffic', 'adapterHistory', 'etsProject', 'memoryEducation', 'camerasDocs', 'ttsUltimate'],
     files: files.map(item => Object.assign({}, item, { exists: fs.existsSync(item.path) })),
     telegramDirectories: [
       { id: 'archiveRoot', path: telegramArchiveRoot, exists: fs.existsSync(telegramArchiveRoot) },
-      ...(telegramNodeDir ? [{ id: 'nodeArchive', path: telegramNodeDir, exists: fs.existsSync(telegramNodeDir) }] : [])
+      ...(telegramNodeDir ? [{ id: 'nodeArchive', path: telegramNodeDir, exists: fs.existsSync(telegramNodeDir) }] : []),
+      { id: 'adapterArchiveRoot', path: adapterArchiveRoot, exists: fs.existsSync(adapterArchiveRoot) },
+      ...(adapterNodeDir ? [{ id: 'adapterNodeArchive', path: adapterNodeDir, exists: fs.existsSync(adapterNodeDir) }] : [])
     ],
     telegramFilePattern: 'YYYY-MM-DD.jsonl'
   }
@@ -2505,7 +2517,18 @@ const parseQuestionTimeRange = (question, nowTs = Date.now()) => {
     return { fromTs: yesterdayStart, toTs: yesterdayEnd, label: 'yesterday', explicit: true }
   }
 
-  const lastDaysMatch = text.match(/\b(?:last|ultimi)\s+(\d{1,3})\s+(?:day|days|giorno|giorni)\b/)
+  const lastHoursMatch = text.match(/\b(?:last|ultime|ultimi|letzte[n]?|derni[eè]res?|[uú]ltimas?)\s+(\d{1,3})\s+(?:hour|hours|ora|ore|stunde|stunden|heure|heures|hora|horas)\b/)
+  if (lastHoursMatch) {
+    const hours = Math.max(1, Number(lastHoursMatch[1] || 1))
+    return {
+      fromTs: nowTs - (hours * 60 * 60 * 1000),
+      toTs: nowTs,
+      label: `last ${hours} hours`,
+      explicit: true
+    }
+  }
+
+  const lastDaysMatch = text.match(/\b(?:last|ultimi|ultime|letzte[n]?|derni[eè]res?|[uú]ltimos?|[uú]ltimas?)\s+(\d{1,3})\s+(?:day|days|giorno|giorni|tag|tage|tagen|jour|jours|d[ií]a|d[ií]as)\b/)
   if (lastDaysMatch) {
     const days = Math.max(1, Number(lastDaysMatch[1] || 1))
     return {
@@ -6148,6 +6171,9 @@ module.exports = function (RED) {
     node._gaLabelCsvCache = { ref: null, map: {} }
     node._busConnectionWatchTimer = null
     node._historyDiskLastPruneAt = 0
+    node._historyDiskPending = new Map()
+    node._adapterHistoryDiskLastPruneAt = 0
+    node._adapterHistoryDiskPending = new Map()
     node._homeMemory = createEmptyKnxAiHomeMemory()
     node._homeMemoryWriteTimer = null
     node._homeMemoryPeriodicTimer = null
@@ -7269,6 +7295,12 @@ module.exports = function (RED) {
       const maxEvents = Math.min(minimalMode ? 20 : compactMode ? 50 : 240, maxEventsRequested)
       const promptEvents = selectTelegramsForPrompt({ question, maxEvents })
       const recent = Array.isArray(promptEvents.events) ? promptEvents.events : []
+      const adapterPromptEvents = selectAdapterEventsForPrompt({
+        question,
+        maxEvents: minimalMode ? 12 : compactMode ? 30 : 160,
+        range: promptEvents.range
+      })
+      const recentAdapterEvents = Array.isArray(adapterPromptEvents.events) ? adapterPromptEvents.events : []
       const wantsSvgChart = shouldGenerateSvgChart(question)
       const wantsFunctionNodeSourceContext = shouldIncludeFunctionNodeSourceContext(question)
       const areasSnapshot = buildAreasSnapshot({ summary })
@@ -7286,7 +7318,14 @@ module.exports = function (RED) {
         return `${new Date(t.ts).toISOString()} ${t.event} ${t.source} -> ${t.destination}${devName} dpt=${t.dpt} payload=${payloadStr}${rawStr}`
       })
       const recentLines = takeLastItemsByCharBudget(lines, minimalMode ? 1000 : compactMode ? 2200 : 7000)
-      const archiveScopeLine = `Prompt event source: ${promptEvents.source}. Time range: ${promptEvents.range && promptEvents.range.label ? promptEvents.range.label : 'recent events'}. Events selected: ${recent.length}.`
+      const archiveScopeLine = `Prompt event source: ${promptEvents.source}. Time range: ${promptEvents.range && promptEvents.range.label ? promptEvents.range.label : 'recent events'}${promptEvents.range && promptEvents.range.clampedToRetention ? ` (clamped to ${promptEvents.range.retentionDays} available day(s))` : ''}. Events selected: ${recent.length}.`
+      const knxArchiveSummary = truncatePromptText(safeStringify(promptEvents.summary || {}), minimalMode ? 1200 : compactMode ? 3000 : 9000)
+      const adapterArchiveSummary = truncatePromptText(safeStringify(adapterPromptEvents.summary || {}), minimalMode ? 1000 : compactMode ? 2600 : 8000)
+      const adapterLines = takeLastItemsByCharBudget(
+        recentAdapterEvents.map(formatKnxAiAdapterHistoryEventForPrompt).filter(Boolean),
+        minimalMode ? 700 : compactMode ? 1800 : 6000
+      )
+      const adapterArchiveScopeLine = `Adapter event source: ${adapterPromptEvents.source}. Time range: ${adapterPromptEvents.range && adapterPromptEvents.range.label ? adapterPromptEvents.range.label : 'last 24 hours'}${adapterPromptEvents.range && adapterPromptEvents.range.clampedToRetention ? ` (clamped to ${adapterPromptEvents.range.retentionDays} available day(s))` : ''}. Events selected: ${recentAdapterEvents.length}.`
 
       let flowContext = ''
       const flowMaxChars = minimalMode ? 600 : compactMode ? 1200 : 5000
@@ -7388,10 +7427,22 @@ module.exports = function (RED) {
         wantsSvgChart ? '- Prefer width via viewBox and include labels + legend when useful.' : '',
         wantsSvgChart ? '' : '',
         archiveScopeLine,
+        'The KNX archive summary below is calculated from every stored telegram in the requested interval. Use its totals for counts; the selected telegrams are only a relevant/recent sample.',
+        'KNX historical archive summary (JSON):',
+        knxArchiveSummary,
         '',
         'Selected KNX telegrams:',
         recentLines.join('\n'),
         '',
+        adapterArchiveScopeLine,
+        `Adapter history retention: ${KNX_AI_ADAPTER_HISTORY_RETENTION_DAYS} day(s), with a guaranteed minimum query window of ${KNX_AI_ADAPTER_HISTORY_MIN_HOURS} hours.`,
+        'The adapter archive summary below is calculated from every stored event in the requested interval. Use its totals for counts; the selected events are only a relevant/recent sample.',
+        'Adapter historical archive summary (JSON):',
+        adapterArchiveSummary,
+        '',
+        'Selected adapter events:',
+        adapterLines.length ? adapterLines.join('\n') : '(no stored adapter events in this interval)',
+        '',
         'User request:',
         question || ''
       ].join('\n')
@@ -7445,6 +7496,15 @@ module.exports = function (RED) {
 
     const getHistoryArchiveFile = (dayKey) => path.join(getHistoryArchiveDir(), `${String(dayKey || '').trim() || formatArchiveDayKey(Date.now())}.jsonl`)
 
+    const getAdapterHistoryArchiveDir = () => {
+      const baseDir = (node.serverKNX && node.serverKNX.userDir)
+        ? node.serverKNX.userDir
+        : path.join(RED.settings.userDir, 'knxultimatestorage')
+      return path.join(baseDir, 'knxai', 'adapter-history', node.id)
+    }
+
+    const getAdapterHistoryArchiveFile = dayKey => path.join(getAdapterHistoryArchiveDir(), `${String(dayKey || '').trim() || formatArchiveDayKey(Date.now())}.jsonl`)
+
     const getHomeMemoryFile = () => {
       const baseDir = (node.serverKNX && node.serverKNX.userDir)
         ? node.serverKNX.userDir
@@ -7752,7 +7812,7 @@ module.exports = function (RED) {
       try {
         if (!fs.existsSync(dirPath)) return
         const entries = fs.readdirSync(dirPath, { withFileTypes: true })
-        const cutoffTs = now - ((retentionDays - 1) * 24 * 60 * 60 * 1000)
+        const cutoffTs = now - (retentionDays * 24 * 60 * 60 * 1000)
         const cutoffDayKey = formatArchiveDayKey(cutoffTs)
         for (let i = 0; i < entries.length; i++) {
           const entry = entries[i]
@@ -7776,7 +7836,10 @@ module.exports = function (RED) {
       const dayKey = formatArchiveDayKey(telegram.ts || Date.now())
       const filePath = getHistoryArchiveFile(dayKey)
       const line = JSON.stringify(telegram) + '\n'
+      const pendingKey = buildKnxAiHistoryEventKey(telegram, 'knx')
+      if (pendingKey) node._historyDiskPending.set(pendingKey, telegram)
       fs.appendFile(filePath, line, 'utf8', (error) => {
+        if (pendingKey && node._historyDiskPending.get(pendingKey) === telegram) node._historyDiskPending.delete(pendingKey)
         if (error) node.sysLogger?.warn(`KNX AI history append error: ${error.message || error}`)
       })
       pruneHistoryArchiveFiles()
@@ -7820,45 +7883,68 @@ module.exports = function (RED) {
       }
     }
 
-    const loadHistorySliceFromDisk = ({ fromTs, toTs, limit = 240 } = {}) => {
-      if (node.historyStoreToDisk !== true) return []
+    const loadHistoryQueryFromDisk = ({ fromTs, toTs, limit = 240, question = '' } = {}) => {
+      const emptyAccumulator = () => createKnxAiHistoryAccumulator({ kind: 'knx', question, limit }).finish()
+      if (node.historyStoreToDisk !== true) return emptyAccumulator()
       const archiveDir = getHistoryArchiveDir()
       try {
-        if (!fs.existsSync(archiveDir)) return []
         const from = Number(fromTs || 0)
         const to = Number(toTs || 0)
-        if (!Number.isFinite(from) || !Number.isFinite(to) || to < from) return []
+        if (!Number.isFinite(from) || !Number.isFinite(to) || to < from) return emptyAccumulator()
+        const accumulator = createKnxAiHistoryAccumulator({ kind: 'knx', question, limit })
+        const pending = node._historyDiskPending instanceof Map ? node._historyDiskPending : new Map()
         const dayKeys = collectArchiveDayKeysBetween({ fromTs: from, toTs: to })
-        if (!dayKeys.length) return []
-        const items = []
-        for (let i = 0; i < dayKeys.length; i++) {
-          const filePath = getHistoryArchiveFile(dayKeys[i])
-          if (!fs.existsSync(filePath)) continue
-          const raw = fs.readFileSync(filePath, 'utf8')
-          if (!raw || String(raw).trim() === '') continue
-          const lines = raw.split(/\r?\n/)
-          for (let j = 0; j < lines.length; j++) {
-            const line = lines[j]
-            if (!line) continue
-            try {
-              const telegram = JSON.parse(line)
-              const ts = Number(telegram && telegram.ts ? telegram.ts : 0)
-              if (!Number.isFinite(ts) || ts < from || ts > to) continue
-              items.push(telegram)
-            } catch (error) {
-              // Ignore malformed archive rows.
+        if (fs.existsSync(archiveDir)) {
+          for (let i = 0; i < dayKeys.length; i++) {
+            const filePath = getHistoryArchiveFile(dayKeys[i])
+            if (!fs.existsSync(filePath)) continue
+            const raw = fs.readFileSync(filePath, 'utf8')
+            if (!raw || String(raw).trim() === '') continue
+            const lines = raw.split(/\r?\n/)
+            for (let j = 0; j < lines.length; j++) {
+              const line = lines[j]
+              if (!line) continue
+              try {
+                const telegram = JSON.parse(line)
+                const ts = Number(telegram && telegram.ts ? telegram.ts : 0)
+                if (!Number.isFinite(ts) || ts < from || ts > to) continue
+                const key = buildKnxAiHistoryEventKey(telegram, 'knx')
+                if (key && pending.has(key)) continue
+                accumulator.add(telegram)
+              } catch (error) {
+                // Ignore malformed archive rows.
+              }
             }
           }
         }
-        if (!items.length) return []
-        items.sort((a, b) => Number(a.ts || 0) - Number(b.ts || 0))
-        return items.slice(-Math.max(1, Number(limit || 1)))
+        pending.forEach(telegram => {
+          const ts = Number(telegram && telegram.ts ? telegram.ts : 0)
+          if (Number.isFinite(ts) && ts >= from && ts <= to) accumulator.add(telegram)
+        })
+        return accumulator.finish()
       } catch (error) {
         node.sysLogger?.warn(`KNX AI history load slice error: ${error.message || error}`)
-        return []
+        return emptyAccumulator()
       }
     }
 
+    const clampArchiveRangeToRetention = ({ range, retentionDays }) => {
+      const now = nowMs()
+      const days = Math.max(1, Number(retentionDays) || 1)
+      const earliest = now - (days * 24 * 60 * 60 * 1000)
+      const source = range && typeof range === 'object'
+        ? range
+        : { fromTs: now - (24 * 60 * 60 * 1000), toTs: now, label: 'last 24 hours', explicit: false }
+      const fromTs = Math.max(earliest, Number(source.fromTs || earliest))
+      const toTs = Math.min(now, Number(source.toTs || now))
+      return Object.assign({}, source, {
+        fromTs,
+        toTs: Math.max(fromTs, toTs),
+        retentionDays: days,
+        clampedToRetention: Number(source.fromTs || 0) < earliest
+      })
+    }
+
     const selectTelegramsForPrompt = ({ question, maxEvents }) => {
       const now = nowMs()
       const maxItems = Math.max(10, Number(maxEvents) || 120)
@@ -7866,36 +7952,132 @@ module.exports = function (RED) {
       const fallbackRange = node.historyStoreToDisk === true
         ? { fromTs: now - (24 * 60 * 60 * 1000), toTs: now, label: 'last 24 hours', explicit: false }
         : { fromTs: now - (Math.max(5, Number(node.historyWindowSec || 5)) * 1000), toTs: now, label: 'memory window', explicit: false }
-      const range = explicitRange || fallbackRange
+      const range = clampArchiveRangeToRetention({
+        range: explicitRange || fallbackRange,
+        retentionDays: node.historyStoreRetentionDays
+      })
 
       let selected = []
       let source = 'memory'
+      let archiveSummary = null
       if (node.historyStoreToDisk === true) {
-        const diskItems = loadHistorySliceFromDisk({ fromTs: range.fromTs, toTs: range.toTs, limit: maxItems * 3 })
-        const memoryItems = node._history.filter(t => Number(t && t.ts ? t.ts : 0) >= range.fromTs && Number(t && t.ts ? t.ts : 0) <= range.toTs)
-        const dedupe = new Map()
-        diskItems.concat(memoryItems).forEach((telegram) => {
-          if (!telegram || typeof telegram !== 'object') return
-          const key = [
-            Number(telegram.ts || 0),
-            String(telegram.event || ''),
-            String(telegram.source || ''),
-            String(telegram.destination || ''),
-            normalizeValueForCompare(telegram.payload),
-            String(telegram.rawHex || '')
-          ].join('|')
-          dedupe.set(key, telegram)
-        })
-        selected = Array.from(dedupe.values()).sort((a, b) => Number(a.ts || 0) - Number(b.ts || 0)).slice(-maxItems)
-        source = 'archive+memory'
+        const query = loadHistoryQueryFromDisk({ fromTs: range.fromTs, toTs: range.toTs, limit: maxItems, question })
+        selected = query.events
+        archiveSummary = query.summary
+        source = 'daily JSONL archive'
       } else {
         selected = node._history.slice(-maxItems)
+        const accumulator = createKnxAiHistoryAccumulator({ kind: 'knx', question, limit: maxItems })
+        selected.forEach(telegram => accumulator.add(telegram))
+        const memoryQuery = accumulator.finish()
+        selected = memoryQuery.events
+        archiveSummary = memoryQuery.summary
       }
 
       return {
         events: selected,
         source,
-        range
+        range,
+        summary: archiveSummary
+      }
+    }
+
+    const pruneAdapterHistoryArchiveFiles = ({ force = false } = {}) => {
+      const now = nowMs()
+      if (!force && (now - Number(node._adapterHistoryDiskLastPruneAt || 0)) < (60 * 60 * 1000)) return
+      node._adapterHistoryDiskLastPruneAt = now
+      const dirPath = getAdapterHistoryArchiveDir()
+      try {
+        if (!fs.existsSync(dirPath)) return
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true })
+        const retentionDays = Math.max(1, KNX_AI_ADAPTER_HISTORY_RETENTION_DAYS)
+        const cutoffDayKey = formatArchiveDayKey(now - (retentionDays * 24 * 60 * 60 * 1000))
+        entries.forEach(entry => {
+          if (!entry || !entry.isFile()) return
+          const match = String(entry.name || '').match(/^(\d{4}-\d{2}-\d{2})\.jsonl$/)
+          if (!match || match[1] >= cutoffDayKey) return
+          try { fs.unlinkSync(path.join(dirPath, entry.name)) } catch (error) { /* ignore */ }
+        })
+      } catch (error) {
+        node.sysLogger?.warn(`KNX AI adapter history prune error: ${error.message || error}`)
+      }
+    }
+
+    const persistAdapterEventToDisk = ({ event, adapter, provider } = {}) => {
+      const normalized = normalizeKnxAiAdapterHistoryEvent({ event, adapter, provider, nowTs: nowMs() })
+      if (!normalized) return null
+      const archiveDir = getAdapterHistoryArchiveDir()
+      if (!ensureDirectorySync(archiveDir)) return normalized
+      const filePath = getAdapterHistoryArchiveFile(formatArchiveDayKey(normalized.ts))
+      const pendingKey = buildKnxAiHistoryEventKey(normalized, 'adapter')
+      if (pendingKey) node._adapterHistoryDiskPending.set(pendingKey, normalized)
+      fs.appendFile(filePath, `${JSON.stringify(normalized)}\n`, 'utf8', error => {
+        if (pendingKey && node._adapterHistoryDiskPending.get(pendingKey) === normalized) node._adapterHistoryDiskPending.delete(pendingKey)
+        if (error) node.sysLogger?.warn(`KNX AI adapter history append error: ${error.message || error}`)
+      })
+      pruneAdapterHistoryArchiveFiles()
+      return normalized
+    }
+
+    const loadAdapterHistoryQueryFromDisk = ({ fromTs, toTs, limit = 160, question = '' } = {}) => {
+      const accumulator = createKnxAiHistoryAccumulator({ kind: 'adapter', question, limit })
+      const from = Number(fromTs || 0)
+      const to = Number(toTs || 0)
+      if (!Number.isFinite(from) || !Number.isFinite(to) || to < from) return accumulator.finish()
+      const pending = node._adapterHistoryDiskPending instanceof Map ? node._adapterHistoryDiskPending : new Map()
+      try {
+        const archiveDir = getAdapterHistoryArchiveDir()
+        const dayKeys = collectArchiveDayKeysBetween({ fromTs: from, toTs: to })
+        if (fs.existsSync(archiveDir)) {
+          dayKeys.forEach(dayKey => {
+            const filePath = getAdapterHistoryArchiveFile(dayKey)
+            if (!fs.existsSync(filePath)) return
+            const raw = fs.readFileSync(filePath, 'utf8')
+            if (!raw || String(raw).trim() === '') return
+            raw.split(/\r?\n/).forEach(line => {
+              if (!line) return
+              try {
+                const item = JSON.parse(line)
+                const ts = Number(item && item.ts ? item.ts : 0)
+                if (!Number.isFinite(ts) || ts < from || ts > to) return
+                const key = buildKnxAiHistoryEventKey(item, 'adapter')
+                if (key && pending.has(key)) return
+                accumulator.add(item)
+              } catch (error) { /* ignore malformed archive rows */ }
+            })
+          })
+        }
+        pending.forEach(item => {
+          const ts = Number(item && item.ts ? item.ts : 0)
+          if (Number.isFinite(ts) && ts >= from && ts <= to) accumulator.add(item)
+        })
+      } catch (error) {
+        node.sysLogger?.warn(`KNX AI adapter history load error: ${error.message || error}`)
+      }
+      return accumulator.finish()
+    }
+
+    const selectAdapterEventsForPrompt = ({ question, maxEvents, range } = {}) => {
+      const effectiveRange = clampArchiveRangeToRetention({
+        range: range || parseQuestionTimeRange(question, nowMs()) || {
+          fromTs: nowMs() - (KNX_AI_ADAPTER_HISTORY_MIN_HOURS * 60 * 60 * 1000),
+          toTs: nowMs(),
+          label: `last ${KNX_AI_ADAPTER_HISTORY_MIN_HOURS} hours`,
+          explicit: false
+        },
+        retentionDays: KNX_AI_ADAPTER_HISTORY_RETENTION_DAYS
+      })
+      const query = loadAdapterHistoryQueryFromDisk({
+        fromTs: effectiveRange.fromTs,
+        toTs: effectiveRange.toTs,
+        limit: Math.max(1, Number(maxEvents) || 160),
+        question
+      })
+      return {
+        events: query.events,
+        summary: query.summary,
+        source: 'daily JSONL adapter archive',
+        range: effectiveRange
       }
     }
 
@@ -10190,6 +10372,8 @@ module.exports = function (RED) {
         '- For an explicit request to refresh, read, query, or retrieve a current KNX state, create GroupValue_Read operations for the exact relevant objects. Use payload null for reads.',
         '- GroupValue_Read is allowed for exact status, neutral, or command objects in AVAILABLE KNX OBJECTS because it does not modify the bus state.',
         '- For a question that can be answered from recent data, return commands as an empty array. If current data is missing or the user explicitly asks for a fresh read, request it instead of claiming that read-only objects cannot be queried.',
+        '- Historical questions must use the KNX and adapter archive summaries in the supplied analysis context. Totals describe every stored row in the requested interval; selected rows are samples for detail and must not be used as the total count.',
+        '- Adapter history includes automatically detected provider events such as camera motion and smart detections. Do not claim that the absence of an archived event proves physical absence; report only what the adapters recorded.',
         '- Create a GroupValue_Write only when the user clearly asks to control an actuator now.',
         '- Never invent, guess, transform, or substitute a group address or DPT.',
         '- A GroupValue_Write destination must appear in AVAILABLE KNX OBJECTS with role command. Status and neutral objects must never receive GroupValue_Write.',
@@ -10901,9 +11085,14 @@ module.exports = function (RED) {
       }
     }
 
-    const handleCameraAdapterEvent = (providerEvent) => {
+    const handleCameraAdapterEvent = (providerEvent, provider = null) => {
       const event = normalizeKnxAiCameraEvent(providerEvent)
-      if (!event || event.active === false) return false
+      if (!event) return false
+      const adapter = provider && node._cameraAdapters instanceof Map
+        ? node._cameraAdapters.get(String(provider.adapterId || ''))
+        : null
+      persistAdapterEventToDisk({ event: Object.assign({}, providerEvent, event), adapter, provider })
+      if (event.active === false) return true
       const now = nowMs()
       listAllKnxAiCameraWatches(node._chatContext).filter(watch => cameraWatchMatchesEvent(watch, event)).forEach((watch) => {
         const lastAt = Number(node._cameraWatchLastTriggered.get(watch.id) || 0)
@@ -10958,7 +11147,7 @@ module.exports = function (RED) {
           if (previousProvider === provider && node._cameraProviderUnsubscribers.has(providerId)) return
           if (typeof provider.subscribe === 'function') {
             const unsubscribe = provider.subscribe(event => {
-              try { handleCameraAdapterEvent(event) } catch (error) {
+              try { handleCameraAdapterEvent(event, provider) } catch (error) {
                 try { node.sysLogger?.warn(`KNX AI camera event error: ${error.message || error}`) } catch (logError) { /* ignore */ }
               }
             })
@@ -12312,6 +12501,7 @@ module.exports = function (RED) {
 
     try {
       pruneHistoryArchiveFiles({ force: true })
+      pruneAdapterHistoryArchiveFiles({ force: true })
       loadRecentHistoryFromDisk()
       loadHomeMemoryFromDisk()
       loadChatContextFromDisk()
@@ -12367,6 +12557,7 @@ module.exports = function (RED) {
 }
 
 module.exports.__test = {
+  KNX_AI_ADAPTER_HISTORY_RETENTION_DAYS,
   KNX_AI_CLOUD_LLM_TIMEOUT_MIN_MS,
   KNX_AI_COMPACT_CONTEXT_MAX_TOKENS,
   KNX_AI_LOCAL_CONTEXT_RETRY_CHAR_BUDGETS,
@@ -12410,6 +12601,7 @@ module.exports.__test = {
   normalizeKnxAiCommandCandidates,
   normalizeKnxAiRoutineDescriptor,
   normalizeLmStudioModelCatalog,
+  parseQuestionTimeRange,
   parseKnxAiConversationResponse,
   postLocalLlmWithContextFallbacks,
   postOpenAiCompatibleChatWithFallbacks,

package/nodes/locales/de/knxUltimateAI.html

@@ -51,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

@@ -51,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

@@ -51,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

@@ -51,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

@@ -51,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

@@ -51,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.19",
+  "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/",