memovai · IRONICBo · Feb 18, 2026 · Feb 24, 2026 · Feb 24, 2026 · Mar 1, 2026
diff --git a/main/CMakeLists.txt b/main/CMakeLists.txt
@@ -6,6 +6,8 @@ idf_component_register(
         "imu/I2C_Driver.c"
         "imu/QMI8658.c"
         "imu/imu_manager.c"
+        "sensors/env_sensor.c"
+        "trigger/lick_trigger.c"
         "bus/message_bus.c"
         "wifi/wifi_manager.c"
         "telegram/telegram_bot.c"
@@ -24,6 +26,7 @@ idf_component_register(
         "tools/tool_web_search.c"
         "tools/tool_get_time.c"
         "tools/tool_files.c"
+        "tools/tool_pixiviz.c"
         "skills/skill_loader.c"
     INCLUDE_DIRS
         "."

diff --git a/main/agent/context_builder.c b/main/agent/context_builder.c
@@ -48,6 +48,10 @@ esp_err_t context_build_system_prompt(char *buf, size_t size)
         "- cron_list: List all scheduled cron jobs.\n"
         "- cron_remove: Remove a scheduled cron job by ID.\n\n"
         "When using cron_add for Telegram delivery, always set channel='telegram' and a valid numeric chat_id.\n\n"
+        "Telegram rich output rule:\n"
+        "- To send an image, put a separate markdown image line in your final output: ![caption](https://...)\n"
+        "- You can include multiple image lines; each will be sent as a Telegram photo.\n"
+        "- Keep image URLs public HTTPS direct links.\n\n"
         "Use tools when needed. Provide your final answer as text after using tools.\n\n"
         "## Memory\n"
         "You have persistent memory stored on local flash:\n"

diff --git a/main/bus/message_bus.c b/main/bus/message_bus.c
@@ -2,11 +2,16 @@
 #include "mimi_config.h"
 #include "esp_log.h"
 #include <string.h>
+#include <stdbool.h>
 
 static const char *TAG = "bus";
 
 static QueueHandle_t s_inbound_queue;
 static QueueHandle_t s_outbound_queue;
+static char s_latest_channel[16];
+static char s_latest_chat_id[32];
+static bool s_has_latest_context = false;
+static portMUX_TYPE s_ctx_lock = portMUX_INITIALIZER_UNLOCKED;
 
 esp_err_t message_bus_init(void)
 {
@@ -18,6 +23,10 @@ esp_err_t message_bus_init(void)
         return ESP_ERR_NO_MEM;
     }
 
+    memset(s_latest_channel, 0, sizeof(s_latest_channel));
+    memset(s_latest_chat_id, 0, sizeof(s_latest_chat_id));
+    s_has_latest_context = false;
+
     ESP_LOGI(TAG, "Message bus initialized (queue depth %d)", MIMI_BUS_QUEUE_LEN);
     return ESP_OK;
 }
@@ -28,6 +37,17 @@ esp_err_t message_bus_push_inbound(const mimi_msg_t *msg)
         ESP_LOGW(TAG, "Inbound queue full, dropping message");
         return ESP_ERR_NO_MEM;
     }
+
+    if (strcmp(msg->channel, MIMI_CHAN_SYSTEM) != 0 && msg->chat_id[0] != '\0') {
+        portENTER_CRITICAL(&s_ctx_lock);
+        strncpy(s_latest_channel, msg->channel, sizeof(s_latest_channel) - 1);
+        s_latest_channel[sizeof(s_latest_channel) - 1] = '\0';
+        strncpy(s_latest_chat_id, msg->chat_id, sizeof(s_latest_chat_id) - 1);
+        s_latest_chat_id[sizeof(s_latest_chat_id) - 1] = '\0';
+        s_has_latest_context = true;
+        portEXIT_CRITICAL(&s_ctx_lock);
+    }
+
     return ESP_OK;
 }
 
