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

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')
@@ -71,7 +78,10 @@ const KNX_AI_CLOUD_LLM_TIMEOUT_MIN_MS = 120000
 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_LMSTUDIO_PROMPT_CONTEXT_MAX_TOKENS = 16 * 1024
+const KNX_AI_OLLAMA_CONTEXT_MAX_TOKENS = 16 * 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)
@@ -83,13 +93,77 @@ const resolveKnxAiLlmTimeoutMs = ({ provider, configuredTimeoutMs } = {}) => {
 
 const resolveKnxAiPromptContextMode = ({ provider, contextLength } = {}) => {
   if (provider !== 'ollama' && provider !== 'lmstudio') return 'full'
-  const tokens = Math.max(0, Number(contextLength) || 0)
+  const reportedTokens = Math.max(0, Number(contextLength) || 0)
+  // Local providers may advertise a 131K model capability even when that is a
+  // poor operational choice. Never let the advertised maximum promote KNX AI
+  // to the huge "full" prompt. The 16K semantic view retains every action type
+  // while selecting only question-relevant KNX/history/project context.
+  const localPromptCap = provider === 'lmstudio'
+    ? KNX_AI_LMSTUDIO_PROMPT_CONTEXT_MAX_TOKENS
+    : KNX_AI_OLLAMA_CONTEXT_MAX_TOKENS
+  const tokens = Math.min(reportedTokens || localPromptCap, localPromptCap)
   if (!tokens) return 'full'
   if (tokens <= KNX_AI_MINIMAL_CONTEXT_MAX_TOKENS) return 'minimal'
   if (tokens <= KNX_AI_COMPACT_CONTEXT_MAX_TOKENS) return 'compact'
   return 'full'
 }
 
+const resolveKnxAiOperationalContextLimit = ({ provider, contextLength } = {}) => {
+  const normalizedProvider = String(provider || '').trim().toLowerCase()
+  const localPromptCap = normalizedProvider === 'lmstudio'
+    ? KNX_AI_LMSTUDIO_PROMPT_CONTEXT_MAX_TOKENS
+    : normalizedProvider === 'ollama'
+      ? KNX_AI_OLLAMA_CONTEXT_MAX_TOKENS
+      : 0
+  if (!localPromptCap) {
+    return {
+      provider: normalizedProvider,
+      tokens: 0,
+      mode: 'provider-managed'
+    }
+  }
+  const activeContextLength = Math.max(0, Number(contextLength) || 0)
+  return {
+    provider: normalizedProvider,
+    tokens: Math.min(activeContextLength || localPromptCap, localPromptCap),
+    mode: 'fixed'
+  }
+}
+
+const measureKnxAiPromptContext = ({ body, provider, model } = {}) => {
+  const requestBody = body && typeof body === 'object' ? body : {}
+  const textParts = []
+  let imageCount = 0
+  const appendContent = (content) => {
+    if (typeof content === 'string') {
+      textParts.push(content)
+      return
+    }
+    if (!Array.isArray(content)) return
+    content.forEach(part => {
+      if (!part || typeof part !== 'object') return
+      if (part.type === 'text' && typeof part.text === 'string') textParts.push(part.text)
+      if (part.type === 'image' || part.type === 'image_url') imageCount += 1
+    })
+  }
+  appendContent(requestBody.system)
+  ;(Array.isArray(requestBody.messages) ? requestBody.messages : []).forEach(message => {
+    if (!message || typeof message !== 'object') return
+    appendContent(message.content)
+    if (Array.isArray(message.images)) imageCount += message.images.length
+  })
+  const promptText = textParts.join('\n')
+  const bytes = Buffer.byteLength(promptText, 'utf8')
+  return {
+    provider: String(provider || '').trim().toLowerCase(),
+    model: String(model || requestBody.model || '').trim(),
+    bytes,
+    characters: promptText.length,
+    estimatedInputTokens: bytes > 0 ? Math.max(1, Math.ceil(bytes / 4)) : 0,
+    imageCount
+  }
+}
+
 const selectKnxAiCatalogForPrompt = ({ catalog, question, mode = 'full' } = {}) => {
   const source = Array.isArray(catalog) ? catalog : []
   if (mode === 'full') return source.slice(0, 600)
@@ -324,6 +398,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 +422,20 @@ const summarizeKnxAiChatContext = ({ node, nodeId, redUserDir } = {}) => {
   }
 
   return {
-    sources: ['knxTraffic', 'etsProject', 'memoryEducation', 'camerasDocs', 'ttsUltimate'],
+    contextLimit: resolveKnxAiOperationalContextLimit({
+      provider: node && node.llmProvider,
+      contextLength: node && node.llmContextLength
+    }),
+    lastPromptUsage: node && node._lastChatPromptUsage
+      ? Object.assign({}, node._lastChatPromptUsage)
+      : null,
+    sources: ['knxTraffic', 'adapterHistory', 'etsProject', 'memoryEducation', 'cameras', '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'
   }
@@ -1819,7 +1904,26 @@ const coerceKnxAiCommandPayload = (value, { dpt } = {}) => {
 const resolveKnxAiOperationEvent = (candidate) => {
   const item = candidate && typeof candidate === 'object' ? candidate : {}
   const raw = String(item.event || item.operation || item.action || '').trim().toLowerCase()
-  if (['groupvalue_read', 'read', 'query', 'request_status'].includes(raw)) return 'GroupValue_Read'
+  const normalized = raw.replace(/[\s-]+/g, '_')
+  const compact = normalized.replace(/[^a-z]/g, '')
+  const readNames = new Set([
+    'groupvalue_read', 'groupvalue_response', 'read', 'query', 'get',
+    'get_state', 'read_state', 'read_status', 'request_status', 'status'
+  ])
+  if (readNames.has(normalized) || ['groupvalueread', 'groupvalueresponse', 'getstate', 'readstate', 'readstatus', 'requeststatus'].includes(compact)) {
+    return 'GroupValue_Read'
+  }
+  const writeNames = new Set(['groupvalue_write', 'write', 'set', 'set_state', 'command'])
+  if (writeNames.has(normalized) || ['groupvaluewrite', 'setstate'].includes(compact)) return 'GroupValue_Write'
+
+  // Small local models sometimes omit the operation discriminator on a state
+  // query even though they correctly return exact ETS destinations. An item
+  // without a payload cannot be an actuator write, so treat it as a safe read.
+  // Legacy write proposals that contain a payload remain writes and still pass
+  // through command-role, DPT, payload and confirmation validation.
+  const hasPayload = Object.prototype.hasOwnProperty.call(item, 'payload') || Object.prototype.hasOwnProperty.call(item, 'value')
+  const payload = Object.prototype.hasOwnProperty.call(item, 'payload') ? item.payload : item.value
+  if (!hasPayload || payload === null || payload === undefined) return 'GroupValue_Read'
   return 'GroupValue_Write'
 }
 
@@ -2505,7 +2609,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 {
@@ -4090,12 +4205,11 @@ const findLmStudioModel = ({ catalog, model }) => {
   }) || null
 }
 
-const ensureLmStudioModelMaxContext = async ({
+const resolveLmStudioModelContext = async ({
   baseUrl,
   apiKey,
   model,
-  get = getJson,
-  post = postJson
+  get = getJson
 } = {}) => {
   const selectedModel = String(model || '').trim()
   if (!selectedModel) throw new Error('No Bionic LM Studio model selected')
@@ -4109,74 +4223,40 @@ const ensureLmStudioModelMaxContext = async ({
     model: selectedModel
   })
   if (!descriptor) throw new Error(`Bionic LM Studio model not found: ${selectedModel}`)
-  const targetContextLength = Math.max(0, Number(descriptor.maxContextLength) || 0)
-  if (!targetContextLength) {
+  const maxContextLength = Math.max(0, Number(descriptor.maxContextLength) || 0)
+  if (!maxContextLength) {
     throw new Error(`Bionic LM Studio did not report max_context_length for model "${descriptor.id}"`)
   }
-  const readyInstance = descriptor.loadedInstances.find(instance => instance.contextLength === targetContextLength)
+  // A loaded instance reflects the context explicitly chosen in Bionic LM
+  // Studio. Preserve it instead of treating max_context_length (a capability)
+  // as the desired runtime configuration and silently reloading the model.
+  const readyInstance = descriptor.loadedInstances.find(instance => {
+    return instance.id === selectedModel && instance.contextLength > 0
+  }) || descriptor.loadedInstances.find(instance => instance.contextLength > 0)
   if (readyInstance) {
     return {
       model: descriptor.id,
       displayName: descriptor.displayName,
       instanceId: readyInstance.id,
-      contextLength: targetContextLength,
-      maxContextLength: targetContextLength,
+      contextLength: readyInstance.contextLength,
+      maxContextLength,
+      active: true,
       changed: false
     }
   }
 
-  const unloadUrl = deriveLmStudioNativeApiUrl(baseUrl, '/api/v1/models/unload')
-  const loadUrl = deriveLmStudioNativeApiUrl(baseUrl, '/api/v1/models/load')
-  for (const instance of descriptor.loadedInstances) {
-    // eslint-disable-next-line no-await-in-loop
-    await post({
-      url: unloadUrl,
-      headers,
-      body: { instance_id: instance.id },
-      timeoutMs: KNX_AI_LOCAL_LLM_TIMEOUT_MIN_MS
-    })
-  }
-
-  try {
-    const loaded = await post({
-      url: loadUrl,
-      headers,
-      body: {
-        model: descriptor.id,
-        context_length: targetContextLength,
-        echo_load_config: true
-      },
-      timeoutMs: KNX_AI_LOCAL_LLM_TIMEOUT_MIN_MS
-    })
-    const appliedContextLength = Math.max(0, Number(loaded && loaded.load_config && loaded.load_config.context_length) || targetContextLength)
-    return {
-      model: descriptor.id,
-      displayName: descriptor.displayName,
-      instanceId: String(loaded && loaded.instance_id || descriptor.id),
-      contextLength: appliedContextLength,
-      maxContextLength: targetContextLength,
-      changed: true
-    }
-  } catch (error) {
-    const previousContextLength = descriptor.loadedInstances.reduce((max, instance) => Math.max(max, instance.contextLength), 0)
-    if (previousContextLength > 0) {
-      try {
-        await post({
-          url: loadUrl,
-          headers,
-          body: {
-            model: descriptor.id,
-            context_length: previousContextLength,
-            echo_load_config: true
-          },
-          timeoutMs: KNX_AI_LOCAL_LLM_TIMEOUT_MIN_MS
-        })
-      } catch (restoreError) { /* best-effort restoration of the previous instance */ }
-    }
-    const detail = String(error && error.message ? error.message : error)
-    const loadError = new Error(`Bionic LM Studio could not load "${descriptor.displayName}" with its maximum context (${targetContextLength} tokens). ${detail}`)
-    if (error && error.status !== undefined) loadError.status = error.status
-    throw loadError
+  // Do not load an inactive model through the management API. Bionic LM
+  // Studio's JIT loader must remain free to apply the user's saved per-model
+  // defaults (including context length) when the first chat request arrives.
+  // Until that happens, build a conservative prompt that fits within 16K.
+  return {
+    model: descriptor.id,
+    displayName: descriptor.displayName,
+    instanceId: '',
+    contextLength: Math.min(maxContextLength, KNX_AI_MINIMAL_CONTEXT_MAX_TOKENS),
+    maxContextLength,
+    active: false,
+    changed: false
   }
 }
 
@@ -4269,7 +4349,7 @@ const resolveOllamaModelMaxContext = async ({ baseUrl, model, post = postJson }
   return {
     model: selectedModel,
     maxContextLength,
-    contextLength: maxContextLength
+    contextLength: Math.min(maxContextLength, KNX_AI_OLLAMA_CONTEXT_MAX_TOKENS)
   }
 }
 
@@ -5773,7 +5853,7 @@ module.exports = function (RED) {
         if (!apiKey && deployedNode && deployedNode.credentials && deployedNode.credentials.llmApiKey) {
           apiKey = sanitizeApiKey(deployedNode.credentials.llmApiKey)
         }
-        const result = await ensureLmStudioModelMaxContext({
+        const result = await resolveLmStudioModelContext({
           baseUrl,
           apiKey,
           model: body.model
@@ -6148,6 +6228,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
@@ -7261,7 +7344,7 @@ module.exports = function (RED) {
       }, 90)
     }
 
-    const buildLLMPrompt = ({ question, summary, compact = false, languageHint = '' } = {}) => {
+    const buildLLMPrompt = ({ question, summary, compact = false, languageHint = '', includeDocs = true } = {}) => {
       const promptMode = compact === 'minimal' ? 'minimal' : compact === true || compact === 'compact' ? 'compact' : 'full'
       const compactMode = promptMode !== 'full'
       const minimalMode = promptMode === 'minimal'
@@ -7269,6 +7352,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 +7375,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
@@ -7327,7 +7423,7 @@ module.exports = function (RED) {
       }
 
       let docsContext = ''
-      if (node.llmIncludeDocsSnippets) {
+      if (includeDocs && node.llmIncludeDocsSnippets) {
         const docsMaxCharsConfigured = Math.max(500, Math.min(5000, Number(node.llmDocsMaxChars) || 500))
         const docsMaxChars = minimalMode
           ? Math.min(docsMaxCharsConfigured, 500)
@@ -7388,10 +7484,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 +7553,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 +7869,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 +7893,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 +7940,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 +8009,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
       }
     }
 
@@ -9636,14 +9875,19 @@ module.exports = function (RED) {
       if (node._lmStudioContextPromise && node._lmStudioContextPromise.key === key) {
         return node._lmStudioContextPromise.promise
       }
-      const promise = ensureLmStudioModelMaxContext({
+      const promise = resolveLmStudioModelContext({
         baseUrl: node.llmBaseUrl,
         apiKey: node.llmApiKey,
         model: node.llmModel
       }).then(result => {
         node.llmContextLength = Math.max(0, Number(result && result.contextLength) || node.llmContextLength)
-        node._lmStudioContextReadyKey = `${node.llmBaseUrl}\u0000${node.llmModel}\u0000${node.llmContextLength}`
-        node._lmStudioContextReadyResult = result
+        if (result && result.active === true) {
+          node._lmStudioContextReadyKey = `${node.llmBaseUrl}\u0000${node.llmModel}\u0000${node.llmContextLength}`
+          node._lmStudioContextReadyResult = result
+        } else {
+          node._lmStudioContextReadyKey = ''
+          node._lmStudioContextReadyResult = null
+        }
         return result
       }).finally(() => {
         if (node._lmStudioContextPromise && node._lmStudioContextPromise.key === key) {
@@ -9660,7 +9904,11 @@ module.exports = function (RED) {
       const model = node.llmModel || 'llama3.1'
       const key = `${url}\u0000${model}`
       if (!force && node._ollamaContextReadyKey === key && node.llmContextLength > 0) {
-        return { model, maxContextLength: node.llmContextLength, contextLength: node.llmContextLength }
+        return {
+          model,
+          maxContextLength: Math.max(node.llmContextLength, Number(node._ollamaModelMaxContextLength) || 0),
+          contextLength: node.llmContextLength
+        }
       }
       const resolveContext = () => resolveOllamaModelMaxContext({ baseUrl: url, model })
       let result
@@ -9671,7 +9919,8 @@ module.exports = function (RED) {
         await ensureOllamaServerRunning({ baseUrl: url, autoStart: true, timeoutMs: 22000 })
         result = await resolveContext()
       }
-      node.llmContextLength = Math.max(0, Number(result && result.maxContextLength) || 0)
+      node._ollamaModelMaxContextLength = Math.max(0, Number(result && result.maxContextLength) || 0)
+      node.llmContextLength = Math.max(0, Number(result && result.contextLength) || 0)
       node._ollamaContextReadyKey = key
       return result
     }
@@ -9682,7 +9931,24 @@ module.exports = function (RED) {
       return null
     }
 
-    const callLLMChat = async ({ systemPrompt, userContent, images = [], jsonSchema = null, maxTokensOverride = null }) => {
+    const recordChatPromptUsage = ({ body, provider, model } = {}) => {
+      const sequence = Math.max(0, Number(node._chatPromptUsageSequence) || 0) + 1
+      node._chatPromptUsageSequence = sequence
+      node._lastChatPromptUsageSequence = sequence
+      node._lastChatPromptUsage = Object.assign(
+        { at: new Date().toISOString(), exactInputTokens: 0 },
+        measureKnxAiPromptContext({ body, provider, model })
+      )
+      return sequence
+    }
+
+    const recordExactChatPromptTokens = ({ sequence, inputTokens } = {}) => {
+      const tokens = Math.max(0, Number(inputTokens) || 0)
+      if (!tokens || sequence !== node._lastChatPromptUsageSequence || !node._lastChatPromptUsage) return
+      node._lastChatPromptUsage = Object.assign({}, node._lastChatPromptUsage, { exactInputTokens: Math.round(tokens) })
+    }
+
+    const callLLMChat = async ({ systemPrompt, userContent, images = [], jsonSchema = null, maxTokensOverride = null, trackChatContextUsage = false }) => {
       if (!node.llmEnabled) throw new Error('LLM is disabled in node config')
       if (node.llmProvider === 'lmstudio' && !String(node.llmModel || '').trim()) {
         throw new Error('No Bionic LM Studio model selected. Start the LM Studio API server, refresh the model list and select a model.')
@@ -9728,10 +9994,16 @@ module.exports = function (RED) {
           )
         }
         let json
+        let promptUsageSequence = 0
         const requestOllamaChat = requestBody => postLocalLlmWithContextFallbacks({
           body: requestBody,
           enabled: true,
-          request: compactBody => postJson({ url, body: compactBody, timeoutMs: effectiveTimeoutMs })
+          request: compactBody => {
+            if (trackChatContextUsage) {
+              promptUsageSequence = recordChatPromptUsage({ body: compactBody, provider: 'ollama', model: compactBody.model })
+            }
+            return postJson({ url, body: compactBody, timeoutMs: effectiveTimeoutMs })
+          }
         })
         try {
           json = await requestOllamaChat(body)
@@ -9745,6 +10017,7 @@ module.exports = function (RED) {
             throw decorateOllamaConnectionError({ error, url, action: 'chat with the model' })
           }
         }
+        recordExactChatPromptTokens({ sequence: promptUsageSequence, inputTokens: json && json.prompt_eval_count })
         const content = json && json.message && typeof json.message.content === 'string' ? json.message.content : safeStringify(json)
         return { provider: 'ollama', model: body.model, content, finishReason: String(json && json.done_reason ? json.done_reason : '') }
       }
@@ -9775,7 +10048,11 @@ module.exports = function (RED) {
           }]
         }
         if (sys) body.system = sys
+        const promptUsageSequence = trackChatContextUsage
+          ? recordChatPromptUsage({ body, provider: 'anthropic', model: body.model })
+          : 0
         const json = await postJson({ url, headers, body, timeoutMs: effectiveTimeoutMs })
+        recordExactChatPromptTokens({ sequence: promptUsageSequence, inputTokens: json && json.usage && json.usage.input_tokens })
         const content = extractAnthropicText(json)
         const finishReason = String(json && json.stop_reason ? json.stop_reason : '')
         return { provider: 'anthropic', model: body.model, content, finishReason }
@@ -9829,17 +10106,27 @@ module.exports = function (RED) {
         ? (localOutputTokenLimit > 0 ? { max_tokens: Math.min(resolvedMaxTokens, localOutputTokenLimit) } : {})
         : { max_tokens: resolvedMaxTokens }
       let json
+      let promptUsageSequence = 0
       try {
         json = await postLocalLlmWithContextFallbacks({
           body: Object.assign(tokenLimitBody, schemaBody),
           enabled: node.llmProvider === 'lmstudio',
-          request: requestBody => postOpenAiCompatibleChatWithFallbacks({
-            url,
-            headers,
-            body: requestBody,
-            timeoutMs: effectiveTimeoutMs,
-            model: baseBody.model
-          })
+          request: requestBody => {
+            if (trackChatContextUsage) {
+              promptUsageSequence = recordChatPromptUsage({
+                body: requestBody,
+                provider: node.llmProvider === 'lmstudio' ? 'lmstudio' : 'openai_compat',
+                model: baseBody.model
+              })
+            }
+            return postOpenAiCompatibleChatWithFallbacks({
+              url,
+              headers,
+              body: requestBody,
+              timeoutMs: effectiveTimeoutMs,
+              model: baseBody.model
+            })
+          }
         })
       } catch (error) {
         if (node.llmProvider === 'lmstudio' && isLikelyConnectionFailure(error)) {
@@ -9849,6 +10136,7 @@ module.exports = function (RED) {
         }
         throw error
       }
+      recordExactChatPromptTokens({ sequence: promptUsageSequence, inputTokens: json && json.usage && json.usage.prompt_tokens })
       const content = extractOpenAICompatText(json) || buildOpenAICompatFallbackText(json)
       const finishReason = String(json && json.choices && json.choices[0] && json.choices[0].finish_reason ? json.choices[0].finish_reason : '')
       return { provider: node.llmProvider === 'lmstudio' ? 'lmstudio' : 'openai_compat', model: baseBody.model, content, finishReason }
@@ -10021,7 +10309,7 @@ module.exports = function (RED) {
       }
     }
 
-    const callLLM = async ({ question, sessionId = 'default', languageHint = '' }) => {
+    const callLLM = async ({ question, sessionId = 'default', languageHint = '', includeDocs = true }) => {
       await ensureSelectedLocalModelContext({ autoStartOllama: true })
       const contextMode = resolveKnxAiPromptContextMode({
         provider: node.llmProvider,
@@ -10038,14 +10326,16 @@ module.exports = function (RED) {
         question,
         summary,
         compact: contextMode === 'full' ? false : contextMode,
-        languageHint
+        languageHint,
+        includeDocs
       })
       const userContent = chatContext ? `${chatContext}\n\n${prompt}` : prompt
       const configuredMaxTokens = Math.max(10000, Number(node.llmMaxTokens) || 0)
       let ret = await callLLMChat({
         systemPrompt: node.llmSystemPrompt || '',
         userContent,
-        maxTokensOverride: configuredMaxTokens
+        maxTokensOverride: configuredMaxTokens,
+        trackChatContextUsage: includeDocs === false
       })
       const finishReason = String(ret && ret.finishReason ? ret.finishReason : '').trim().toLowerCase()
       const lengthLimited = finishReason === 'length' || isOpenAICompatLengthFallbackText(ret && ret.content)
@@ -10056,14 +10346,15 @@ module.exports = function (RED) {
           sessionId,
           maxChars: retryMode === 'minimal' ? 600 : 3000
         })
-        const compactBasePrompt = buildLLMPrompt({ question, summary, compact: retryMode, languageHint })
+        const compactBasePrompt = buildLLMPrompt({ question, summary, compact: retryMode, languageHint, includeDocs })
         const compactPrompt = compactChatContext ? `${compactChatContext}\n\n${compactBasePrompt}` : compactBasePrompt
         const retryMaxTokens = Math.min(16000, Math.max(10000, Math.round(configuredMaxTokens * 1.25)))
         try {
           ret = await callLLMChat({
             systemPrompt: node.llmSystemPrompt || '',
             userContent: compactPrompt,
-            maxTokensOverride: retryMaxTokens
+            maxTokensOverride: retryMaxTokens,
+            trackChatContextUsage: includeDocs === false
           })
         } catch (retryError) {
           // Keep the first provider answer if retry fails.
@@ -10135,14 +10426,14 @@ module.exports = function (RED) {
       if (contextMode !== 'full') {
         gaLines = takeFirstItemsByCharBudget(gaLines, contextMode === 'minimal' ? 5000 : 18000)
       }
-      // Keep conversational channels (Telegram, RedBot, custom adapters, etc.)
-      // aligned with the web Assistant: the chat adds its control/camera context
-      // below, but starts from the same complete KNX analysis prompt.
+      // Conversational channels keep the live KNX analysis context used by the web
+      // Assistant, but deliberately omit packaged help/README/wiki/example snippets.
       const analysisContext = buildLLMPrompt({
         question,
         summary,
         compact: contextMode === 'full' ? false : contextMode,
-        languageHint
+        languageHint,
+        includeDocs: false
       })
       const fullCameraCatalog = Array.from(node._cameraCatalog.values())
       const cameraSearch = normalizeSearchText(question)
@@ -10184,12 +10475,15 @@ module.exports = function (RED) {
         node.llmSystemPrompt || 'You are a KNX building automation assistant.',
         '',
         'KNX CHAT AND CONTROL CONTRACT:',
-        '- Return only one JSON object with exactly this shape: {"reply":"text for the user","language":"it","routine":{"active":false,"name":"","phase":"none|inspect|plan"},"commands":[{"event":"GroupValue_Read|GroupValue_Write","destination":"1/2/3","dpt":"1.001","payload":null,"reason":"short reason"}],"cameraActions":[{"type":"snapshot|analyze|watch|unwatch|list_watches","camera":"exact camera name or id","eventType":"smartDetect|smartDetectLine|smartDetectZone|smartDetectLoiterZone|motion|ring|smartAudioDetect","scopeName":"exact zone or line when supplied by the user","objectTypes":["person"],"cooldownSeconds":60,"sendSnapshot":true,"reason":"short reason"}],"speechActions":[{"type":"announce","text":"exact words to speak","reason":"short reason"}]}.',
+        '- Return only one JSON object with exactly this top-level shape: {"reply":"text for the user","language":"it","routine":{"active":false,"name":"","phase":"none"},"commands":[],"cameraActions":[],"speechActions":[]}.',
+        '- Begin with every action array empty. Add an item only when the current user request actually needs that action; never copy placeholder addresses, DPTs, cameras, events, or payloads from these instructions.',
         '- Use the same language as the user for reply and reason.',
         '- Set language to the ISO code matching the current user request: en, it, de, fr, es, or zh.',
         '- 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.',
@@ -10322,7 +10616,8 @@ module.exports = function (RED) {
             required: ['reply', 'language', 'routine', 'commands', 'cameraActions', 'speechActions']
           }
         },
-        maxTokensOverride: configuredMaxTokens
+        maxTokensOverride: configuredMaxTokens,
+        trackChatContextUsage: true
       })
 
       let envelope
@@ -10901,9 +11196,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 +11258,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 */ }
               }
             })
@@ -11799,7 +12099,7 @@ module.exports = function (RED) {
                   allowKnxCommands: node.llmAllowKnxCommands,
                   languageHint: requestLanguage
                 })
-                : await callLLM({ question, sessionId, languageHint: requestLanguage })
+                : await callLLM({ question, sessionId, languageHint: requestLanguage, includeDocs: false })
               const initialRoutine = normalizeKnxAiRoutineDescriptor(ret && ret.routine)
               const inspectionCommands = (Array.isArray(ret && ret.commands) ? ret.commands : [])
                 .filter(command => command && command.event === 'GroupValue_Read')
@@ -12312,6 +12612,7 @@ module.exports = function (RED) {
 
     try {
       pruneHistoryArchiveFiles({ force: true })
+      pruneAdapterHistoryArchiveFiles({ force: true })
       loadRecentHistoryFromDisk()
       loadHomeMemoryFromDisk()
       loadChatContextFromDisk()
@@ -12367,11 +12668,14 @@ 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,
   KNX_AI_LOCAL_LLM_TIMEOUT_MIN_MS,
+  KNX_AI_LMSTUDIO_PROMPT_CONTEXT_MAX_TOKENS,
   KNX_AI_MINIMAL_CONTEXT_MAX_TOKENS,
+  KNX_AI_OLLAMA_CONTEXT_MAX_TOKENS,
   KNX_AI_ROUTINE_FEEDBACK_TIMEOUT_MS,
   KNX_AI_THINKING_DELAY_MS,
   KNX_AI_TRAFFIC_DEFAULTS,
@@ -12390,7 +12694,7 @@ module.exports.__test = {
   detectKnxAiLanguageFromText,
   deriveLmStudioNativeApiUrl,
   dispatchKnxAiTtsUltimateAnnouncement,
-  ensureLmStudioModelMaxContext,
+  resolveLmStudioModelContext,
   executeKnxAiChatAdapter,
   extractLlmHttpErrorDetail,
   extractOllamaModelMaxContextLength,
@@ -12410,11 +12714,14 @@ module.exports.__test = {
   normalizeKnxAiCommandCandidates,
   normalizeKnxAiRoutineDescriptor,
   normalizeLmStudioModelCatalog,
+  measureKnxAiPromptContext,
+  parseQuestionTimeRange,
   parseKnxAiConversationResponse,
   postLocalLlmWithContextFallbacks,
   postOpenAiCompatibleChatWithFallbacks,
   resolveKnxAiLanguage,
   resolveKnxAiLlmTimeoutMs,
+  resolveKnxAiOperationalContextLimit,
   resolveKnxAiPromptContextMode,
   resolveKnxAiOperationEvent,
   resolveKnxAiSessionId,