feat: reject feedback prompt + timeout UX cleanup

Inspired by PR #1 (thanks @wangyuyan-agent).

- After reject, send follow-up asking for reason; accept any text
  message from trusted user within configurable window (default 60s)
- On timeout, remove stale inline keyboard + send timeout notice
- New config: reject_feedback_timeout (seconds, 0 to skip)
- New i18n strings: reject_feedback_prompt, timeout_notice

Author: antx-code

src/config.rs

@@ -10,6 +10,8 @@ pub struct Config {
     pub default_provider: String,
     #[serde(default = "default_timeout")]
     pub default_timeout: u64,
+    #[serde(default = "default_reject_feedback_timeout")]
+    pub reject_feedback_timeout: u64,
     #[serde(default)]
     pub locale: Locale,
     pub telegram: Option<TelegramConfig>,
@@ -47,6 +49,10 @@ fn default_timeout() -> u64 {
     3600
 }
 
+fn default_reject_feedback_timeout() -> u64 {
+    60
+}
+
 fn default_audit_file() -> String {
     let base = dirs::data_local_dir()
         .unwrap_or_else(|| PathBuf::from("~/.local/share"))
@@ -102,6 +108,8 @@ impl Config {
     pub fn generate_default() -> String {
         r#"default_provider = "telegram"
 default_timeout = 3600
+# Seconds to wait for reject feedback (0 = skip)
+reject_feedback_timeout = 60
 # locale: "en" (default), "zh-CN", "zh-TW"
 locale = "en"
 

src/i18n.rs

@@ -32,6 +32,8 @@ pub struct Messages {
     pub prompt_text: &'static str,
     pub approved_callback: &'static str,
     pub rejected_callback: &'static str,
+    pub reject_feedback_prompt: &'static str,
+    pub timeout_notice: &'static str,
 }
 
 impl Locale {
@@ -43,20 +45,26 @@ impl Locale {
                 prompt_text: "Please approve or reject this request.",
                 approved_callback: "Approved \u{2714}",
                 rejected_callback: "Rejected \u{2714}",
+                reject_feedback_prompt: "\u{274C} <b>Rejected.</b> Reply to this message to add a reason (or ignore to skip).",
+                timeout_notice: "\u{23F0} Request timed out \u{2014} no response received.",
             },
             Self::ZhCN => Messages {
                 approve_button: "\u{2705} \u{6279}\u{51C6}",
                 reject_button: "\u{274C} \u{62D2}\u{7EDD}",
                 prompt_text: "\u{8BF7}\u{6279}\u{51C6}\u{6216}\u{62D2}\u{7EDD}\u{6B64}\u{8BF7}\u{6C42}\u{3002}",
                 approved_callback: "\u{5DF2}\u{6279}\u{51C6} \u{2714}",
                 rejected_callback: "\u{5DF2}\u{62D2}\u{7EDD} \u{2714}",
+                reject_feedback_prompt: "\u{274C} <b>\u{5DF2}\u{62D2}\u{7EDD}\u{3002}</b>\u{56DE}\u{590D}\u{6B64}\u{6D88}\u{606F}\u{4EE5}\u{6DFB}\u{52A0}\u{539F}\u{56E0}\u{FF08}\u{5FFD}\u{7565}\u{5219}\u{8DF3}\u{8FC7}\u{FF09}\u{3002}",
+                timeout_notice: "\u{23F0} \u{8BF7}\u{6C42}\u{5DF2}\u{8D85}\u{65F6} \u{2014} \u{672A}\u{6536}\u{5230}\u{54CD}\u{5E94}\u{3002}",
             },
             Self::ZhTW => Messages {
                 approve_button: "\u{2705} \u{6279}\u{51C6}",
                 reject_button: "\u{274C} \u{62D2}\u{7D55}",
                 prompt_text: "\u{8ACB}\u{6279}\u{51C6}\u{6216}\u{62D2}\u{7D55}\u{6B64}\u{8ACB}\u{6C42}\u{3002}",
                 approved_callback: "\u{5DF2}\u{6279}\u{51C6} \u{2714}",
                 rejected_callback: "\u{5DF2}\u{62D2}\u{7D55} \u{2714}",
+                reject_feedback_prompt: "\u{274C} <b>\u{5DF2}\u{62D2}\u{7D55}\u{3002}</b>\u{56DE}\u{8986}\u{6B64}\u{8A0A}\u{606F}\u{4EE5}\u{9644}\u{4E0A}\u{539F}\u{56E0}\u{FF08}\u{5FFD}\u{7565}\u{5247}\u{8DF3}\u{904E}\u{FF09}\u{3002}",
+                timeout_notice: "\u{23F0} \u{8ACB}\u{6C42}\u{5DF2}\u{8D85}\u{6642} \u{2014} \u{672A}\u{6536}\u{5230}\u{56DE}\u{61C9}\u{3002}",
             },
         }
     }

src/main.rs

@@ -88,6 +88,7 @@ async fn main() -> Result<()> {
                 title: title.clone(),
                 body: body_content,
                 timeout_secs,
+                reject_feedback_timeout_secs: config.reject_feedback_timeout,
             };
 
             let provider: Box<dyn Provider> = match config.default_provider.as_str() {

src/providers/telegram.rs

@@ -217,19 +217,136 @@ impl TelegramProvider {
         Ok(())
     }
 
+    /// Send a message as a reply to another message
+    async fn send_reply(&self, reply_to_message_id: i64, text: &str) -> Result<i64> {
+        #[derive(Serialize)]
+        struct Req {
+            chat_id: i64,
+            text: String,
+            parse_mode: String,
+            reply_to_message_id: i64,
+        }
+        let resp: TelegramResponse<Message> = self
+            .client
+            .post(format!("{}/sendMessage", self.base_url))
+            .json(&Req {
+                chat_id: self.config.chat_id,
+                text: text.to_string(),
+                parse_mode: "HTML".to_string(),
+                reply_to_message_id,
+            })
+            .send()
+            .await?
+            .json()
+            .await?;
+        let msg_id = resp.result.map_or(0, |m| m.message_id);
+        Ok(msg_id)
+    }
+
+    /// Send a standalone notice message
+    async fn send_notice(&self, text: &str) -> Result<()> {
+        #[derive(Serialize)]
+        struct Req {
+            chat_id: i64,
+            text: String,
+            parse_mode: String,
+        }
+        self.client
+            .post(format!("{}/sendMessage", self.base_url))
+            .json(&Req {
+                chat_id: self.config.chat_id,
+                text: text.to_string(),
+                parse_mode: "HTML".to_string(),
+            })
+            .send()
+            .await?;
+        Ok(())
+    }
+
+    /// After reject, send a follow-up reply and wait for feedback text
+    async fn wait_for_reject_feedback(
+        &self,
+        original_message_id: i64,
+        wait_secs: u64,
+        mut offset: Option<i64>,
+    ) -> Result<Option<String>> {
+        if wait_secs == 0 {
+            return Ok(None);
+        }
+
+        // Send follow-up as reply to the original request message
+        // Send follow-up as reply to the original request message
+        self.send_reply(original_message_id, self.messages.reject_feedback_prompt)
+            .await
+            .ok();
+
+        let deadline = tokio::time::Instant::now() + Duration::from_secs(wait_secs);
+
+        loop {
+            if tokio::time::Instant::now() >= deadline {
+                return Ok(None);
+            }
+
+            let remaining = deadline - tokio::time::Instant::now();
+            let poll_timeout = remaining.min(Duration::from_secs(10));
+
+            let mut url = format!(
+                "{}/getUpdates?timeout={}&allowed_updates=[\"message\"]",
+                self.base_url,
+                poll_timeout.as_secs()
+            );
+            if let Some(off) = offset {
+                url.push_str(&format!("&offset={off}"));
+            }
+
+            let resp: TelegramResponse<Vec<Update>> =
+                self.client.get(&url).send().await?.json().await?;
+
+            let updates = match resp.result {
+                Some(u) => u,
+                None => continue,
+            };
+
+            for update in updates {
+                offset = Some(update.update_id + 1);
+
+                if let Some(msg) = update.message {
+                    if msg.chat.id != self.config.chat_id {
+                        continue;
+                    }
+                    let user_id = msg.from.as_ref().map_or(0, |u| u.id);
+                    if !self.is_trusted(user_id) {
+                        continue;
+                    }
+                    // Accept any text message from trusted user in this chat
+                    // (reply to original, reply to follow-up, or direct message)
+                    if msg.text.is_some() {
+                        return Ok(msg.text.clone());
+                    }
+                }
+            }
+
+            tokio::time::sleep(POLL_INTERVAL).await;
+        }
+    }
+
     async fn poll_for_response(
         &self,
         sent_message_id: i64,
         timeout: Duration,
-        title: &str,
+        request: &FeedbackRequest,
     ) -> Result<FeedbackResponse> {
         let deadline = tokio::time::Instant::now() + timeout;
         let mut offset: Option<i64> = None;
 
         loop {
             if tokio::time::Instant::now() >= deadline {
                 info!("Timeout reached, no response received");
-                return Ok(FeedbackResponse::timeout(title));
+                self.edit_message_reply_markup(self.config.chat_id, sent_message_id)
+                    .await
+                    .ok();
+                self.send_notice(self.messages.timeout_notice).await.ok();
+                return Ok(FeedbackResponse::timeout(&request.title));
             }
 
             let remaining = deadline - tokio::time::Instant::now();
@@ -300,13 +417,31 @@ impl TelegramProvider {
                         "Response received"
                     );
 
+                    // For reject: prompt for optional feedback
+                    let feedback = if decision == Decision::Rejected {
+                        let fb = self
+                            .wait_for_reject_feedback(
+                                sent_message_id,
+                                request.reject_feedback_timeout_secs,
+                                offset,
+                            )
+                            .await
+                            .unwrap_or(None);
+                        if fb.is_some() {
+                            info!(feedback = ?fb, "Reject feedback received");
+                        }
+                        fb
+                    } else {
+                        None
+                    };
+
                     return Ok(FeedbackResponse {
                         decision,
                         user: cb.from.display_name(),
                         user_id: cb.from.id,
-                        feedback: None,
+                        feedback,
                         timestamp: Utc::now(),
-                        request_title: title.to_string(),
+                        request_title: request.title.clone(),
                     });
                 }
 
@@ -350,7 +485,7 @@ impl TelegramProvider {
                                 user_id,
                                 feedback: feedback_text,
                                 timestamp: Utc::now(),
-                                request_title: title.to_string(),
+                                request_title: request.title.clone(),
                             });
                         }
                     }
@@ -367,7 +502,7 @@ impl Provider for TelegramProvider {
     async fn send_and_wait(&self, request: &FeedbackRequest) -> Result<FeedbackResponse> {
         let msg_id = self.send_message(request).await?;
         let timeout = Duration::from_secs(request.timeout_secs);
-        self.poll_for_response(msg_id, timeout, &request.title).await
+        self.poll_for_response(msg_id, timeout, request).await
     }
 }
 

src/types.rs

@@ -6,6 +6,7 @@ pub struct FeedbackRequest {
     pub title: String,
     pub body: String,
     pub timeout_secs: u64,
+    pub reject_feedback_timeout_secs: u64,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]