@@ -57,3 +77,25 @@ esp_err_t message_bus_pop_outbound(mimi_msg_t *msg, uint32_t timeout_ms)
     }
     return ESP_OK;
 }
+
+esp_err_t message_bus_get_latest_client_context(char *channel, size_t channel_size,
+                                                char *chat_id, size_t chat_id_size)
+{
+    if (!channel || channel_size == 0 || !chat_id || chat_id_size == 0) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    portENTER_CRITICAL(&s_ctx_lock);
+    if (!s_has_latest_context) {
+        portEXIT_CRITICAL(&s_ctx_lock);
+        return ESP_ERR_NOT_FOUND;
+    }
+
+    strncpy(channel, s_latest_channel, channel_size - 1);
+    channel[channel_size - 1] = '\0';
+    strncpy(chat_id, s_latest_chat_id, chat_id_size - 1);
+    chat_id[chat_id_size - 1] = '\0';
+    portEXIT_CRITICAL(&s_ctx_lock);
+
+    return ESP_OK;
+}
diff --git a/main/bus/message_bus.h b/main/bus/message_bus.h
@@ -3,6 +3,7 @@
 #include "esp_err.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/queue.h"
+#include <stddef.h>
 
 /* Channel identifiers */
 #define MIMI_CHAN_TELEGRAM   "telegram"
@@ -45,3 +46,10 @@ esp_err_t message_bus_push_outbound(const mimi_msg_t *msg);
  * Caller must free msg->content when done.
  */
 esp_err_t message_bus_pop_outbound(mimi_msg_t *msg, uint32_t timeout_ms);
