node-red-contrib-knx-ultimate 6.3.13 → 6.3.15

package/nodes/locales/it/knxUltimateMatterBridge.html

@@ -27,7 +27,9 @@ Cambiare il tipo dispositivo dopo l'abbinamento del bridge modifica la struttura
 | Luce bianco dinamico | + GA comando/stato temperatura colore in Kelvin (DPT 7.600) |
 | Tapparella / Tenda | Su/Giù (DPT 1.008), Stop (DPT 1.017), posizione % comando/stato (DPT 5.001), inversione posizione opzionale |
 | Termostato (riscaldamento e/o raffrescamento) | GA temperatura attuale, GA comando/stato setpoint (DPT 9.001). Aggiungendo anche il GA comando/stato setpoint raffrescamento si espone anche la modalità Cool (doppio setpoint) |
+| Condizionatore ambiente | Un unico dispositivo Matter che combina GA comando/stato On/Off (DPT 1.001), temperatura attuale e setpoint caldo/freddo (DPT 9.001), e velocità ventola % (DPT 5.001) |
 | Ventola / VMC | GA comando/stato velocità % (DPT 5.001) |
+| Serratura porta | GA comando blocco/sblocco e GA stato bloccato/sbloccato (DPT 1.001; `true` = bloccata) |
 | Sensori (temperatura, umidità, luminosità, presenza, contatto) | Un GA di stato ciascuno |
 | Rilevatore fumo/CO | GA stato allarme fumo + GA stato allarme CO opzionale (DPT 1.005): notifiche critiche sul telefono |
 | Rilevatore allagamento | GA stato allagamento (DPT 1.005) |
@@ -45,7 +47,7 @@ Queste opzioni sono nascoste finché non servono al tipo selezionato. I disposit
 
 Il selettore dei PIN si trova fuori dalle TAB dell'editor. Abilitandolo compare subito sotto una sezione contestuale **Input/output del flow**, con esempi copiabili filtrati per il tipo di dispositivo selezionato:
 
-- **Input**: aggiorna lo stato Matter dal flow, senza passare dal bus KNX: `msg.payload = { function: "onoff", value: true }` (`function` è una tra `onoff`, `level`, `rgb`, `colortemp`, `position`, `temperature`, `humidity`, `illuminance`, `occupancy`, `contact`, `currenttemp`, `setpoint`, `fanspeed`, `smoke`, `co`, `leak`, `co2`, `rvcstate`, `rvcmode`). Utile per esporre ad Alexa & Co. valori calcolati nel flow (es. un sensore virtuale).
+- **Input**: aggiorna lo stato Matter dal flow, senza passare dal bus KNX: `msg.payload = { function: "onoff", value: true }` (`function` è una tra `onoff`, `level`, `rgb`, `colortemp`, `position`, `temperature`, `humidity`, `illuminance`, `occupancy`, `contact`, `currenttemp`, `setpoint`, `coolingsetpoint`, `fanspeed`, `lock`, `smoke`, `co`, `leak`, `co2`, `rvcstate`, `rvcmode`). Utile per esporre ad Alexa & Co. valori calcolati nel flow (es. un sensore virtuale).
 - **Output**: ogni comando ricevuto da un controller Matter viene inoltrato al flow: `msg.topic` = nome del dispositivo, `msg.payload` = valore, `msg.matter` = il comando grezzo. Un dispositivo senza GA di comando diventa un **dispositivo solo-flow**.
 
 ## Note

package/nodes/locales/it/knxUltimateMatterBridge.json

@@ -74,7 +74,9 @@
       "fn_leak_ga": "GA stato allagamento",
       "fn_co2_ga": "GA stato CO2 (ppm, DPT 9.008)",
       "fn_fanspeed_cmd": "GA comando velocità ventola %",
