feat(telegram): wire heartbeat alerts to forum topic

Route heartbeat alert messages to a configured Telegram forum topic
via heartbeat_topic_id config. Adds AlertCallback to HeartbeatRunner
that the daemon wires to send messages with message_thread_id().

- AlertCallback type on HeartbeatRunner (invoked for non-OK responses)
- create_heartbeat_alert_callback() in server telegram module
- load_paired_chat_id() helper for notification routing
- Daemon wires callback when heartbeat_topic_id is configured

Author: yiwang

crates/cli/src/cli/daemon.rs

@@ -275,6 +275,25 @@ async fn run_daemon_services(
                 runner.enable_gen_dispatch();
                 tracing::info!("Heartbeat gen dispatch enabled (localgpt-gen found)");
             }
+
+            // Wire Telegram alert callback if heartbeat_topic_id is configured
+            if let Some(ref tg) = heartbeat_config.telegram
+                && tg.enabled
+                && let Some(topic_id) = tg.heartbeat_topic_id
+                && !tg.api_token.is_empty()
+                && !tg.api_token.starts_with("${")
+                && let Some(callback) = localgpt_server::telegram::create_heartbeat_alert_callback(
+                    &tg.api_token,
+                    topic_id,
+                )
+            {
+                runner.set_alert_callback(callback);
+                tracing::info!(
+                    "Heartbeat Telegram alert callback enabled (topic_id: {})",
+                    topic_id
+                );
+            }
+
             tracing::info!("Heartbeat runner created");
             if let Err(e) = runner.run().await {
                 tracing::error!("Heartbeat runner error: {}", e);

crates/core/src/heartbeat/mod.rs

@@ -3,4 +3,4 @@ pub mod gen_dispatch;
 mod runner;
 
 pub use events::{HeartbeatEvent, HeartbeatStatus, emit_heartbeat_event, get_last_heartbeat_event};
-pub use runner::{HeartbeatRunner, ToolFactory};
+pub use runner::{AlertCallback, HeartbeatRunner, ToolFactory};

crates/core/src/heartbeat/runner.rs

@@ -43,8 +43,14 @@ pub struct HeartbeatRunner {
     /// When true, heartbeat checks HEARTBEAT.md for gen experiments before normal processing
     /// and dispatches them via `localgpt-gen headless` subprocess.
     gen_dispatch_enabled: bool,
+    /// Optional callback invoked when heartbeat produces an alert (non-OK, non-skipped response).
+    /// Used by the daemon to forward alerts to Telegram.
+    on_alert: Option<AlertCallback>,
 }
 
+/// Callback type for heartbeat alert notifications
+pub type AlertCallback = Box<dyn Fn(&str) + Send + Sync>;
+
 impl HeartbeatRunner {
     /// Create a new HeartbeatRunner with the default agent ID ("main")
     pub fn new(config: &Config) -> Result<Self> {
@@ -129,6 +135,7 @@ impl HeartbeatRunner {
             workspace_lock,
             tool_factory,
             gen_dispatch_enabled: false,
+            on_alert: None,
         })
     }
 
@@ -141,6 +148,12 @@ impl HeartbeatRunner {
         self.gen_dispatch_enabled = true;
     }
 
+    /// Set a callback invoked when heartbeat produces an alert (non-OK, non-skipped).
+    /// Used by the daemon to forward alerts to Telegram with topic routing.
+    pub fn set_alert_callback(&mut self, callback: AlertCallback) {
+        self.on_alert = Some(callback);
+    }
+
     async fn first_delay(&self) -> Duration {
         // Read last heartbeat event to calibrate first tick time
         if let Ok(json) = fs::read_to_string(self.config.paths.last_heartbeat())
@@ -267,6 +280,10 @@ impl HeartbeatRunner {
                         debug!(name: "Heartbeat", "OK");
                     } else {
                         warn!(name: "Heartbeat", "response not OK: {}", response);
+                        // Notify via alert callback (e.g., Telegram with topic routing)
+                        if let Some(ref callback) = self.on_alert {
+                            callback(&response);
+                        }
                     }
 
                     if status == HeartbeatStatus::SkippedMayTry {

crates/server/src/telegram.rs

@@ -10,7 +10,7 @@ use std::path::PathBuf;
 use std::sync::Arc;
 use std::time::Instant;
 use teloxide::prelude::*;
-use teloxide::types::{MessageId, ParseMode};
+use teloxide::types::{ChatId, MessageId, ParseMode, ThreadId};
 use tokio::sync::Mutex;
 use tracing::{debug, error, info, warn};
 
@@ -65,6 +65,38 @@ fn load_paired_user() -> Option<PairedUser> {
     serde_json::from_str(&content).ok()
 }
 
+/// Load the paired user's chat ID for sending notifications.
+/// In Telegram, private chat ID equals user ID for DMs.
+pub fn load_paired_chat_id() -> Option<i64> {
+    load_paired_user().map(|u| u.user_id as i64)
+}
+
+/// Create a heartbeat alert callback that sends messages to a Telegram topic.
+/// Returns None if no paired user or missing config.
+pub fn create_heartbeat_alert_callback(
+    api_token: &str,
+    topic_id: i32,
+) -> Option<localgpt_core::heartbeat::AlertCallback> {
+    let chat_id = load_paired_chat_id()?;
+    let bot = Bot::new(api_token);
+
+    Some(Box::new(move |text: &str| {
+        let bot = bot.clone();
+        let msg = if text.len() > 4000 {
+            format!("{}...", &text[..text.floor_char_boundary(4000)])
+        } else {
+            text.to_string()
+        };
+        tokio::spawn(async move {
+            let mut req = bot.send_message(ChatId(chat_id), &msg);
+            req = req.message_thread_id(ThreadId(MessageId(topic_id)));
+            if let Err(e) = req.await {
+                tracing::warn!("Failed to send heartbeat alert to Telegram topic: {}", e);
+            }
+        });
+    }))
+}
+
 fn save_paired_user(user: &PairedUser) -> Result<()> {
     let path = pairing_file_path()?;
     let content = serde_json::to_string_pretty(user)?;