fix(adapters): inject system note when image validation fails so agent reply aligns with warning

When download_and_encode_image rejects an attachment, the Slack/Discord
adapter already sends the user a visible ⚠️ message. Without this
change, the agent sees no attachment and may reply "I don't see any image
attached" -- contradicting the warning the user just received.

- Add media::format_failed_attachment_note() as a shared helper (single
  source of truth) for the ContentBlock::Text injected into extra_blocks.
- Slack: push the note after the existing warning send (pack_arrival_event
  partitions Text blocks before the typed prompt; stable iteration order
  means push trails any STT transcript, which is correct).
- Discord: introduce failed_image_files Vec, split the catch-all Err arm
  into variant-specific arms matching Slack, send a Discord-flavored user
  warning (without the Slack files:read scope hint), and inject the note.
- Add three unit tests for format_failed_attachment_note in media::tests.

Addresses the minor UX observation from the openabdev#776 final review comment
(antigenius0910, 2026-05-14). Depends on PR openabdev#793 (failed_image_files Vec
and MediaFetchError variants introduced there).

Fixes openabdev#776 (UX follow-up).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: howie

src/discord.rs

@@ -647,6 +647,7 @@ impl EventHandler for Handler {
         let mut echo_entries: Vec<crate::stt::EchoEntry> = Vec::new();
         let mut text_file_bytes: u64 = 0;
         let mut text_file_count: u32 = 0;
+        let mut failed_image_files: Vec<String> = Vec::new();
         const TEXT_TOTAL_CAP: u64 = 1024 * 1024; // 1 MB total for all text file attachments
         const TEXT_FILE_COUNT_CAP: u32 = 5;
 
@@ -738,6 +739,39 @@ impl EventHandler for Handler {
                             ));
                         }
                     }
+                    Err(media::MediaFetchError::SizeExceeded { actual, limit }) => {
+                        tracing::warn!(
+                            url = %attachment.url,
+                            filename = %attachment.filename,
+                            actual,
+                            limit,
+                            "image exceeds size limit"
+                        );
+                        failed_image_files.push(format!(
+                            "{} (exceeds {limit} byte limit)",
+                            attachment.filename
+                        ));
+                    }
+                    Err(
+                        media::MediaFetchError::UnsupportedResponseType { .. }
+                        | media::MediaFetchError::InvalidImageBody { .. },
+                    ) => {
+                        tracing::warn!(
+                            url = %attachment.url,
+                            filename = %attachment.filename,
+                            "image validation failed; body is not a supported image"
+                        );
+                        failed_image_files.push(attachment.filename.clone());
+                    }
+                    Err(media::MediaFetchError::ProcessingFailed(ref e)) => {
+                        tracing::warn!(
+                            url = %attachment.url,
+                            filename = %attachment.filename,
+                            error = %e,
+                            "image post-processing failed"
+                        );
+                        failed_image_files.push(attachment.filename.clone());
+                    }
                     Err(e) => {
                         tracing::warn!(
                             url = %attachment.url,
@@ -750,6 +784,28 @@ impl EventHandler for Handler {
             }
         }
 
+        if !failed_image_files.is_empty() {
+            let warn_channel = ChannelRef {
+                platform: "discord".into(),
+                channel_id: msg.channel_id.get().to_string(),
+                thread_id: None,
+                parent_id: None,
+                origin_event_id: None,
+            };
+            let file_list = failed_image_files.join("`, `");
+            let warn_msg = format!(
+                ":warning: I couldn't process the file(s) you shared (`{file_list}`). \
+                 Supported formats are PNG / JPEG / GIF / WebP up to 10 MB."
+            );
+            if let Err(e) = adapter.send_message(&warn_channel, &warn_msg).await {
+                warn!(error = %e, "failed to send image validation warning to user");
+            }
+            let names: Vec<&str> = failed_image_files.iter().map(String::as_str).collect();
+            extra_blocks.push(ContentBlock::Text {
+                text: media::format_failed_attachment_note(&names),
+            });
+        }
+
         tracing::debug!(
             num_extra_blocks = extra_blocks.len(),
             num_attachments = msg.attachments.len(),

src/media.rs

@@ -67,6 +67,23 @@ impl std::fmt::Display for MediaFetchError {
     }
 }
 
+/// Build a `[Attachment validation failed]` note for injection into the agent prompt
+/// so the agent's reply acknowledges the failure instead of asking "where's the image?".
+/// Caller must guarantee `filenames` is non-empty.
+pub fn format_failed_attachment_note(filenames: &[&str]) -> String {
+    let list = filenames
+        .iter()
+        .map(|n| format!("`{n}`"))
+        .collect::<Vec<_>>()
+        .join(", ");
+    format!(
+        "[Attachment validation failed]: the user attempted to attach {list} but \
+         the file(s) could not be processed (unsupported format, corrupt body, or \
+         size limit exceeded). The user has been notified separately — acknowledge \
+         the failure and proceed without apologising for not seeing the file."
+    )
+}
+
 /// Strip MIME parameters and trim whitespace.  `"image/png; charset=binary"` → `"image/png"`.
 pub(crate) fn strip_mime_params(mime: &str) -> &str {
     mime.split(';').next().unwrap_or(mime).trim()
@@ -793,4 +810,28 @@ mod tests {
         let bytes = [0xffu8, 0xd8];
         assert_eq!(hex_prefix(&bytes), "ffd8");
     }
+
+    // --- format_failed_attachment_note tests ---
+
+    #[test]
+    fn format_failed_attachment_note_single() {
+        let note = super::format_failed_attachment_note(&["photo.png"]);
+        assert!(note.contains("`photo.png`"));
+        assert!(note.starts_with("[Attachment validation failed]:"));
+        assert!(note.contains("The user has been notified separately"));
+    }
+
+    #[test]
+    fn format_failed_attachment_note_multiple() {
+        let note = super::format_failed_attachment_note(&["a.png", "b.jpg"]);
+        assert!(note.contains("`a.png`"));
+        assert!(note.contains("`b.jpg`"));
+        assert!(note.contains(", "));
+    }
+
+    #[test]
+    fn format_failed_attachment_note_preserves_size_suffix() {
+        let note = super::format_failed_attachment_note(&["big.png (exceeds 10000000 byte limit)"]);
+        assert!(note.contains("`big.png (exceeds 10000000 byte limit)`"));
+    }
 }

src/slack.rs

@@ -1103,6 +1103,14 @@ async fn handle_message(
         if let Err(e) = adapter.send_message(&warn_channel, &msg).await {
             warn!(error = %e, "failed to send image validation warning to user");
         }
+        // Inject a system note so the agent's reply acknowledges the failure
+        // instead of saying "I don't see any image". pack_arrival_event partitions
+        // Text blocks before the prompt (stable order), so push trails any STT
+        // transcript but precedes the typed prompt — correct position for meta-info.
+        let names: Vec<&str> = failed_image_files.iter().map(String::as_str).collect();
+        extra_blocks.push(ContentBlock::Text {
+            text: media::format_failed_attachment_note(&names),
+        });
     }
 
     // Resolve Slack display name (best-effort, fallback to user_id)