-      "fn_fanspeed_status": "GA stato velocità ventola %"
+      "fn_fanspeed_status": "GA stato velocità ventola %",
+      "fn_lock_cmd": "GA comando blocco/sblocco",
+      "fn_lock_status": "GA stato bloccato/sbloccato"
     },
     "types": {
       "onofflight": "Luce On/Off",
@@ -89,7 +91,9 @@
       "contactsensor": "Sensore contatto",
       "windowcovering": "Tapparella / Tenda",
       "thermostat": "Termostato (riscaldamento)",
+      "roomairconditioner": "Condizionatore ambiente",
       "fan": "Ventola / VMC",
+      "doorlock": "Serratura porta",
       "smokecoalarm": "Rilevatore fumo/CO",
       "waterleakdetector": "Rilevatore allagamento",
       "airqualitysensor": "Sensore qualità aria (CO2)",

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

@@ -14,14 +14,14 @@
 ## 命令（输入）
 发送 `msg.topic`：
 - `summary`（或空）：立即输出摘要
-- `reset`：清空内部历史、计数器和已学习的家庭记忆；AI 教育保持不变
+- `reset`：清空内部历史、计数器、已学习的家庭记忆和所有持久聊天上下文；AI 教育保持不变
 - `ask`：向已配置的 LLM 提问
 - `confirm` / `cancel`：无需再次调用 LLM，即可确认或取消待处理的 KNX 命令
-- `clear_chat`：清除当前会话的对话记忆
+- `clear_chat`：清除当前会话的最近对话、持久指令和待处理命令
 
 `ask` 的问题建议放在 `msg.prompt`，也可放在 `msg.payload`（字符串）或常见 Telegram 字段 `msg.payload.content` / `msg.payload.text`。
 
-启用 KNX 控制后，最近的对话会按 `msg.knxAi.sessionId`、`msg.sessionId` 或检测到的 Telegram 聊天 ID 保存在 RAM 中。将输出 3 连接到聊天发送节点，将输出 4 连接到配置为**通用模式**的 KNX Ultimate 节点。启用确认后，第一条回复会显示 GA、DPT 和 payload，但不会发送写入；同一会话必须在 5 分钟内回复“确认”或“取消”。新请求会替换旧的待处理计划。每条已确认命令都包含 `msg.destination`、`msg.dpt`、`msg.payload` 和 `msg.event = "GroupValue_Write"`。
+每个 Ask/聊天会话都会保留最近 8 轮对话和最多 20 条明确的长期指令，并按 `msg.knxAi.sessionId`、`msg.sessionId` 或检测到的 Telegram 聊天 ID 隔离。像“请记住不要在回答中使用 unknown 这个词”这样的请求会成为持久指令。使用相同存储的所有 KNX AI 节点实时共享此上下文，并在 Node-RED 重启后从 `knxultimatestorage/knxai/memory/knxai-chat-context.md` 重新加载。该文件采用原子写入，最多保存 50 个会话且不超过 512 KB。启用 KNX 控制后，将输出 3 连接到聊天发送节点，将输出 4 连接到配置为**通用模式**的 KNX Ultimate 节点。启用确认后，第一条回复会显示 GA、DPT 和 payload，但不会发送写入；同一会话必须在 5 分钟内回复“确认”或“取消”。新请求会替换旧的待处理计划。每条已确认命令都包含 `msg.destination`、`msg.dpt`、`msg.payload` 和 `msg.event = "GroupValue_Write"`。
 对于 DPT 1.xxx 写入，AI 生成的安全等价值 `true`/`false`、`1`/`0` 和 `on`/`off` 会在本地校验和输出前统一转换为真正的布尔值。
 
 ### 最新 KNX 读取
@@ -35,12 +35,14 @@
 
 随附的 **windkh/node-red-contrib-telegrambot** 预设遵循该包的 receiver/sender 消息约定。把 `telegram receiver` 直接连接到 KNX AI，并把输出 3 直接连接到 `telegram sender`。如需内联确认按钮，还要把配置为 `callback_query` 的 `telegram event` 连接到同一个 KNX AI 输入。输入映射会提取 `msg.payload.content`、`msg.payload.chatId` 和 Telegram 语言；输出映射会创建所需的 `msg.payload.chatId`、`type` 和 `content`，并在写入等待确认时从 `msg.knxAi.confirmationRequest` 添加 `options.reply_markup`。Telegram 包仍是独立的可选依赖项。
 
+随附的 **RedBot / node-red-contrib-chatbot (Telegram)** 预设遵循 RedBot 的通用消息格式。将 `chatbot-telegram-receive` 直接连接到 KNX AI，并将输出 3 直接连接到 `chatbot-telegram-send`；无需单独的 callback 节点，因为 RedBot 会把内联按钮的 postback 转换成普通入站消息。输入映射读取 `transport`、`chatId`、`type`、`content` 和 Telegram 语言。输出映射保留 RedBot 的 `originalMessage`、`chat`、`api` 和 `client` 跟踪数据，然后发送 `message` payload，或发送带有确认 `postback` 操作的 `inline-buttons` payload。RedBot 仍是独立的可选依赖项。
+
 ## 主动家庭智能与有限记忆
 **对话与家庭**中的**主动家庭与记忆**子部分以可选方式启用主动通知。节点会根据 ETS 层级、名称、角色和 DPT，使用意大利语、英语、德语、法语、西班牙语和中文术语，为卷帘、窗户、门、照明、温度、气候、占用和报警建立确定性的语义模型。首个主动检测器只监视可靠识别且非命令的卷帘/窗户/门状态。超过配置的打开时间且当前不在静默时段时，输出 3 会发送本地化消息，并设置 `msg.knxAi.type = "proactive_notification"`。节点绝不会主动使用输出 4，也不会自行修改 KNX；用户之后提出的任何操作仍须经过正常的校验与确认。
 
 最近一次聊天会话会被记为主人，也可以通过**主要接收者 / 聊天 ID**明确指定。合成的 `msg.inputMessage` 会保留接收者，使 Telegram 适配器能够发送主动通知。冷却时间和每小时最多三条主动通知可防止消息泛滥。
 
-学习到的参考文件会在启动时从 `<userDir>/knxai/memory/knxai-home-memory-<node-id>.md` 加载，每 15 分钟以原子方式重写，并严格限制在可配置的 64–1,024 KB（默认 256 KB）。最多保留 120 条重要观察、80 条聚合习惯、80 条通知和 300 个 ETS 语义对象，绝不会保存无限的原始报文流。较旧且优先级较低的项目会先被删除。**AI 教育**最多 16,000 个字符，并且始终来自节点配置：AI 可以将其作为权威指导读取，但不能修改或覆盖。如果已填写 AI 教育但 LLM 无法进行评估，候选通知会被抑制，以免违反用户指导。
+共享的学习参考文件会在启动时从 `<userDir>/knxai/memory/knxai-home-memory.md` 加载，每 15 分钟以原子方式重写，并始终严格限制为 5 MB。最多保留 120 条重要观察、80 条聚合习惯、80 条通知和 300 个 ETS 语义对象，绝不会保存无限的原始报文流。较旧且优先级较低的项目会先被删除。**AI 教育**最多 16,000 个字符，并且始终来自节点配置：AI 可以将其作为权威指导读取，但不能修改或覆盖。如果已填写 AI 教育但 LLM 无法进行评估，候选通知会被抑制，以免违反用户指导。
 
 ## 实用配置示例
 此示例创建一个简洁的助手：它会报告重要的长时间开启状态，但允许书房卷帘保持开启。
@@ -52,7 +54,6 @@
 | **开启多久后通知** (`proactiveOpenMinutes`) | `120` | 开启两小时后评估是否需要通知。 |
 | **静默时间开始 / 结束** | `23:00` / `07:00` | 夜间不会发送主动消息。 |
 | **重复冷却时间** (`proactiveCooldownMinutes`) | `360` | 同一对象六小时内不会再次通知。 |
-| **家庭记忆文件上限** (`homeMemoryMaxKb`) | `256` | 此节点的 Markdown 参考文件始终小于 256 KB。 |
 
 **AI 教育** (`aiEducation`) 示例：
 
@@ -116,7 +117,6 @@ KNX AI 会自动监听 `GroupValue_Write`、`GroupValue_Response` 和 `GroupValu
 - **静默时间开始 / 结束**：每天禁止主动消息的时间段。
 - **AI 教育**：仅由用户管理的权威指导，AI 可以读取但永远不能修改。
 - **重复冷却时间（分钟）**：同一对象再次通知前的最短间隔；默认 360 分钟。
-- **家庭记忆文件上限（KB）**：64 到 1,024 KB 的硬限制；默认 256 KB。
 - 如果启用了磁盘归档，**Ask** 默认会查询该归档：若问题里写了明确日期/时间范围就按其查询，否则默认查询最近 24 小时并补上当前 RAM 事件。
 - **包含 Node-RED 项目清单**：在提示词中加入整个 Node-RED 项目的节点清单，不仅包含 KNX 节点，也包含 function/change/inject/template 等在内且带有 KNX 逻辑或组地址的有用节点。
 - 相关的帮助、README 和示例片段始终会自动包含。

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

@@ -57,7 +57,6 @@
       "proactiveCooldownMinutes": "重复通知冷却时间（分钟）",
       "proactiveQuietStart": "静默时段开始",
       "proactiveQuietEnd": "静默时段结束",
-      "homeMemoryMaxKb": "家庭记忆文件最大值（KB）",
       "aiEducation": "AI 教育（由用户管理）",
       "llmIncludeDocsSnippets": "Include documentation snippets (help/README/examples)",
       "llmDocsLanguage": "Docs language"
@@ -89,8 +88,7 @@
       "chatAdapterIntro": "选择预设即可插入输入和输出映射代码。列表从随包提供的聊天适配器文件加载；生成的代码仍可编辑。",
       "chatAdapterCodeHelp": "映射同步运行。返回 msg 以继续，或不返回值以丢弃消息。错误会被捕获并报告，不会停止 Node-RED。",
       "homeIntelligenceIntro": "节点会创建多语言 ETS 语义模型，并在可靠识别的卷帘、窗户或门长时间保持打开时主动通知聊天。它绝不会自行发送 KNX 命令。",
-      "aiEducationHelp": "只有用户可以编辑此部分。AI 会把它作为权威指导读取，但学习到的记忆绝不能覆盖它。最多 16,000 个字符。",
-      "homeMemoryLimitHelp": "Markdown 记忆每 15 分钟以原子方式重写，并始终限制在 64 到 1,024 KB。达到限制时会先删除较旧的观察，再删除习惯和语义对象。"
+      "aiEducationHelp": "只有用户可以编辑此部分。AI 会把它作为权威指导读取，但学习到的记忆绝不能覆盖它。最多 16,000 个字符。"
     },
     "placeholder": {
       "llmBaseUrl": "https://api.openai.com/v1/chat/completions (or your compatible endpoint)",

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

@@ -27,7 +27,9 @@
 | 色温灯 | + 色温命令/状态 GA，开尔文 (DPT 7.600) |
 | 窗帘/卷帘 | 上/下 (DPT 1.008)、停止 (DPT 1.017)、位置 % 命令/状态 (DPT 5.001)、可选位置反转 |
 | 温控器（采暖和/或制冷） | 当前温度 GA、设定点命令/状态 GA (DPT 9.001)。如再配置制冷设定点命令/状态 GA，则同时提供 Cool 模式（双设定点） |
+| 房间空调 | 一个 Matter 设备组合开/关命令/状态 GA (DPT 1.001)、当前温度与采暖/制冷设定点 (DPT 9.001)，以及风扇速度 % 命令/状态 GA (DPT 5.001) |
 | 风扇/新风 | 速度 % 命令/状态 GA (DPT 5.001) |
+| 门锁 | 锁定/解锁命令 GA 和锁定/解锁状态 GA (DPT 1.001；`true` = 已锁定) |
 | 传感器（温度、湿度、光照、人体、门磁） | 各一个状态 GA |
 | 烟雾/CO 报警器 | 烟雾报警状态 GA + 可选 CO 报警状态 GA (DPT 1.005)：手机上的紧急通知 |
 | 漏水探测器 | 漏水状态 GA (DPT 1.005) |
@@ -45,7 +47,7 @@
 
 引脚选择器位于编辑器选项卡之外。启用后，其下方会显示与所选设备类型匹配的 **Flow 输入/输出** 区域，并提供可复制示例：
 
-- **输入**：从 Flow 更新 Matter 状态，无需经过 KNX 总线：`msg.payload = { function: "onoff", value: true }`（`function` 为 `onoff`、`level`、`rgb`、`colortemp`、`position`、`temperature`、`humidity`、`illuminance`、`occupancy`、`contact`、`currenttemp`、`setpoint`、`fanspeed`、`smoke`、`co`、`leak`、`co2`、`rvcstate`、`rvcmode` 之一）。适合把 Flow 中计算的值（如虚拟传感器）公开给 Alexa 等。
+- **输入**：从 Flow 更新 Matter 状态，无需经过 KNX 总线：`msg.payload = { function: "onoff", value: true }`（`function` 为 `onoff`、`level`、`rgb`、`colortemp`、`position`、`temperature`、`humidity`、`illuminance`、`occupancy`、`contact`、`currenttemp`、`setpoint`、`coolingsetpoint`、`fanspeed`、`lock`、`smoke`、`co`、`leak`、`co2`、`rvcstate`、`rvcmode` 之一）。适合把 Flow 中计算的值（如虚拟传感器）公开给 Alexa 等。
 - **输出**：从 Matter 控制器收到的每个命令都转发到 Flow：`msg.topic` = 设备名称，`msg.payload` = 值，`msg.matter` = 原始命令。没有命令 GA 的设备成为**纯 Flow 设备**。
 
 ## 说明

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

@@ -74,7 +74,9 @@
       "fn_leak_ga": "漏水状态 GA",
       "fn_co2_ga": "CO2 状态 GA（ppm，DPT 9.008）",
       "fn_fanspeed_cmd": "风扇速度 % 命令 GA",
-      "fn_fanspeed_status": "风扇速度 % 状态 GA"
+      "fn_fanspeed_status": "风扇速度 % 状态 GA",
+      "fn_lock_cmd": "锁定/解锁 命令 GA",
+      "fn_lock_status": "锁定/解锁 状态 GA"
     },
     "types": {
       "onofflight": "开关灯",
@@ -89,7 +91,9 @@
       "contactsensor": "门磁传感器",
       "windowcovering": "窗帘 / 卷帘",
       "thermostat": "温控器（采暖）",
+      "roomairconditioner": "房间空调",
       "fan": "风扇 / 新风",
+      "doorlock": "门锁",
       "smokecoalarm": "烟雾/CO 报警器",
       "waterleakdetector": "漏水探测器",
       "airqualitysensor": "空气质量传感器 (CO2)",

package/nodes/utils/knxAiChatContext.js

@@ -0,0 +1,277 @@
+const CHAT_CONTEXT_VERSION = 1
+const CHAT_CONTEXT_MAX_BYTES = 512 * 1024
+const CHAT_CONTEXT_MAX_SESSIONS = 50
+const CHAT_CONTEXT_MAX_TURNS_PER_SESSION = 8
+const CHAT_CONTEXT_MAX_INSTRUCTIONS_PER_SESSION = 20
+const CHAT_CONTEXT_MAX_QUESTION_CHARS = 4000
+const CHAT_CONTEXT_MAX_REPLY_CHARS = 8000
+const CHAT_CONTEXT_MAX_INSTRUCTION_CHARS = 2000
+
+const clampText = (value, maxChars) => String(value === undefined || value === null ? '' : value)
+  .trim()
+  .slice(0, Math.max(0, Number(maxChars) || 0))
+
+const normalizeSessionId = value => clampText(value || 'default', 160) || 'default'
+
+const createEmptyKnxAiChatContext = () => ({
+  version: CHAT_CONTEXT_VERSION,
+  createdAt: new Date().toISOString(),
+  updatedAt: new Date().toISOString(),
+  sessions: []
+})
+
+const normalizeTurn = (turn) => {
+  if (!turn || typeof turn !== 'object' || Array.isArray(turn)) return null
+  const question = clampText(turn.question, CHAT_CONTEXT_MAX_QUESTION_CHARS)
+  const reply = clampText(turn.reply, CHAT_CONTEXT_MAX_REPLY_CHARS)
+  if (!question && !reply) return null
+  return {
+    at: clampText(turn.at || new Date().toISOString(), 64),
+    question,
+    reply
+  }
+}
+
+const normalizeInstruction = (instruction) => {
+  if (!instruction || typeof instruction !== 'object' || Array.isArray(instruction)) return null
+  const text = clampText(instruction.text, CHAT_CONTEXT_MAX_INSTRUCTION_CHARS)
+  if (!text) return null
+  return {
+    at: clampText(instruction.at || new Date().toISOString(), 64),
+    text
+  }
+}
+
+const normalizeSession = (session) => {
+  if (!session || typeof session !== 'object' || Array.isArray(session)) return null
+  const id = normalizeSessionId(session.id)
+  const turns = (Array.isArray(session.turns) ? session.turns : [])
+    .map(normalizeTurn)
+    .filter(Boolean)
+    .slice(-CHAT_CONTEXT_MAX_TURNS_PER_SESSION)
+  const instructions = (Array.isArray(session.instructions) ? session.instructions : [])
+    .map(normalizeInstruction)
+    .filter(Boolean)
+    .slice(-CHAT_CONTEXT_MAX_INSTRUCTIONS_PER_SESSION)
+  return {
+    id,
+    updatedAt: clampText(session.updatedAt || new Date().toISOString(), 64),
+    turns,
+    instructions
+  }
+}
+
+const normalizeKnxAiChatContext = (value = {}) => {
+  const source = value && typeof value === 'object' && !Array.isArray(value) ? value : {}
+  const byId = new Map()
+  ;(Array.isArray(source.sessions) ? source.sessions : []).forEach((item) => {
+    const session = normalizeSession(item)
+    if (!session) return
+    byId.delete(session.id)
+    byId.set(session.id, session)
+  })
+  return {
+    version: CHAT_CONTEXT_VERSION,
+    createdAt: clampText(source.createdAt || new Date().toISOString(), 64),
+    updatedAt: clampText(source.updatedAt || new Date().toISOString(), 64),
+    sessions: Array.from(byId.values()).slice(-CHAT_CONTEXT_MAX_SESSIONS)
+  }
+}
+
+const findSession = (context, sessionId) => {
+  const id = normalizeSessionId(sessionId)
+  return normalizeKnxAiChatContext(context).sessions.find(session => session.id === id) || null
+}
+
+const touchSession = (context, sessionId) => {
+  const target = normalizeKnxAiChatContext(context)
+  const id = normalizeSessionId(sessionId)
+  const existing = target.sessions.find(session => session.id === id)
+  const session = existing || { id, updatedAt: new Date().toISOString(), turns: [], instructions: [] }
+  target.sessions = target.sessions.filter(item => item.id !== id)
+  target.sessions.push(session)
+  target.sessions = target.sessions.slice(-CHAT_CONTEXT_MAX_SESSIONS)
+  target.updatedAt = new Date().toISOString()
+  session.updatedAt = target.updatedAt
+  return { target, session }
+}
+
+const explicitInstructionPatterns = [
+  /^\s*(?:please[\s,]+)?remember\b/i,
+  /^\s*from now on\b/i,
+  /^\s*(?:please[\s,]+)?(?:always|never)\b/i,
+  /^\s*(?:per favore[\s,]+)?(?:ricordati|ricorda|ricordarsi|memorizza)\b/i,
+  /^\s*(?:d['’]ora in poi|da ora in poi)\b/i,
+  /^\s*(?:usa sempre|non usare mai|evita sempre)\b/i,
+  /^\s*(?:bitte[\s,]+)?(?:merk dir|erinnere dich)\b/i,
+  /^\s*(?:ab jetzt|von jetzt an)\b/i,
+  /^\s*(?:s['’]il te pla[iî]t[\s,]+)?(?:souviens-toi|rappelle-toi|m[eé]morise)\b/i,
+  /^\s*(?:dor[eé]navant|[àa] partir de maintenant)\b/i,
+  /^\s*(?:por favor[\s,]+)?(?:recuerda|memoriza)\b/i,
+  /^\s*(?:a partir de ahora|de ahora en adelante)\b/i,
+  /^\s*(?:请)?记住/,
+  /^\s*从现在开始/
+]
+
+const extractExplicitKnxAiChatInstruction = (question) => {
+  const text = clampText(question, CHAT_CONTEXT_MAX_INSTRUCTION_CHARS)
+  if (!text) return ''
+  return explicitInstructionPatterns.some(pattern => pattern.test(text)) ? text : ''
+}
+
+const addKnxAiChatTurn = (context, { sessionId, question, reply, at } = {}) => {
+  const { target, session } = touchSession(context, sessionId)
+  const turn = normalizeTurn({ at, question, reply })
+  if (turn) session.turns.push(turn)
+  session.turns = session.turns.slice(-CHAT_CONTEXT_MAX_TURNS_PER_SESSION)
+
+  const explicitInstruction = extractExplicitKnxAiChatInstruction(question)
+  if (explicitInstruction) {
+    const normalized = explicitInstruction.toLocaleLowerCase()
+    session.instructions = session.instructions.filter(item => item.text.toLocaleLowerCase() !== normalized)
+    session.instructions.push({
+      at: clampText(at || new Date().toISOString(), 64),
+      text: explicitInstruction
+    })
+    session.instructions = session.instructions.slice(-CHAT_CONTEXT_MAX_INSTRUCTIONS_PER_SESSION)
+  }
+  return target
+}
+
+const clearKnxAiChatSession = (context, sessionId) => {
+  const target = normalizeKnxAiChatContext(context)
+  const id = normalizeSessionId(sessionId)
+  target.sessions = target.sessions.filter(session => session.id !== id)
+  target.updatedAt = new Date().toISOString()
+  return target
+}
+
+const getKnxAiChatSession = (context, sessionId) => {
+  const session = findSession(context, sessionId)
+  return session || {
+    id: normalizeSessionId(sessionId),
+    updatedAt: '',
+    turns: [],
+    instructions: []
+  }
+}
+
+const buildKnxAiChatPromptContext = ({ context, sessionId, maxChars = 16000 } = {}) => {
+  const session = getKnxAiChatSession(context, sessionId)
+  if (!session.instructions.length && !session.turns.length) return ''
+  const lines = []
+  if (session.instructions.length) {
+    lines.push('PERSISTENT CHAT INSTRUCTIONS AND PREFERENCES (explicitly supplied by this user; follow them unless they conflict with safety or the KNX contract; newer entries override older conflicting entries):')
+    session.instructions.forEach(item => lines.push(`- ${item.text.replace(/\r?\n/g, ' ')}`))
+  }
+  if (session.turns.length) {
+    if (lines.length) lines.push('')
+    lines.push('RECENT CONVERSATION:')
+    session.turns.forEach((turn) => {
+      lines.push(`User: ${turn.question}`)
+      lines.push(`Assistant: ${turn.reply}`)
+    })
+  }
+  return lines.join('\n').slice(0, Math.max(1000, Number(maxChars) || 16000))
+}
+
+const escapeMarkdownText = value => clampText(value, CHAT_CONTEXT_MAX_REPLY_CHARS)
+  .replace(/\r?\n/g, ' ')
+  .replace(/</g, '&lt;')
+  .replace(/>/g, '&gt;')
+
+const renderKnxAiChatContext = (context) => {
+  const target = normalizeKnxAiChatContext(context)
+  target.updatedAt = new Date().toISOString()
+  const metadata = Buffer.from(JSON.stringify(target), 'utf8').toString('base64')
+  const lines = [
+    '<!-- KNX_AI_CHAT_CONTEXT_V1_BASE64',
+    metadata,
+    'KNX_AI_CHAT_CONTEXT_END -->',
+    '',
+    '# KNX AI Chat Context',
+    '',
+    `Updated: ${target.updatedAt}`,
+    '',
+    'This bounded file stores recent chat turns and explicit long-term instructions separately for each chat session.',
+    ''
+  ]
+  target.sessions.forEach((session) => {
+    lines.push(`## Session ${escapeMarkdownText(session.id)}`, '')
+    lines.push('### Persistent instructions', '')
+    if (!session.instructions.length) lines.push('_None._')
+    session.instructions.forEach(item => lines.push(`- ${escapeMarkdownText(item.at)} — ${escapeMarkdownText(item.text)}`))
+    lines.push('', '### Recent turns', '')
+    if (!session.turns.length) lines.push('_None._')
+    session.turns.forEach((turn) => {
+      lines.push(`- ${escapeMarkdownText(turn.at)} — **User:** ${escapeMarkdownText(turn.question)}`)
+      lines.push(`  **Assistant:** ${escapeMarkdownText(turn.reply)}`)
+    })
+    lines.push('')
+  })
+  return { markdown: lines.join('\n'), context: target }
+}
+
+const buildKnxAiChatContextMarkdown = ({ context, maxBytes = CHAT_CONTEXT_MAX_BYTES } = {}) => {
+  const targetBytes = Math.max(64 * 1024, Math.min(CHAT_CONTEXT_MAX_BYTES, Number(maxBytes) || CHAT_CONTEXT_MAX_BYTES))
+  let bounded = normalizeKnxAiChatContext(context)
+  let rendered = renderKnxAiChatContext(bounded)
+  while (Buffer.byteLength(rendered.markdown, 'utf8') > targetBytes) {
+    const sessionWithTurns = bounded.sessions.find(session => session.turns.length > 0)
+    if (sessionWithTurns) sessionWithTurns.turns.shift()
+    else if (bounded.sessions.length > 1) bounded.sessions.shift()
+    else {
+      const sessionWithInstructions = bounded.sessions.find(session => session.instructions.length > 0)
+      if (!sessionWithInstructions) break
+      sessionWithInstructions.instructions.shift()
+    }
+    rendered = renderKnxAiChatContext(bounded)
+    bounded = rendered.context
+  }
+  return {
+    markdown: rendered.markdown,
+    context: rendered.context,
+    bytes: Buffer.byteLength(rendered.markdown, 'utf8'),
+    maxBytes: targetBytes
+  }
+}
+
+const parseKnxAiChatContextMarkdown = (markdown) => {
+  const text = String(markdown || '')
+  const match = text.match(/<!-- KNX_AI_CHAT_CONTEXT_V1_BASE64\s*\n([A-Za-z0-9+/=\r\n]+?)\nKNX_AI_CHAT_CONTEXT_END -->/)
+  if (!match) return createEmptyKnxAiChatContext()
+  try {
+    const metadata = Buffer.from(match[1].replace(/\s+/g, ''), 'base64').toString('utf8')
+    return normalizeKnxAiChatContext(JSON.parse(metadata))
+  } catch (error) {
+    return createEmptyKnxAiChatContext()
+  }
+}
+
+const conversationMapFromKnxAiChatContext = (context) => {
+  const result = new Map()
+  normalizeKnxAiChatContext(context).sessions.forEach((session) => {
+    result.set(session.id, session.turns.map(turn => ({
+      question: turn.question,
+      reply: turn.reply
+    })))
+  })
+  return result
+}
+
+module.exports = {
+  CHAT_CONTEXT_MAX_BYTES,
+  CHAT_CONTEXT_MAX_INSTRUCTIONS_PER_SESSION,
+  CHAT_CONTEXT_MAX_SESSIONS,
+  CHAT_CONTEXT_MAX_TURNS_PER_SESSION,
+  addKnxAiChatTurn,
+  buildKnxAiChatContextMarkdown,
+  buildKnxAiChatPromptContext,
+  clearKnxAiChatSession,
+  conversationMapFromKnxAiChatContext,
+  createEmptyKnxAiChatContext,
+  extractExplicitKnxAiChatInstruction,
+  getKnxAiChatSession,
+  normalizeKnxAiChatContext,
+  parseKnxAiChatContextMarkdown
+}

package/nodes/utils/knxAiHomeMemory.js

@@ -1,7 +1,7 @@
 const HOME_MEMORY_VERSION = 1
 const HOME_MEMORY_MIN_KB = 64
-const HOME_MEMORY_MAX_KB = 1024
-const HOME_MEMORY_DEFAULT_KB = 256
+const HOME_MEMORY_MAX_KB = 5120
+const HOME_MEMORY_DEFAULT_KB = 5120
 const HOME_MEMORY_MAX_EDUCATION_CHARS = 16000
 const HOME_MEMORY_MAX_OBSERVATIONS = 120
 const HOME_MEMORY_MAX_HABITS = 80