+
+/**
+ * Get the latest non-system source context seen on inbound bus.
+ * Useful for routing device-triggered prompts back to the active chat.
+ */
+esp_err_t message_bus_get_latest_client_context(char *channel, size_t channel_size,
+                                                char *chat_id, size_t chat_id_size);
diff --git a/main/buttons/button_driver.c b/main/buttons/button_driver.c
@@ -15,6 +15,13 @@ static void Timer_Callback(void *arg){
 
 struct Button BUTTON1;
 PressEvent BOOT_KEY_State;
+static button_event_cb_t s_event_cb = NULL;
+
+void button_set_event_callback(button_event_cb_t cb)
+{
+  s_event_cb = cb;
+}
+
 static uint8_t Read_Button_GPIO_Level(uint8_t button_id)
 {
   if(!button_id)
@@ -25,18 +32,21 @@ static void Button_SINGLE_CLICK_Callback(void* btn){
   struct Button *user_button = (struct Button *)btn;
   if(user_button == &BUTTON1){
     BOOT_KEY_State = SINGLE_CLICK;
+    if (s_event_cb) s_event_cb(SINGLE_CLICK);
   }
 }
 static void Button_DOUBLE_CLICK_Callback(void* btn){
   struct Button *user_button = (struct Button *)btn;
   if(user_button == &BUTTON1){
     BOOT_KEY_State = DOUBLE_CLICK;
+    if (s_event_cb) s_event_cb(DOUBLE_CLICK);
   }
 }
 static void Button_LONG_PRESS_START_Callback(void* btn){
   struct Button *user_button = (struct Button *)btn;
   if(user_button == &BUTTON1){
     BOOT_KEY_State= LONG_PRESS_START;
+    if (s_event_cb) s_event_cb(LONG_PRESS_START);
   }
 }
 void button_Init(void)

diff --git a/main/buttons/button_driver.h b/main/buttons/button_driver.h
@@ -12,5 +12,7 @@
 extern PressEvent BOOT_KEY_State;    
 
 void button_Init(void);
+typedef void (*button_event_cb_t)(PressEvent event);
+void button_set_event_callback(button_event_cb_t cb);
 
 #endif
diff --git a/main/cli/serial_cli.c b/main/cli/serial_cli.c
@@ -555,13 +555,13 @@ esp_err_t serial_cli_init(void)
 #if CONFIG_ESP_CONSOLE_UART_DEFAULT || CONFIG_ESP_CONSOLE_UART_CUSTOM
     esp_console_dev_uart_config_t hw_config = ESP_CONSOLE_DEV_UART_CONFIG_DEFAULT();
     ESP_ERROR_CHECK(esp_console_new_repl_uart(&hw_config, &repl_config, &repl));
+#elif CONFIG_ESP_CONSOLE_USB_CDC
+    esp_console_dev_usb_cdc_config_t hw_config = ESP_CONSOLE_DEV_CDC_CONFIG_DEFAULT();
+    ESP_ERROR_CHECK(esp_console_new_repl_usb_cdc(&hw_config, &repl_config, &repl));
 #elif CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG
     esp_console_dev_usb_serial_jtag_config_t hw_config =
         ESP_CONSOLE_DEV_USB_SERIAL_JTAG_CONFIG_DEFAULT();
     ESP_ERROR_CHECK(esp_console_new_repl_usb_serial_jtag(&hw_config, &repl_config, &repl));
-#elif CONFIG_ESP_CONSOLE_USB_CDC
-    esp_console_dev_usb_cdc_config_t hw_config = ESP_CONSOLE_DEV_CDC_CONFIG_DEFAULT();
-    ESP_ERROR_CHECK(esp_console_new_repl_usb_cdc(&hw_config, &repl_config, &repl));
 #else
     ESP_LOGE(TAG, "No supported console backend is enabled");
     return ESP_ERR_NOT_SUPPORTED;

diff --git a/main/imu/QMI8658.c b/main/imu/QMI8658.c
@@ -285,6 +285,22 @@ void getGyroscope(void)
     Gyro.z = Gyro.z * gyroScales;
 }
 
+esp_err_t QMI8658_Read_Temperature(float *temp_c)
+{
+    if (!temp_c) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    uint8_t buf[2] = {0};
+    esp_err_t err = I2C_Read(Device_addr, QMI8658_TEMP_L, buf, 2);
+    if (err != ESP_OK) {
+        return err;
+    }
+
+    int16_t raw = (int16_t)(((uint16_t)buf[1] << 8) | buf[0]);
+    *temp_c = ((float)raw / 256.0f) + 25.0f;
+    return ESP_OK;
+}
 
 
 

diff --git a/main/imu/QMI8658.h b/main/imu/QMI8658.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "I2C_Driver.h"
+#include "esp_err.h"
 
 //device address
 #define QMI8658_L_SLAVE_ADDRESS                 (0x6B)
@@ -158,4 +159,5 @@ float getGyroX();
 float getGyroY();
 float getGyroZ();
 void getAccelerometer(void);
-void getGyroscope(void);
+void getGyroscope(void);
+esp_err_t QMI8658_Read_Temperature(float *temp_c);
diff --git a/main/mimi.c b/main/mimi.c
@@ -1,5 +1,7 @@
 #include <stdio.h>
 #include <string.h>
+#include <ctype.h>
+#include <stdbool.h>
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "esp_log.h"
@@ -26,9 +28,100 @@
 #include "buttons/button_driver.h"
 #include "imu/imu_manager.h"
 #include "skills/skill_loader.h"
+#include "trigger/lick_trigger.h"
 
 static const char *TAG = "mimi";
 
+static char *trim_left(char *s)
+{
+    while (s && *s && isspace((unsigned char)*s)) s++;
+    return s;
+}
+
+/* Parse one markdown image line: ![caption](https://...)
+ * Returns true when parsed and values are copied into out buffers.
+ */
+static bool parse_markdown_image_line(const char *line, char *out_url, size_t out_url_sz,
+                                      char *out_caption, size_t out_caption_sz)
+{
+    if (!line || strncmp(line, "![", 2) != 0) return false;
+    const char *cap_end = strstr(line + 2, "](");
+    if (!cap_end) return false;
+    const char *url_start = cap_end + 2;
+    const char *url_end = strchr(url_start, ')');
+    if (!url_end || url_end <= url_start) return false;
+
+    size_t cap_len = (size_t)(cap_end - (line + 2));
+    size_t url_len = (size_t)(url_end - url_start);
+    if (url_len == 0 || url_len >= out_url_sz) return false;
+
+    memcpy(out_url, url_start, url_len);
+    out_url[url_len] = '\0';
+    if (strncmp(out_url, "https://", 8) != 0) return false;
+
+    if (out_caption && out_caption_sz > 0) {
+        size_t cpy = cap_len < (out_caption_sz - 1) ? cap_len : (out_caption_sz - 1);
+        memcpy(out_caption, line + 2, cpy);
+        out_caption[cpy] = '\0';
+    }
+    return true;
+}
+
+/* Telegram dispatcher with image support.
+ * If content includes markdown image lines (![]()), images are sent via sendPhoto.
+ * Remaining text is sent via sendMessage.
+ */
+static esp_err_t telegram_send_rich(const char *chat_id, const char *content)
+{
+    if (!chat_id || !content) return ESP_ERR_INVALID_ARG;
+
+    size_t n = strlen(content);
+    char *scratch = malloc(n + 1);
+    if (!scratch) return ESP_ERR_NO_MEM;
+    memcpy(scratch, content, n + 1);
+
+    char *text_buf = calloc(1, n + 1);
+    if (!text_buf) {
+        free(scratch);
+        return ESP_ERR_NO_MEM;
+    }
+
+    bool any_fail = false;
+    size_t text_off = 0;
+    char *save = NULL;
+    for (char *line = strtok_r(scratch, "\n", &save); line; line = strtok_r(NULL, "\n", &save)) {
+        char *trim = trim_left(line);
+        char image_url[384] = {0};
+        char caption[128] = {0};
+
+        if (parse_markdown_image_line(trim, image_url, sizeof(image_url), caption, sizeof(caption))) {
+            esp_err_t e = telegram_send_photo(chat_id, image_url, caption[0] ? caption : NULL);
+            if (e != ESP_OK) {
+                any_fail = true;
+                ESP_LOGW(TAG, "sendPhoto failed, fallback to text URL");
+                text_off += snprintf(text_buf + text_off, n + 1 - text_off, "%s\n", image_url);
+            }
+            continue;
+        }
+
+        text_off += snprintf(text_buf + text_off, n + 1 - text_off, "%s\n", line);
+    }
+
+    esp_err_t text_err = ESP_OK;
+    if (text_buf[0] != '\0') {
+        text_err = telegram_send_message(chat_id, text_buf);
+    }
+
+    free(text_buf);
+    free(scratch);
+
+    if (any_fail) {
+        ESP_LOGW(TAG, "One or more sendPhoto calls failed; link-text fallback was used");
+    }
+    if (text_err != ESP_OK) return ESP_FAIL;
+    return ESP_OK;
+}
+
 static esp_err_t init_nvs(void)
 {
     esp_err_t ret = nvs_flash_init();
@@ -74,7 +167,7 @@ static void outbound_dispatch_task(void *arg)
         ESP_LOGI(TAG, "Dispatching response to %s:%s", msg.channel, msg.chat_id);
 
         if (strcmp(msg.channel, MIMI_CHAN_TELEGRAM) == 0) {
-            esp_err_t send_err = telegram_send_message(msg.chat_id, msg.content);
+            esp_err_t send_err = telegram_send_rich(msg.chat_id, msg.content);
             if (send_err != ESP_OK) {
                 ESP_LOGE(TAG, "Telegram send failed for %s: %s", msg.chat_id, esp_err_to_name(send_err));
             } else {
@@ -122,6 +215,7 @@ void app_main(void)
 
     /* Initialize subsystems */
     ESP_ERROR_CHECK(message_bus_init());
+    ESP_ERROR_CHECK(lick_trigger_init());
     ESP_ERROR_CHECK(memory_store_init());
     ESP_ERROR_CHECK(skill_loader_init());
     ESP_ERROR_CHECK(session_mgr_init());