@@ -127,9 +127,8 @@ public class UploadAttachmentsWorker(
                 }
             }
             attachments
-        } catch (e: CancellationException) {
-            throw e
         } catch (e: Exception) {
+            // Also reached when the worker is stopped: the failed states release the sender waiting for them.
             logger.e { "[uploadAttachments] #uploader; unable to upload attachments: ${e.message}" }
             attachments.map {
                 it.copy(
@@ -176,25 +175,33 @@ public class UploadAttachmentsWorker(
         val uploadedAttachments = message.attachments.mapIndexed { index, original ->
             attachments[index].takeIf { it.uploadState == Attachment.UploadState.Success } ?: original
         }
-        messageRepository.insertMessage(message.copy(attachments = uploadedAttachments))
+        insertMessageIfStored(message.copy(attachments = uploadedAttachments))
         channelStateLogic?.listenForChannelState()?.getMessageById(message.id)?.let { current ->
             val updated = current.attachments.map { if (it.uploadId == uploaded.uploadId) uploaded else it }
             channelStateLogic.upsertMessage(current.copy(attachments = updated))
         }
     }
 
-    private suspend fun updateMessages(message: Message) {
+    // Runs even if the worker was stopped: the upload states it publishes release the sender waiting for them.
+    private suspend fun updateMessages(message: Message) = withContext(NonCancellable) {
         val updatedMessage = message.copy(
             syncStatus = message.syncStatus
                 .takeUnless {
                     message.attachments.any { attachment -> attachment.uploadState is Attachment.UploadState.Failed }
                 } ?: SyncStatus.FAILED_PERMANENTLY,
         )
         channelStateLogic?.upsertMessage(updatedMessage)
-        messageRepository.insertMessage(updatedMessage)
+        insertMessageIfStored(updatedMessage)
         AttachmentsUploadStates.updateMessageAttachments(updatedMessage)
     }
 
+    private suspend fun insertMessageIfStored(message: Message) {
+        // A logout that flushed the database also removed the message: don't bring it back.
+        if (messageRepository.selectMessage(message.id) != null) {
+            messageRepository.insertMessage(message)
+        }
+    }
+
     private class ProgressCallbackImpl(
         private val messageId: String,
         private val uploadId: String,
 
@@ -365,8 +365,42 @@ internal class WhenUploadAttachmentsTests {
             )
             verify(attachmentUploader, never())
                 .uploadAttachment(any(), any(), argThat { uploadId == "uploadId2" }, anyOrNull(), anyOrNull())
+            // The final write still publishes a terminal state, which releases the sender.
+            verify(repository).insertMessage(
+                argThat {
+                    attachments.any { it.uploadId == "uploadId1" && it.uploadState == Attachment.UploadState.Success } &&
+                        attachments.any { it.uploadId == "uploadId2" && it.uploadState is Attachment.UploadState.Failed }
+                },
+            )
         }
 
+    @Test
+    fun `Given a logout flushed the database during an upload Should not store the message again`() = runTest {
+        val attachment = randomAttachment().copy(uploadState = Attachment.UploadState.Idle, extraData = mapOf(EXTRA_UPLOAD_ID to "uploadId1"))
+        val message = randomMessage(id = "messageId123", attachments = mutableListOf(attachment))
+        var flushed = false
+        lateinit var workerJob: Job
+        val repository = mock<MessageRepository> {
+            onBlocking { selectMessage(message.id) } doAnswer { message.takeUnless { flushed } }
+        }
+        val attachmentUploader = mock<AttachmentUploader> {
+            on(it.uploadAttachment(any(), any(), any(), anyOrNull(), anyOrNull())) doSuspendableAnswer {
+                // The logout clears the database, then stops the worker, while the upload completes.
+                flushed = true
+                workerJob.cancel()
+                Result.Success(attachment.copy(uploadState = Attachment.UploadState.Success, assetUrl = "url1"))
+            }
+        }
+        val sut = Fixture().givenAttachmentUploader(attachmentUploader)
+            .givenMessageRepository(repository)
+            .get()
+
+        workerJob = launch { sut.uploadAttachmentsForMessage(message.id) }
+        workerJob.join()
+
+        verify(repository, never()).insertMessage(any())
+    }
+
     @Test
     fun `Given an earlier upload failed Should store a later success without marking the message failed`() = runTest {
         val first = randomAttachment().copy(uploadState = Attachment.UploadState.Idle, extraData = mapOf(EXTRA_UPLOAD_ID to "uploadId1"))