fix(discord): address remaining review feedback on text file attachments

- Dynamic fence: loop until fence string absent from content, handles
  files with 4+ consecutive backticks (replaces static "````" check)
- Eliminate double allocation: use from_utf8_lossy directly (zero-copy
  for valid UTF-8) instead of from_utf8(bytes.to_vec()) fallback chain
- Accurate size accounting: download_and_read_text_file now returns
  Option<(ContentBlock, u64)> with actual bytes.len(), replacing
  attachment.size (Discord metadata) for text_file_bytes tracking
- Explicit file count cap: TEXT_FILE_COUNT_CAP = 5 to bound latency
  when many small files are attached, alongside the existing 1 MB cap

Author: claude

src/discord.rs

@@ -130,7 +130,9 @@ impl EventHandler for Handler {
         // Process attachments: route by content type (audio → STT, text file → inline, image → encode)
         if !msg.attachments.is_empty() {
             let mut text_file_bytes: u64 = 0;
+            let mut text_file_count: usize = 0;
             const TEXT_TOTAL_CAP: u64 = 1024 * 1024; // 1 MB total for all text file attachments
+            const TEXT_FILE_COUNT_CAP: usize = 5;
 
             for attachment in &msg.attachments {
                 if is_audio_attachment(attachment) {
@@ -145,12 +147,17 @@ impl EventHandler for Handler {
                         debug!(filename = %attachment.filename, "skipping audio attachment (STT disabled)");
                     }
                 } else if is_text_attachment(attachment) {
+                    if text_file_count >= TEXT_FILE_COUNT_CAP {
+                        warn!(filename = %attachment.filename, count = text_file_count, "text file count cap reached, skipping");
+                        continue;
+                    }
                     if text_file_bytes + u64::from(attachment.size) > TEXT_TOTAL_CAP {
                         warn!(filename = %attachment.filename, total = text_file_bytes, "text attachments total exceeds 1MB cap, skipping remaining");
                         continue;
                     }
-                    if let Some(content_block) = download_and_read_text_file(attachment).await {
-                        text_file_bytes += u64::from(attachment.size);
+                    if let Some((content_block, actual_bytes)) = download_and_read_text_file(attachment).await {
+                        text_file_bytes += actual_bytes;
+                        text_file_count += 1;
                         debug!(filename = %attachment.filename, "adding text file attachment");
                         content_blocks.push(content_block);
                     }
@@ -299,11 +306,12 @@ fn is_text_attachment(attachment: &serenity::model::channel::Attachment) -> bool
     TEXT_FILENAMES.contains(&attachment.filename.to_lowercase().as_str())
 }
 
-/// Download a text-based file attachment and return it as a ContentBlock::Text.
+/// Download a text-based file attachment and return it as a ContentBlock::Text
+/// along with the actual downloaded byte count.
 /// Files larger than 512 KB are skipped to avoid bloating the prompt.
 async fn download_and_read_text_file(
     attachment: &serenity::model::channel::Attachment,
-) -> Option<ContentBlock> {
+) -> Option<(ContentBlock, u64)> {
     const MAX_SIZE: u64 = 512 * 1024; // 512 KB
 
     if u64::from(attachment.size) > MAX_SIZE {
@@ -319,22 +327,25 @@ async fn download_and_read_text_file(
     let bytes = resp.bytes().await.ok()?;
 
     // Defense-in-depth: verify actual download size
-    if bytes.len() as u64 > MAX_SIZE {
+    let actual_bytes = bytes.len() as u64;
+    if actual_bytes > MAX_SIZE {
         warn!(filename = %attachment.filename, size = bytes.len(), "downloaded text file exceeds 512KB limit, skipping");
         return None;
     }
 
-    let text = String::from_utf8(bytes.to_vec()).unwrap_or_else(|_| {
-        String::from_utf8_lossy(&bytes).into_owned()
-    });
+    // from_utf8_lossy returns Cow::Borrowed for valid UTF-8 (zero-copy path)
+    let text = String::from_utf8_lossy(&bytes).into_owned();
 
-    // Use enough backticks to avoid conflicts with content that contains triple backticks
-    let fence = if text.contains("```") { "````" } else { "```" };
+    // Dynamically extend the fence until it no longer appears in the file content
+    let mut fence = "```".to_string();
+    while text.contains(fence.as_str()) {
+        fence.push('`');
+    }
 
     debug!(filename = %attachment.filename, chars = text.len(), "text file inlined");
-    Some(ContentBlock::Text {
+    Some((ContentBlock::Text {
         text: format!("[File: {}]\n{fence}\n{}\n{fence}", attachment.filename, text),
-    })
+    }, actual_bytes))
 }
 
 /// Check if an attachment is an audio file (voice messages are typically audio/ogg).