diff --git a/App.tsx b/App.tsx
index 134c43e..77b4635 100644
--- a/App.tsx
+++ b/App.tsx
@@ -143,6 +143,16 @@ function MainTabsNavigator({ navigation }: NativeStackScreenProps<RootStackParam
           <EmailListScreen
             onComposePress={() => navigation.navigate('Compose')}
             onEmailPress={(email) => {
+              // An own-account draft opens back in the composer for editing,
+              // not in the read-only thread view. Drafts browsed in a shared
+              // account's folder stay read-only — the composer can't save
+              // into or destroy from another account.
+              const { currentMailboxId } = useEmailStore.getState();
+              const currentMailbox = mailboxes.find((m) => m.id === currentMailboxId);
+              if (email.keywords?.$draft && !currentMailbox?.isShared) {
+                navigation.navigate('Compose', { draft: { emailId: email.id } });
+                return;
+              }
               navigation.navigate('EmailThread', {
                 emailId: email.id,
                 threadId: email.threadId,
diff --git a/locales/en/common.json b/locales/en/common.json
index df03173..6c38451 100644
--- a/locales/en/common.json
+++ b/locales/en/common.json
@@ -455,6 +455,10 @@
     "discard": "Discard",
     "discard_draft_title": "Discard draft?",
     "discard_draft_confirm": "You have unsaved changes. Do you want to discard this draft?",
+    "edit_draft": "Edit draft",
+    "save_draft": "Save draft",
+    "save_draft_failed": "Could not save draft",
+    "uploads_in_flight": "Wait for attachments to finish uploading.",
     "saving": "Saving...",
     "sending": "Sending...",
     "add_link": "Add link",
diff --git a/locales/fr/common.json b/locales/fr/common.json
index b37618c..a035bb0 100644
--- a/locales/fr/common.json
+++ b/locales/fr/common.json
@@ -451,6 +451,11 @@
     "discard": "Supprimer",
     "discard_draft_title": "Supprimer le brouillon ?",
     "discard_draft_confirm": "Vous avez des modifications non enregistrées. Voulez-vous supprimer ce brouillon ?",
+    "edit_draft": "Modifier le brouillon",
+    "editor_unavailable": "Impossible de lire le contenu du message. Copiez votre texte, puis fermez et rouvrez l'éditeur.",
+    "save_draft": "Enregistrer le brouillon",
+    "save_draft_failed": "Impossible d'enregistrer le brouillon",
+    "uploads_in_flight": "Attendez la fin de l'envoi des pièces jointes.",
     "saving": "Enregistrement...",
     "draft_saved": "Brouillon enregistré",
     "save_failed": "Échec de l'enregistrement",
diff --git a/src/api/__tests__/email.test.ts b/src/api/__tests__/email.test.ts
index 684b544..7e0f572 100644
--- a/src/api/__tests__/email.test.ts
+++ b/src/api/__tests__/email.test.ts
@@ -24,6 +24,7 @@ import {
   deleteEmail,
   searchEmails,
   sendEmail,
+  saveDraft,
 } from '../email';
 
 const mockRequest = jmapClient.request as ReturnType<typeof vi.fn>;
@@ -406,4 +407,74 @@ describe('email operations', () => {
       expect(emailCreate['header:References:asText']).toBe('<msg-0@example.com> <msg-1@example.com>');
     });
   });
+
+  describe('saveDraft', () => {
+    it('should create the draft in the drafts mailbox with the $draft keyword', async () => {
+      mockRequest.mockResolvedValue({
+        methodResponses: [['Email/set', { created: { draft: { id: 'e-draft' } } }, '0']],
+      });
+
+      const result = await saveDraft(
+        {
+          from: [{ email: 'me@example.com' }],
+          to: [{ email: 'you@example.com' }],
+          subject: 'WIP',
+          htmlBody: '<p>half-written</p>',
+        },
+        'drafts-mb',
+      );
+
+      expect(result).toEqual({ emailId: 'e-draft' });
+      const setArgs = mockRequest.mock.calls[0][0][0][1];
+      expect(setArgs.destroy).toBeUndefined();
+      expect(setArgs.create.draft.mailboxIds).toEqual({ 'drafts-mb': true });
+      expect(setArgs.create.draft.keywords).toEqual({ $draft: true, $seen: true });
+    });
+
+    it('should destroy the replaced draft in the same Email/set call', async () => {
+      mockRequest.mockResolvedValue({
+        methodResponses: [
+          ['Email/set', { created: { draft: { id: 'e-new' } }, destroyed: ['e-old'] }, '0'],
+        ],
+      });
+
+      await saveDraft(
+        { from: [{ email: 'me@example.com' }], subject: '', textBody: 'note to self' },
+        'drafts-mb',
+        'e-old',
+      );
+
+      const setArgs = mockRequest.mock.calls[0][0][0][1];
+      expect(setArgs.destroy).toEqual(['e-old']);
+    });
+
+    it('should allow a draft without recipients', async () => {
+      mockRequest.mockResolvedValue({
+        methodResponses: [['Email/set', { created: { draft: { id: 'e-draft' } } }, '0']],
+      });
+
+      await saveDraft(
+        { from: [{ email: 'me@example.com' }], subject: 'no recipients yet', textBody: 'x' },
+        'drafts-mb',
+      );
+
+      const emailCreate = mockRequest.mock.calls[0][0][0][1].create.draft;
+      expect(emailCreate.to).toBeUndefined();
+    });
+
+    it('should throw when the server rejects the create', async () => {
+      mockRequest.mockResolvedValue({
+        methodResponses: [
+          ['Email/set', { notCreated: { draft: { type: 'overQuota', description: 'Mailbox full' } } }, '0'],
+        ],
+      });
+
+      await expect(
+        saveDraft(
+          { from: [{ email: 'me@example.com' }], subject: 'x', textBody: 'y' },
+          'drafts-mb',
+        ),
+      ).rejects.toThrow('Mailbox full');
+    });
+  });
 });
diff --git a/src/api/email.ts b/src/api/email.ts
index db31d50..2fc74a4 100644
--- a/src/api/email.ts
+++ b/src/api/email.ts
@@ -766,35 +766,32 @@ export interface SendEmailResult {
   emailSubmissionId?: string;
 }
 
-export async function sendEmail(
-  email: {
-    from: EmailAddress[];
-    to: EmailAddress[];
-    cc?: EmailAddress[];
-    bcc?: EmailAddress[];
-    subject: string;
-    htmlBody?: string;
-    textBody?: string;
-    attachments?: OutgoingAttachment[];
-    inReplyTo?: string;
-    references?: string;
-  },
-  identityId: string,
-  sentMailboxId: string,
-  // When > 0 the message is held for this many seconds before delivery via the
-  // SMTP HOLDFOR parameter (FUTURERELEASE). Used for both explicit "send later"
-  // scheduling and the global send-delay (undo-send) window.
-  holdForSeconds?: number,
-): Promise<SendEmailResult> {
-  const accountId = jmapClient.accountId;
+export interface OutgoingEmailContent {
+  from: EmailAddress[];
+  to?: EmailAddress[];
+  cc?: EmailAddress[];
+  bcc?: EmailAddress[];
+  subject: string;
+  htmlBody?: string;
+  textBody?: string;
+  attachments?: OutgoingAttachment[];
+  inReplyTo?: string;
+  references?: string;
+}
+
+function buildEmailCreate(
+  email: OutgoingEmailContent,
+  mailboxId: string,
+  keywords: Record<string, boolean>,
+): Record<string, unknown> {
   const emailCreate: Record<string, unknown> = {
     from: email.from,
     to: email.to,
     cc: email.cc,
     bcc: email.bcc,
     subject: email.subject,
-    mailboxIds: { [sentMailboxId]: true },
-    keywords: { $seen: true },
+    mailboxIds: { [mailboxId]: true },
+    keywords,
   };
 
   const bodyValues: Record<string, { value: string }> = {};
@@ -827,6 +824,21 @@ export async function sendEmail(
     emailCreate['header:References:asText'] = email.references ?? email.inReplyTo;
   }
 
+  return emailCreate;
+}
+
+export async function sendEmail(
+  email: OutgoingEmailContent & { to: EmailAddress[] },
+  identityId: string,
+  sentMailboxId: string,
+  // When > 0 the message is held for this many seconds before delivery via the
+  // SMTP HOLDFOR parameter (FUTURERELEASE). Used for both explicit "send later"
+  // scheduling and the global send-delay (undo-send) window.
+  holdForSeconds?: number,
+): Promise<SendEmailResult> {
+  const accountId = jmapClient.accountId;
+  const emailCreate = buildEmailCreate(email, sentMailboxId, { $seen: true });
+
   const submissionCreate: Record<string, unknown> = { emailId: '#draft', identityId };
   // For a deferred send the envelope must be set explicitly so the HOLDFOR
   // mail-from parameter rides along (JMAP §7.3: an omitted envelope makes the
@@ -885,6 +897,40 @@ export async function sendEmail(
   };
 }
 
+/**
+ * Create (or re-create) a draft in the drafts mailbox. JMAP emails are
+ * immutable apart from keywords/mailboxIds (RFC 8621 §4), so "updating" a
+ * draft means creating a replacement and destroying the original in the same
+ * Email/set call. A failed destroy leaves a stale copy behind but never loses
+ * the new draft, so it is reported by the server yet not treated as an error.
+ */
+export async function saveDraft(
+  email: OutgoingEmailContent,
+  draftsMailboxId: string,
+  replaceEmailId?: string,
+): Promise<{ emailId: string }> {
+  const accountId = jmapClient.accountId;
+  const emailCreate = buildEmailCreate(email, draftsMailboxId, { $draft: true, $seen: true });
+
+  const setArgs: Record<string, unknown> = { accountId, create: { draft: emailCreate } };
+  if (replaceEmailId) setArgs.destroy = [replaceEmailId];
+
+  const res = await jmapClient.request(
+    [['Email/set', setArgs, '0']],
+    [CAPABILITIES.CORE, CAPABILITIES.MAIL],
+  );
+
+  const [methodName, result] = res.methodResponses[0];
+  if (methodName.endsWith('/error')) {
+    throw new Error((result as { description?: string }).description ?? 'Failed to save draft');
+  }
+  const notCreated = (result as { notCreated?: Record<string, { description?: string; type?: string }> }).notCreated?.draft;
+  if (notCreated) throw new Error(notCreated.description ?? notCreated.type ?? 'Failed to save draft');
+  const emailId = (result as { created?: Record<string, { id?: string }> }).created?.draft?.id;
+  if (!emailId) throw new Error('Failed to save draft');
+  return { emailId };
+}
+
 export interface ScheduledEmail {
   emailSubmissionId: string;
   emailId: string;
diff --git a/src/lib/__tests__/draft-compose.test.ts b/src/lib/__tests__/draft-compose.test.ts
new file mode 100644
index 0000000..b6ca1ce
--- /dev/null
+++ b/src/lib/__tests__/draft-compose.test.ts
@@ -0,0 +1,106 @@
+import { describe, it, expect } from 'vitest';
+import { draftToComposeInit, rewriteCidSrcToDataUrls } from '../draft-compose';
+import type { Email } from '../../api/types';
+
+function makeDraft(overrides: Partial<Email> = {}): Email {
+  return {
+    id: 'e-1',
+    threadId: 't-1',
+    mailboxIds: { 'drafts-mb': true },
+    keywords: { $draft: true },
+    size: 1000,
+    receivedAt: '2026-08-01T10:00:00Z',
+    hasAttachment: false,
+    ...overrides,
+  };
+}
+
+describe('draftToComposeInit', () => {
+  it('maps recipients, subject and the html body', () => {
+    const init = draftToComposeInit(makeDraft({
+      to: [{ email: 'you@example.com', name: 'You' }],
+      cc: [{ email: 'cc@example.com' }],
+      bcc: [{ email: 'hidden@example.com' }],
+      subject: 'WIP',
+      htmlBody: [{ partId: 'html', type: 'text/html' }],
+      bodyValues: { html: { value: '<p>half-written</p>' } },
+    }));
+
+    expect(init.to).toEqual([{ email: 'you@example.com', name: 'You' }]);
+    expect(init.cc).toEqual([{ email: 'cc@example.com' }]);
+    expect(init.bcc).toEqual([{ email: 'hidden@example.com' }]);
+    expect(init.subject).toBe('WIP');
+    expect(init.bodyHtml).toBe('<p>half-written</p>');
+  });
+
+  it('escapes a text-only body into html', () => {
+    const init = draftToComposeInit(makeDraft({
+      textBody: [{ partId: 'text', type: 'text/plain' }],
+      bodyValues: { text: { value: 'line one\nwith <angle> & amp' } },
+    }));
+
+    expect(init.bodyHtml).toBe('line one<br>with &lt;angle&gt; &amp; amp');
+  });
+
+  it('strips dangerous tags from the stored html body', () => {
+    const init = draftToComposeInit(makeDraft({
+      htmlBody: [{ partId: 'html', type: 'text/html' }],
+      bodyValues: { html: { value: '<p>ok</p><script>alert(1)</script>' } },
+    }));
+
+    expect(init.bodyHtml).not.toContain('<script>');
+    expect(init.bodyHtml).toContain('<p>ok</p>');
+  });
+
+  it('classifies attachments and unwraps cid brackets', () => {
+    const init = draftToComposeInit(makeDraft({
+      attachments: [
+        { blobId: 'b-1', type: 'application/pdf', name: 'doc.pdf', size: 42, disposition: 'attachment' },
+        { blobId: 'b-2', type: 'image/png', name: 'pic.png', size: 7, disposition: 'inline', cid: '<img-1@local>' },
+      ],
+    }));
+
+    expect(init.attachments).toEqual([
+      { blobId: 'b-1', type: 'application/pdf', name: 'doc.pdf', size: 42, cid: undefined, inline: false },
+      { blobId: 'b-2', type: 'image/png', name: 'pic.png', size: 7, cid: 'img-1@local', inline: true },
+    ]);
+  });
+
+  it('keeps reply threading headers', () => {
+    const init = draftToComposeInit(makeDraft({
+      inReplyTo: ['<msg-1@example.com>'],
+      references: ['<msg-0@example.com>', '<msg-1@example.com>'],
+    }));
+
+    expect(init.inReplyTo).toBe('<msg-1@example.com>');
+    expect(init.references).toBe('<msg-0@example.com> <msg-1@example.com>');
+  });
+
+  it('defaults everything on an empty draft', () => {
+    const init = draftToComposeInit(makeDraft());
+
+    expect(init.to).toEqual([]);
+    expect(init.subject).toBe('');
+    expect(init.bodyHtml).toBe('');
+    expect(init.attachments).toEqual([]);
+  });
+});
+
+describe('rewriteCidSrcToDataUrls', () => {
+  it('swaps cid: srcs for data urls and stamps data-cid', () => {
+    const html = '<p>x</p><img alt="a" src="cid:img-1@local" width="10">';
+    const out = rewriteCidSrcToDataUrls(html, { 'img-1@local': 'data:image/png;base64,AA==' });
+
+    expect(out).toBe('<p>x</p><img alt="a" src="data:image/png;base64,AA==" data-cid="img-1@local" width="10">');
+  });
+
+  it('leaves images whose cid was not hydrated untouched', () => {
+    const html = '<img src="cid:missing@local">';
+    expect(rewriteCidSrcToDataUrls(html, {})).toBe(html);
+  });
+
+  it('is a no-op on html without cid references', () => {
+    const html = '<p>plain</p><img src="https://example.com/x.png">';
+    expect(rewriteCidSrcToDataUrls(html, { any: 'data:x' })).toBe(html);
+  });
+});
diff --git a/src/lib/draft-compose.ts b/src/lib/draft-compose.ts
new file mode 100644
index 0000000..3bebe83
--- /dev/null
+++ b/src/lib/draft-compose.ts
@@ -0,0 +1,84 @@
+// Map a fetched draft Email back into composer state so it can be re-edited.
+// JMAP emails are immutable apart from keywords/mailboxIds (RFC 8621 §4), so
+// the composer re-creates the draft on save/send and destroys the original;
+// attachments are reused by blobId without re-uploading.
+
+import type { Email, EmailAddress } from '../api/types';
+import { escapeHtml, stripDangerousTags } from './email-html';
+
+export interface DraftAttachmentInit {
+  blobId: string;
+  type: string;
+  name: string;
+  size: number;
+  cid?: string;
+  inline: boolean;
+}
+
+export interface DraftComposeInit {
+  to: EmailAddress[];
+  cc: EmailAddress[];
+  bcc: EmailAddress[];
+  subject: string;
+  bodyHtml: string;
+  attachments: DraftAttachmentInit[];
+  inReplyTo?: string;
+  references?: string;
+}
+
+function extractBody(email: Email, kind: 'htmlBody' | 'textBody'): string | null {
+  for (const part of email[kind] ?? []) {
+    const v = part.partId ? email.bodyValues?.[part.partId]?.value : undefined;
+    if (v) return v;
+  }
+  return null;
+}
+
+export function draftToComposeInit(email: Email): DraftComposeInit {
+  const html = extractBody(email, 'htmlBody');
+  const text = extractBody(email, 'textBody');
+  const bodyHtml = html
+    ? stripDangerousTags(html)
+    : escapeHtml(text ?? '').replace(/\n/g, '<br>');
+
+  const attachments: DraftAttachmentInit[] = (email.attachments ?? [])
+    .filter((a) => !!a.blobId)
+    .map((a) => ({
+      blobId: a.blobId,
+      type: a.type || 'application/octet-stream',
+      name: a.name ?? 'attachment',
+      size: a.size ?? 0,
+      cid: a.cid?.replace(/^<|>$/g, ''),
+      inline: a.disposition === 'inline' && !!a.cid,
+    }));
+
+  return {
+    to: email.to ?? [],
+    cc: email.cc ?? [],
+    bcc: email.bcc ?? [],
+    subject: email.subject ?? '',
+    bodyHtml,
+    attachments,
+    inReplyTo: email.inReplyTo?.[0],
+    references: email.references?.join(' '),
+  };
+}
+
+// Swap `src="cid:X"` references for fetched data: URLs and stamp the editor's
+// `data-cid` marker so `rewriteInlineImages` can turn them back into cid parts
+// at send time. Images whose cid is missing from the map are left untouched.
+export function rewriteCidSrcToDataUrls(
+  html: string,
+  dataUrlByCid: Record<string, string>,
+): string {
+  if (!html || !/src=("|')cid:/i.test(html)) return html;
+  return html.replace(
+    /<img\b([^>]*?)\ssrc=("cid:([^"]*)"|'cid:([^']*)')([^>]*)>/gi,
+    (full, before: string, _quoted: string, dq: string | undefined, sq: string | undefined, after: string) => {
+      const cid = (dq ?? sq ?? '').replace(/^<|>$/g, '');
+      const dataUrl = dataUrlByCid[cid];
+      if (!dataUrl) return full;
+      return `<img${before} src="${dataUrl}" data-cid="${cid}"${after}>`;
+    },
+  );
+}
diff --git a/src/navigation/types.ts b/src/navigation/types.ts
index 30f9e96..78544cd 100644
--- a/src/navigation/types.ts
+++ b/src/navigation/types.ts
@@ -18,6 +18,10 @@ export type RootStackParamList = {
           references?: string;
         };
         prefillTo?: EmailAddress[];
+        // Re-open an existing draft for editing. The composer loads the full
+        // message, prefills its fields, and replaces the original on save/send.
+        // Own-account drafts only: the composer can't write into a shared one.
+        draft?: { emailId: string };
       }
     | undefined;
   ContactDetail: { contactId: string };
diff --git a/src/screens/ComposeScreen.tsx b/src/screens/ComposeScreen.tsx
index d140139..bd9902f 100644
--- a/src/screens/ComposeScreen.tsx
+++ b/src/screens/ComposeScreen.tsx
@@ -35,10 +35,16 @@ import {
   matchesContactSearch,
 } from '../lib/contact-utils';
 import { getIdentities } from '../api/identity';
-import { sendEmail, type OutgoingAttachment } from '../api/email';
+import {
+  sendEmail, getFullEmail, destroyEmails, saveDraft as saveDraftApi,
+  type OutgoingAttachment,
+} from '../api/email';
 import { jmapClient } from '../api/jmap-client';
 import { uploadBlob } from '../api/blob';
 import { buildInitialHtml, htmlToPlainText, rewriteInlineImages } from '../lib/compose-html';
+import {
+  draftToComposeInit, rewriteCidSrcToDataUrls, type DraftComposeInit,
+} from '../lib/draft-compose';
 import { stripDangerousTags } from '../lib/email-html';
 import type { EmailAddress, Identity, ContactCard } from '../api/types';
 import type { RootStackParamList } from '../navigation/types';
@@ -83,6 +89,24 @@ function parseRecipients(input: string): Recipient[] {
     });
 }
 
+// Content fingerprint used to tell "opened a draft and closed it" apart from
+// real edits — only changed content should prompt on close.
+function snapshotDraftContent(
+  subject: string,
+  bodyPlain: string,
+  to: Recipient[],
+  cc: Recipient[],
+  attachments: AttachmentEntry[],
+): string {
+  return JSON.stringify({
+    subject: subject.trim(),
+    body: bodyPlain.trim(),
+    to: to.map((r) => r.email.toLowerCase()).sort(),
+    cc: cc.map((r) => r.email.toLowerCase()).sort(),
+    attachments: attachments.map((a) => a.blobId ?? a.localId).sort(),
+  });
+}
+
 function formatBytes(n: number): string {
   if (n < 1024) return `${n} B`;
   if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
@@ -97,6 +121,20 @@ function genLocalId(): string {
   return `${Date.now().toString(36)}.${Math.random().toString(36).slice(2, 8)}`;
 }
 
+// Same 2 MB ceiling and chunked base64 conversion as EmailBodyView's inline
+// image hydration — bigger cid parts stay as plain attachments.
+const MAX_INLINE_IMAGE_BYTES = 2 * 1024 * 1024;
+
+function arrayBufferToBase64(buffer: ArrayBuffer): string {
+  const bytes = new Uint8Array(buffer);
+  let binary = '';
+  const chunk = 0x8000;
+  for (let i = 0; i < bytes.length; i += chunk) {
+    binary += String.fromCharCode.apply(null, Array.from(bytes.subarray(i, i + chunk)));
+  }
+  return global.btoa ? global.btoa(binary) : btoa(binary);
+}
+
 async function readUriAsDataUrl(uri: string, mime: string): Promise<string | null> {
   try {
     const base64 = await FileSystem.readAsStringAsync(uri, {
@@ -263,17 +301,24 @@ export default function ComposeScreen({ route, navigation }: Props) {
   const replyTo = route.params?.replyTo;
   const mode = route.params?.mode ?? 'compose';
   const prefillTo = route.params?.prefillTo;
+  const draftParam = route.params?.draft;
   const mailboxes = useEmailStore((s) => s.mailboxes);
+  const refreshEmails = useEmailStore((s) => s.refreshEmails);
   // Always the user's own Sent — composing on behalf of a shared account
   // isn't supported, so a group account's Sent must never be picked up here.
   const sentMailbox = React.useMemo(
     () => ownMailboxes(mailboxes).find((m) => m.role === 'sent'),
     [mailboxes],
   );
+  const draftsMailbox = React.useMemo(
+    () => ownMailboxes(mailboxes).find((m) => m.role === 'drafts'),
+    [mailboxes],
+  );
 
   const [identities, setIdentities] = React.useState<Identity[]>([]);
   const [identityError, setIdentityError] = React.useState<string | null>(null);
   const [sending, setSending] = React.useState(false);
+  const [savingDraft, setSavingDraft] = React.useState(false);
   const [selectedIdentityId, setSelectedIdentityId] = React.useState<string | null>(null);
   const [identitySheetOpen, setIdentitySheetOpen] = React.useState(false);
   const [scheduleSheetOpen, setScheduleSheetOpen] = React.useState(false);
@@ -364,6 +409,82 @@ export default function ComposeScreen({ route, navigation }: Props) {
   // until send time. Maps cid → blobId/type/name/size.
   const inlineRegistryRef = React.useRef<Map<string, AttachmentEntry>>(new Map());
 
+  // ── Draft editing ────────────────────────────────────────────────────
+  // Loaded state of the draft being edited. The whole composer is gated on it
+  // (spinner until then) so the editor mounts with the draft body as its
+  // initial HTML instead of racing a later setHtml into the webview.
+  const [draftInit, setDraftInit] = React.useState<DraftComposeInit | null>(null);
+  const [draftLoadError, setDraftLoadError] = React.useState<string | null>(null);
+  const draftBaselineRef = React.useRef<string | null>(null);
+
+  React.useEffect(() => {
+    if (!draftParam) return;
+    let cancelled = false;
+    void (async () => {
+      try {
+        const full = await getFullEmail(draftParam.emailId);
+        const init = draftToComposeInit(full);
+
+        // Server-side blobs are reused as-is (uploading: false, no local uri).
+        // Inline cid images are hydrated to data: URLs so the editor shows
+        // them; when hydration fails they downgrade to plain attachments so
+        // the part is never silently dropped from the re-created message.
+        const dataUrlByCid: Record<string, string> = {};
+        const entries: AttachmentEntry[] = [];
+        for (const att of init.attachments) {
+          const entry: AttachmentEntry = {
+            localId: genLocalId(),
+            name: att.name,
+            type: att.type,
+            size: att.size,
+            uri: '',
+            inline: false,
+            blobId: att.blobId,
+            uploading: false,
+          };
+          if (att.inline && att.cid && att.size <= MAX_INLINE_IMAGE_BYTES) {
+            try {
+              const buf = await jmapClient.fetchBlobArrayBuffer(
+                att.blobId, att.name, att.type,
+              );
+              dataUrlByCid[att.cid] = `data:${att.type};base64,${arrayBufferToBase64(buf)}`;
+              entry.inline = true;
+              entry.cid = att.cid;
+              inlineRegistryRef.current.set(att.cid, entry);
+            } catch (err) {
+              console.warn('[compose] draft cid hydration failed', att.cid, err);
+            }
+          }
+          // A cid part that wasn't hydrated (too big, fetch failed) rides
+          // along as a regular chip but keeps its cid, so the body's
+          // untouched `src="cid:X"` still resolves for the recipient.
+          if (att.cid && !entry.inline) entry.cid = att.cid;
+          entries.push(entry);
+        }
+        if (cancelled) return;
+
+        const to = init.to.filter((r) => !!r.email).map((r) => ({ name: r.name ?? '', email: r.email }));
+        const cc = init.cc.filter((r) => !!r.email).map((r) => ({ name: r.name ?? '', email: r.email }));
+        setToRecipients(to);
+        setCcRecipients(cc);
+        if (cc.length > 0) setCcVisible(true);
+        setSubject(init.subject);
+        setAttachments(entries);
+        const body = rewriteCidSrcToDataUrls(init.bodyHtml, dataUrlByCid);
+        setBodyHtml(body);
+        draftBaselineRef.current = snapshotDraftContent(
+          init.subject, htmlToPlainText(body), to, cc, entries,
+        );
+        setDraftInit({ ...init, bodyHtml: body });
+      } catch (e) {
+        if (!cancelled) {
+          setDraftLoadError(e instanceof Error ? e.message : 'Failed to load draft');
+        }
+      }
+    })();
+    return () => { cancelled = true; };
+  }, [draftParam]);
+
   const allContacts = useContactsStore((s) => s.contacts);
   const individuals = React.useMemo(() => allContacts.filter((c) => !isGroup(c)), [allContacts]);
 
@@ -507,6 +628,7 @@ export default function ComposeScreen({ route, navigation }: Props) {
     || attachments.some((a) => a.blobId && !a.error);
   const canSend =
     !sending &&
+    !savingDraft &&
     !hasUploadInFlight &&
     !hasUploadError &&
     hasValidRecipients &&
@@ -515,29 +637,110 @@ export default function ComposeScreen({ route, navigation }: Props) {
     !!primaryIdentity &&
     !!sentMailbox;
 
-  const onClose = () => {
-    const isDirty =
-      bodyPlain.trim().length > 0
-      || subject.trim().length > 0
-      || toRecipients.length > 0
-      || ccRecipients.length > 0
-      || attachments.length > 0;
-    if (isDirty) {
+  const performSaveDraft = async () => {
+    if (!draftsMailbox) return;
+    if (hasUploadInFlight) {
       Alert.alert(
-        t('email_composer.discard_draft_title', 'Discard draft?'),
-        t('email_composer.discard_draft_confirm', 'You have unsaved changes. Do you want to discard this draft?'),
-        [
-          { text: t('email_composer.cancel', 'Cancel'), style: 'cancel' },
-          {
-            text: t('email_composer.discard', 'Discard'),
-            style: 'destructive',
-            onPress: () => navigation.goBack(),
-          },
-        ],
+        t('email_composer.save_draft_failed', 'Could not save draft'),
+        t('email_composer.uploads_in_flight', 'Wait for attachments to finish uploading.'),
+      );
+      return;
+    }
+    const liveBodyHtml = await readLiveBodyHtml();
+    if (liveBodyHtml === null) {
+      Alert.alert(
+        t('email_composer.save_draft_failed', 'Could not save draft'),
+        t(
+          'email_composer.editor_unavailable',
+          'Could not read the message content. Copy your text, then close and reopen the composer.',
+        ),
       );
       return;
     }
-    navigation.goBack();
+    setSavingDraft(true);
+    try {
+      const { finalHtml, finalText, outgoing } = buildOutgoingParts(liveBodyHtml);
+      const from: EmailAddress[] = primaryIdentity
+        ? [{ name: primaryIdentity.name, email: primaryIdentity.email }]
+        : [];
+      await saveDraftApi(
+        {
+          from,
+          to: finalTo.length
+            ? finalTo.map((r) => ({ name: r.name || undefined, email: r.email }))
+            : undefined,
+          cc: finalCc.length
+            ? finalCc.map((r) => ({ name: r.name || undefined, email: r.email }))
+            : undefined,
+          bcc: draftInit?.bcc.length ? draftInit.bcc : undefined,
+          subject,
+          htmlBody: plainTextMode ? undefined : finalHtml,
+          textBody: finalText,
+          attachments: outgoing.length ? outgoing : undefined,
+          inReplyTo: replyTo?.inReplyTo ?? draftInit?.inReplyTo,
+          references: replyTo?.references ?? draftInit?.references,
+        },
+        draftsMailbox.id,
+        draftParam?.emailId,
+      );
+      void refreshEmails();
+      navigation.goBack();
+    } catch (e) {
+      Alert.alert(
+        t('email_composer.save_draft_failed', 'Could not save draft'),
+        e instanceof Error ? e.message : 'Failed to save draft',
+      );
+    } finally {
+      setSavingDraft(false);
+    }
+  };
+
+  const onClose = () => { void handleCloseRequest(); };
+
+  const handleCloseRequest = async () => {
+    // Fingerprint the live editor DOM, not the async-fed `bodyHtml` state —
+    // text typed right before closing may not have reached the state yet and
+    // would otherwise be dropped without a prompt (issue #9's trap, at close
+    // time). An unresponsive editor counts as dirty for the same reason.
+    const live = await readLiveBodyHtml();
+    const livePlain = live === null ? null : htmlToPlainText(live);
+    // An edited draft is dirty only when its content changed; a fresh compose
+    // is dirty as soon as it has any content at all.
+    const isDirty = livePlain === null || (draftParam
+      ? draftBaselineRef.current !== null
+        && draftBaselineRef.current !== snapshotDraftContent(
+          subject, livePlain, toRecipients, ccRecipients, attachments,
+        )
+      : livePlain.trim().length > 0
+        || subject.trim().length > 0
+        || toRecipients.length > 0
+        || ccRecipients.length > 0
+        || attachments.length > 0);
+    if (!isDirty) {
+      navigation.goBack();
+      return;
+    }
+    const buttons: Parameters<typeof Alert.alert>[2] = [
+      { text: t('email_composer.cancel', 'Cancel'), style: 'cancel' },
+      {
+        text: t('email_composer.discard', 'Discard'),
+        style: 'destructive',
+        onPress: () => navigation.goBack(),
+      },
+    ];
+    // Discarding an edited draft keeps the original message untouched;
+    // saving replaces it. Without a drafts folder only discard is offered.
+    if (draftsMailbox) {
+      buttons.push({
+        text: t('email_composer.save_draft', 'Save draft'),
+        onPress: () => { void performSaveDraft(); },
+      });
+    }
+    Alert.alert(
+      t('email_composer.discard_draft_title', 'Discard draft?'),
+      t('email_composer.discard_draft_confirm', 'You have unsaved changes. Do you want to discard this draft?'),
+      buttons,
+    );
   };
 
   // ── Attachments ──────────────────────────────────────────────────────
@@ -879,18 +1082,64 @@ export default function ComposeScreen({ route, navigation }: Props) {
     }
   };
 
+  // Read the body straight from the editor DOM rather than trusting the
+  // async, best-effort `change` messages that feed `bodyHtml` — doing so once
+  // shipped replies with the typed text silently missing when the page script
+  // had died (issue #9). Every consumer of the body (send, save draft, the
+  // close-time dirty check) goes through this; null means the editor didn't
+  // answer and callers must fail safe instead of using stale content.
+  const readLiveBodyHtml = async (): Promise<string | null> => {
+    let live: string;
+    try {
+      live = (await editorRef.current?.getHtml()) ?? bodyHtml;
+    } catch {
+      return null;
+    }
+    if (live !== bodyHtml) setBodyHtml(live);
+    return live;
+  };
+
+  const buildOutgoingParts = (liveBodyHtml: string) => {
+    const { html: rewrittenHtml, usedCids } = rewriteInlineImages(liveBodyHtml);
+    // Belt-and-suspenders sanitization: the editor uses execCommand which
+    // can preserve pasted <script>/<style>/etc. Strip them before sending.
+    const safeHtml = stripDangerousTags(rewrittenHtml);
+    const finalHtml = `<div>${safeHtml}</div>`;
+    const finalText = htmlToPlainText(safeHtml);
+
+    const inlineFromBody = usedCids
+      .map((cid) => inlineRegistryRef.current.get(cid))
+      .filter((e): e is AttachmentEntry => !!e && !!e.blobId && !e.error)
+      .map<OutgoingAttachment>((e) => ({
+        blobId: e.blobId!,
+        type: e.type,
+        name: e.name,
+        size: e.size,
+        disposition: 'inline',
+        cid: e.cid,
+      }));
+
+    const fileAttachments = attachments
+      .filter((a) => !a.inline && a.blobId && !a.error)
+      .map<OutgoingAttachment>((a) => ({
+        blobId: a.blobId!,
+        type: a.type,
+        name: a.name,
+        size: a.size,
+        // A non-hydrated draft cid part stays inline so the body's cid: ref
+        // keeps resolving; anything else is a plain attachment.
+        disposition: a.cid ? 'inline' : 'attachment',
+        cid: a.cid,
+      }));
+
+    return { finalHtml, finalText, outgoing: [...inlineFromBody, ...fileAttachments] };
+  };
+
   const performSend = async (holdForSeconds?: number, scheduledAt?: Date) => {
     if (!canSend || !primaryIdentity || !sentMailbox) return;
 
-    // Read the body straight from the editor DOM at send time. The `change`
-    // messages that feed `bodyHtml` are async and best-effort — trusting them
-    // here once shipped replies with the typed text silently missing when the
-    // page script had died (issue #9). If the editor doesn't answer we abort
-    // loudly rather than send possibly-stale content.
-    let liveBodyHtml: string;
-    try {
-      liveBodyHtml = (await editorRef.current?.getHtml()) ?? bodyHtml;
-    } catch {
+    const liveBodyHtml = await readLiveBodyHtml();
+    if (liveBodyHtml === null) {
       Alert.alert(
         t('email_composer.send_failed', 'Send failed'),
         t(
@@ -900,43 +1149,12 @@ export default function ComposeScreen({ route, navigation }: Props) {
       );
       return;
     }
-    if (liveBodyHtml !== bodyHtml) setBodyHtml(liveBodyHtml);
 
     if (!(await passesAttachmentReminder(liveBodyHtml))) return;
     setSending(true);
     try {
       const from: EmailAddress[] = [{ name: primaryIdentity.name, email: primaryIdentity.email }];
-
-      const { html: rewrittenHtml, usedCids } = rewriteInlineImages(liveBodyHtml);
-      // Belt-and-suspenders sanitization: the editor uses execCommand which
-      // can preserve pasted <script>/<style>/etc. Strip them before sending.
-      const safeHtml = stripDangerousTags(rewrittenHtml);
-      const finalHtml = `<div>${safeHtml}</div>`;
-      const finalText = htmlToPlainText(safeHtml);
-
-      const inlineFromBody = usedCids
-        .map((cid) => inlineRegistryRef.current.get(cid))
-        .filter((e): e is AttachmentEntry => !!e && !!e.blobId && !e.error)
-        .map<OutgoingAttachment>((e) => ({
-          blobId: e.blobId!,
-          type: e.type,
-          name: e.name,
-          size: e.size,
-          disposition: 'inline',
-          cid: e.cid,
-        }));
-
-      const fileAttachments = attachments
-        .filter((a) => !a.inline && a.blobId && !a.error)
-        .map<OutgoingAttachment>((a) => ({
-          blobId: a.blobId!,
-          type: a.type,
-          name: a.name,
-          size: a.size,
-          disposition: 'attachment',
-        }));
-
-      const outgoing = [...inlineFromBody, ...fileAttachments];
+      const { finalHtml, finalText, outgoing } = buildOutgoingParts(liveBodyHtml);
 
       const result = await sendEmail(
         {
@@ -945,19 +1163,29 @@ export default function ComposeScreen({ route, navigation }: Props) {
           cc: finalCc.length
             ? finalCc.map((r) => ({ name: r.name || undefined, email: r.email }))
             : undefined,
+          // The composer has no Bcc field; carry an edited draft's Bcc
+          // through unchanged rather than silently dropping it.
+          bcc: draftInit?.bcc.length ? draftInit.bcc : undefined,
           subject,
           // Plain-text mode: skip the HTML part entirely so receiving clients
           // render the text/plain alternative without any formatting.
           htmlBody: plainTextMode ? undefined : finalHtml,
           textBody: finalText,
           attachments: outgoing.length ? outgoing : undefined,
-          inReplyTo: replyTo?.inReplyTo,
-          references: replyTo?.references,
+          inReplyTo: replyTo?.inReplyTo ?? draftInit?.inReplyTo,
+          references: replyTo?.references ?? draftInit?.references,
         },
         primaryIdentity.id,
         sentMailbox.id,
         holdForSeconds,
       );
+      // The message now lives in Sent (or Scheduled): retire the draft it was
+      // edited from. A failed destroy only leaves a stale copy behind.
+      if (draftParam) {
+        void destroyEmails([draftParam.emailId])
+          .then(() => refreshEmails())
+          .catch((err) => console.warn('[compose] failed to destroy edited draft', err));
+      }
       // Confirm an explicit "send later" so the user knows it didn't go out
       // now. The brief undo-send delay stays silent — it's meant to be
       // invisible unless the user cancels from the Scheduled view.
@@ -983,11 +1211,35 @@ export default function ComposeScreen({ route, navigation }: Props) {
   };
 
   const titleKey =
-    mode === 'forward' ? 'email_composer.forward'
+    draftParam ? 'email_composer.edit_draft'
+    : mode === 'forward' ? 'email_composer.forward'
     : mode === 'replyAll' ? 'email_composer.reply_all'
     : replyTo ? 'email_composer.reply'
     : 'email_composer.new_message';
 
+  // Gate the composer on the loaded draft so the editor mounts with the
+  // draft body as its initial HTML (see the draft-loading effect above).
+  if (draftParam && !draftInit) {
+    return (
+      <SafeAreaView style={styles.container} edges={['top']}>
+        <View style={styles.header}>
+          <Pressable onPress={() => navigation.goBack()} style={styles.headerBtn}>
+            <X size={22} color={c.text} />
+          </Pressable>
+          <Text style={styles.headerTitle}>
+            {t('email_composer.edit_draft', 'Edit draft')}
+          </Text>
+          <View style={styles.headerRight} />
+        </View>
+        {draftLoadError ? (
+          <Text style={styles.draftLoadError}>{draftLoadError}</Text>
+        ) : (
+          <ActivityIndicator style={styles.draftLoading} color={c.primary} />
+        )}
+      </SafeAreaView>
+    );
+  }
+
   return (
     <SafeAreaView style={styles.container} edges={['top']}>
       <View style={styles.header}>
@@ -995,7 +1247,7 @@ export default function ComposeScreen({ route, navigation }: Props) {
           <X size={22} color={c.text} />
         </Pressable>
         <Text style={styles.headerTitle}>
-          {t(titleKey, mode === 'forward' ? 'Forward' : mode === 'replyAll' ? 'Reply All' : replyTo ? 'Reply' : 'New Message')}
+          {t(titleKey, draftParam ? 'Edit draft' : mode === 'forward' ? 'Forward' : mode === 'replyAll' ? 'Reply All' : replyTo ? 'Reply' : 'New Message')}
         </Text>
         <View style={styles.headerRight}>
           <Pressable
@@ -1173,7 +1425,7 @@ export default function ComposeScreen({ route, navigation }: Props) {
 
           <RichTextEditor
             ref={editorRef}
-            initialHtml={initialBodyHtml}
+            initialHtml={draftInit ? draftInit.bodyHtml : initialBodyHtml}
             placeholder={t('email_composer.body_placeholder', 'Write your message...')}
             onChange={setBodyHtml}
             onSelectionChange={setSelState}
@@ -1415,6 +1667,13 @@ function makeStyles(c: ThemePalette) {
   headerTitle: { ...typography.h3, color: c.text, flex: 1 },
   headerRight: { flexDirection: 'row', alignItems: 'center', gap: spacing.sm },
   sendButtonDisabled: { opacity: 0.5 },
+  draftLoading: { marginTop: spacing.xl },
+  draftLoadError: {
+    ...typography.body,
+    color: c.error,
+    padding: spacing.lg,
+    textAlign: 'center',
+  },
 
   fieldRow: {
     flexDirection: 'row',
diff --git a/src/screens/EmailThreadScreen.tsx b/src/screens/EmailThreadScreen.tsx
index daa39a2..514043b 100644
--- a/src/screens/EmailThreadScreen.tsx
+++ b/src/screens/EmailThreadScreen.tsx
@@ -10,7 +10,7 @@ import {
   ArrowLeft, Star, Trash2, MoreVertical, Reply, ReplyAll, Forward,
   ChevronLeft, ChevronRight, Paperclip, Archive, Mail, MailOpen,
   FolderInput, ShieldAlert, ShieldCheck, X, Check,
-  Code, Download, Tag,
+  Code, Download, Tag, SquarePen,
 } from 'lucide-react-native';
 import { spacing, radius, typography, componentSizes, type ThemePalette } from '../theme/tokens';
 import { useColors } from '../theme/colors';
@@ -482,6 +482,20 @@ export default function EmailThreadScreen({ route, navigation }: Props) {
               />
             );
           })}
+          {/* Own drafts only: the composer can't save into or destroy from a
+              shared account (composing on behalf of one isn't supported). */}
+          {!!email?.keywords?.$draft && !ownerAccountId && (
+            <ToolbarButton
+              icon={<SquarePen size={18} color={c.textSecondary} />}
+              label="Edit"
+              onPress={() => {
+                if (!email) return;
+                navigation.navigate('Compose', {
+                  draft: { emailId: email.id },
+                });
+              }}
+            />
+          )}
           <ToolbarButton
             icon={<Trash2 size={18} color={c.textSecondary} />}
             label="Delete"