v0.2.39 - Add 15-minute relay-backed trigger reconciliation in trigger_manager_poll to recover missed self-skill events and re-register missing triggers

src/trigger_manager.c

@@ -589,6 +589,126 @@ static void parse_trigger_runtime_tags(cJSON* tags,
     }
 }
 
+static int trigger_manager_reconcile_from_relays(trigger_manager_t* mgr) {
+    if (!mgr || !mgr->cfg) {
+        return -1;
+    }
+
+    cJSON* filter = cJSON_CreateObject();
+    cJSON* kinds = cJSON_CreateArray();
+    cJSON* authors = cJSON_CreateArray();
+    if (!filter || !kinds || !authors) {
+        cJSON_Delete(filter);
+        cJSON_Delete(kinds);
+        cJSON_Delete(authors);
+        return -1;
+    }
+
+    cJSON_AddItemToArray(kinds, cJSON_CreateNumber(31123));
+    cJSON_AddItemToArray(kinds, cJSON_CreateNumber(31124));
+    cJSON_AddItemToObject(filter, "kinds", kinds);
+    cJSON_AddItemToArray(authors, cJSON_CreateString(mgr->cfg->keys.public_key_hex));
+    cJSON_AddItemToObject(filter, "authors", authors);
+    cJSON_AddNumberToObject(filter, "limit", 300);
+
+    char* events_json = nostr_handler_query_json(filter, 8000);
+    cJSON_Delete(filter);
+    if (!events_json) {
+        DEBUG_WARN("[didactyl] trigger reconcile skipped: relay query returned no data");
+        return -1;
+    }
+
+    cJSON* events = cJSON_Parse(events_json);
+    free(events_json);
+    if (!events || !cJSON_IsArray(events)) {
+        cJSON_Delete(events);
+        DEBUG_WARN("[didactyl] trigger reconcile skipped: invalid JSON from relay query");
+        return -1;
+    }
+
+    int considered = 0;
+    int loaded = 0;
+
+    int event_count = cJSON_GetArraySize(events);
+    for (int i = 0; i < event_count; i++) {
+        cJSON* skill_event = cJSON_GetArrayItem(events, i);
+        cJSON* content = skill_event ? cJSON_GetObjectItemCaseSensitive(skill_event, "content") : NULL;
+        cJSON* tags = skill_event ? cJSON_GetObjectItemCaseSensitive(skill_event, "tags") : NULL;
+        if (!content || !cJSON_IsString(content) || !content->valuestring || !tags || !cJSON_IsArray(tags)) {
+            continue;
+        }
+
+        cJSON* d = find_tag_value_string(tags, "d");
+        cJSON* trigger = find_tag_value_string(tags, "trigger");
+        cJSON* filter_j = find_tag_value_string(tags, "filter");
+        cJSON* action = find_tag_value_string(tags, "action");
+
+        const char* d_tag = (d && cJSON_IsString(d) && d->valuestring) ? d->valuestring : NULL;
+        const char* trigger_s = (trigger && cJSON_IsString(trigger) && trigger->valuestring) ? trigger->valuestring : NULL;
+        const char* filter_s = (filter_j && cJSON_IsString(filter_j) && filter_j->valuestring) ? filter_j->valuestring : NULL;
+        const char* action_s = (action && cJSON_IsString(action) && action->valuestring) ? action->valuestring : "llm";
+
+        considered++;
+        if (!d_tag || d_tag[0] == '\0') {
+            continue;
+        }
+
+        int trigger_supported = trigger_s &&
+                               (strcmp(trigger_s, "nostr-subscription") == 0 ||
+                                strcmp(trigger_s, "webhook") == 0 ||
+                                strcmp(trigger_s, "cron") == 0 ||
+                                strcmp(trigger_s, "chain") == 0 ||
+                                strcmp(trigger_s, "dm") == 0);
+        if (!trigger_supported || !filter_s || filter_s[0] == '\0') {
+            continue;
+        }
+
+        if (strcmp(action_s, "template") == 0) {
+            DEBUG_WARN("[didactyl] trigger action template is deprecated; forcing llm for d_tag=%s", d_tag);
+        }
+
+        const char* llm_s = NULL;
+        const char* tools_s = NULL;
+        int has_max_tokens = 0;
+        int max_tokens = 0;
+        int has_temperature = 0;
+        double temperature = 0.0;
+        int has_seed = 0;
+        int seed = 0;
+        parse_trigger_runtime_tags(tags,
+                                   &llm_s,
+                                   &tools_s,
+                                   &has_max_tokens,
+                                   &max_tokens,
+                                   &has_temperature,
+                                   &temperature,
+                                   &has_seed,
+                                   &seed);
+
+        if (trigger_manager_add(mgr,
+                                d_tag,
+                                content->valuestring,
+                                filter_s,
+                                TRIGGER_ACTION_LLM,
+                                trigger_s,
+                                1,
+                                llm_s,
+                                tools_s,
+                                has_max_tokens,
+                                max_tokens,
+                                has_temperature,
+                                temperature,
+                                has_seed,
+                                seed) == 0) {
+            loaded++;
+        }
+    }
+
+    cJSON_Delete(events);
+    DEBUG_INFO("[didactyl] trigger reconcile complete: loaded=%d considered=%d", loaded, considered);
+    return 0;
+}
+
 static void apply_trigger_runtime_to_llm_config(const active_trigger_t* t, llm_config_t* cfg) {
     if (!t || !cfg) return;
 
@@ -810,6 +930,7 @@ int trigger_manager_init(trigger_manager_t* mgr, didactyl_config_t* cfg) {
     }
 
     mgr->last_poll_at = 0;
+    mgr->last_reconcile_at = 0;
 
     DEBUG_INFO("[didactyl] trigger manager initialized (capacity=%d)", mgr->capacity);
     return 0;
@@ -1447,6 +1568,11 @@ int trigger_manager_poll(trigger_manager_t* mgr) {
     }
     pthread_mutex_unlock(&mgr->mutex);
 
+    if (mgr->last_reconcile_at <= 0 || (now - mgr->last_reconcile_at) >= 900) {
+        mgr->last_reconcile_at = now;
+        (void)trigger_manager_reconcile_from_relays(mgr);
+    }
+
     return fired;
 }