fix(files): a re-received file finds the bytes already on disk

The pre-download disk check compared the plaintext on disk against the
wire size, which is the CIPHERTEXT length — 16 AES-GCM bytes bigger — so
the branch was dead and every re-received file downloaded content it
already had. The gate now accepts both forms, and the ledger's recorded
paths join the candidates, covering collision-suffixed downloads and
files sent from arbitrary locations. Content is still hash-verified
before any path is trusted.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: JSKitty

crates/vector-core/src/db/attachments.rs

@@ -219,6 +219,23 @@ pub struct ReusableUpload {
 /// CLAIMS this hash (a hostile sender's fabricated imeta) never qualifies —
 /// our own sends set it by construction. Own uploads win the ordering:
 /// their blobs live on our servers under our delete authority.
+/// Paths where these bytes already landed: every `downloaded=1` row for the
+/// hash, wherever the file was saved (collision suffixes included — the name
+/// on the message says nothing about the name on disk). Rows are CLAIMS: the
+/// caller must hash-verify a path before treating it as the content.
+pub fn downloaded_paths_by_hash(hash: &str) -> Result<Vec<String>, String> {
+    let conn = crate::db::get_db_connection_guard_static()?;
+    let mut stmt = conn
+        .prepare("SELECT DISTINCT path FROM attachments WHERE hash = ?1 AND downloaded = 1 AND path != ''")
+        .map_err(|e| e.to_string())?;
+    let rows = stmt
+        .query_map([hash], |r| r.get::<_, String>(0))
+        .map_err(|e| e.to_string())?
+        .filter_map(|r| r.ok())
+        .collect();
+    Ok(rows)
+}
+
 pub fn find_reusable_by_hash(hash: &str) -> Result<Option<ReusableUpload>, String> {
     if hash.is_empty() {
         return Ok(None);
@@ -365,6 +382,28 @@ mod tests {
         assert!(find_reusable_by_hash("H9").unwrap().is_none());
     }
 
+    /// A re-received file must resolve to the copy already on disk, wherever
+    /// it landed — the ledger's path, not the message's display name, is the
+    /// authority. Undownloaded and pathless rows stay invisible.
+    #[tokio::test]
+    async fn the_ledger_knows_where_the_bytes_already_landed() {
+        let (_tmp, _guard) = init_test_db();
+        let mut on_disk = att("HP", "https://b.example/p", true, true);
+        on_disk.path = "/dl/counter-strike-1.xdc".to_string();
+        save("chat_a", "evt_disk", true, on_disk).await;
+        let mut ghost = att("HP", "https://b.example/p2", true, false);
+        ghost.path = "/dl/never-finished.xdc".to_string();
+        save("chat_b", "evt_ghost", false, ghost).await;
+        save("chat_c", "evt_pathless", true, att("HP", "https://b.example/p3", true, true)).await;
+
+        assert_eq!(
+            downloaded_paths_by_hash("HP").unwrap(),
+            vec!["/dl/counter-strike-1.xdc".to_string()],
+            "only the downloaded row with a real path answers"
+        );
+        assert!(downloaded_paths_by_hash("H9").unwrap().is_empty());
+    }
+
     /// One blob, many messages: the shared copy must outlive every send but
     /// the last. The gate answers from the DB, not memory — an old message
     /// windowed out of STATE still holds its reference here.

src-tauri/src/commands/attachments.rs

@@ -355,8 +355,15 @@ pub async fn download_attachment(npub: String, msg_id: String, attachment_id: St
                                 // and correctly falls through to a real download. Size gates
                                 // the read so an obvious mismatch skips the full hash.
                                 let content_matches = |p: &std::path::PathBuf| {
+                                    // The wire `size` is the CIPHERTEXT length; the disk file is
+                                    // plaintext, 16 AES-GCM tag bytes shorter. Accept either form
+                                    // (plaintext references carry the plaintext size) — an exact
+                                    // equality here kept this whole branch dead and every
+                                    // re-received file downloading bytes it already had.
                                     let size_ok = attachment.size == 0
-                                        || std::fs::metadata(p).map(|m| m.len() == attachment.size).unwrap_or(false);
+                                        || std::fs::metadata(p)
+                                            .map(|m| m.len() == attachment.size || m.len() + 16 == attachment.size)
+                                            .unwrap_or(false);
                                     size_ok
                                         && std::fs::read(p)
                                             .map(|b| util::calculate_file_hash(&b) == expected_hash)
@@ -367,6 +374,17 @@ pub async fn download_attachment(npub: String, msg_id: String, attachment_id: St
                                 } else {
                                     name_path.filter(|p| p.exists() && content_matches(p))
                                 };
+                                // Third candidate: wherever the ledger says these bytes already
+                                // landed — a collision-suffixed download, or a file we SENT from
+                                // an arbitrary path. Rows are claims; content_matches still
+                                // hash-verifies before anything is trusted.
+                                let file_path = file_path.or_else(|| {
+                                    vector_core::db::attachments::downloaded_paths_by_hash(&expected_hash)
+                                        .unwrap_or_default()
+                                        .into_iter()
+                                        .map(std::path::PathBuf::from)
+                                        .find(|p| p.exists() && content_matches(p))
+                                });
                                 if let Some(file_path) = file_path {
                                     // File already exists! Update the state and return success
                                     attachment.set_downloaded(true);