gogcli-mcp-gmail 2.21.1 → 2.23.0

package/tests/tools/gmail-extra.test.ts

@@ -96,7 +96,7 @@ describe('gog_gmail_attachment', () => {
     stubGog({ meta: PDF_LIST, download: { path: '/tmp/gog-attachments/m1/attachment', bytes: 99723, contentBase64: PDF_B64 } });
     const res = await call({});
     // download to the temp path first, then the metadata read to resolve the name.
-    expect(dlArgs()).toEqual(['gmail', 'attachment', 'm1', 'a1', '--inline', '--out=/tmp/gog-attachments/m1/attachment', '--name=attachment']);
+    expect(dlArgs()).toEqual(['gmail', 'attachment', 'm1', 'a1', '--use-indexed-attachment-ids=false', '--inline', '--inline-max-bytes=3145728', '--out=/tmp/gog-attachments/m1/attachment', '--name=attachment']);
     expect(gotGet()).toBe(true);
     const payload = JSON.parse(textOf(res));
     expect(payload).toMatchObject({
@@ -135,14 +135,14 @@ describe('gog_gmail_attachment', () => {
     stubGog({ download: { path: '/tmp/gog-attachments/m1/report.pdf', bytes: 12, contentBase64: PDF_B64 } });
     await call({ name: 'report.pdf' });
     expect(gotGet()).toBe(false);
-    expect(dlArgs()).toEqual(['gmail', 'attachment', 'm1', 'a1', '--inline', '--out=/tmp/gog-attachments/m1/report.pdf', '--name=report.pdf']);
+    expect(dlArgs()).toEqual(['gmail', 'attachment', 'm1', 'a1', '--use-indexed-attachment-ids=false', '--inline', '--inline-max-bytes=3145728', '--out=/tmp/gog-attachments/m1/report.pdf', '--name=report.pdf']);
   });
 
   it('a named non-image on the connector skips --inline (headed straight to Drive)', async () => {
     stubGog({ download: { path: '/tmp/gog-attachments/m1/report.pdf', bytes: 12 }, drive: { file: { id: 'F9' } } });
     await asConnector(() => call({ name: 'report.pdf' }));
     expect(gotGet()).toBe(false);
-    expect(dlArgs()).toEqual(['gmail', 'attachment', 'm1', 'a1', '--out=/tmp/gog-attachments/m1/report.pdf', '--name=report.pdf']);
+    expect(dlArgs()).toEqual(['gmail', 'attachment', 'm1', 'a1', '--use-indexed-attachment-ids=false', '--inline-max-bytes=3145728', '--out=/tmp/gog-attachments/m1/report.pdf', '--name=report.pdf']);
   });
 
   it('resolves the real filename by size and sanitizes path separators (no traversal)', async () => {
@@ -235,7 +235,7 @@ describe('gog_gmail_attachment', () => {
   it('deliver=drive skips --inline and uploads, honoring driveFolder and name', async () => {
     stubGog({ download: { path: '/tmp/gog-attachments/m1/renamed.png', bytes: 24 }, drive: { file: { id: 'F2', webViewLink: 'https://drive.google.com/file/d/F2/view' } } });
     const res = await call({ deliver: 'drive', driveFolder: 'DIR9', name: 'renamed.png', account: 'me@x.com' });
-    expect(dlArgs()).toEqual(['gmail', 'attachment', 'm1', 'a1', '--out=/tmp/gog-attachments/m1/renamed.png', '--name=renamed.png']);
+    expect(dlArgs()).toEqual(['gmail', 'attachment', 'm1', 'a1', '--use-indexed-attachment-ids=false', '--inline-max-bytes=3145728', '--out=/tmp/gog-attachments/m1/renamed.png', '--name=renamed.png']);
     expect(lib.run).toHaveBeenCalledWith(
       ['drive', 'upload', '/tmp/gog-attachments/m1/renamed.png', '--json', '--parent=DIR9', '--name=renamed.png'], { account: 'me@x.com' });
     expect(JSON.parse(textOf(res))).toMatchObject({ deliveredVia: 'drive', id: 'F2' });
@@ -268,14 +268,14 @@ describe('gog_gmail_attachment', () => {
   it('honors a caller out on stdio', async () => {
     stubGog({ download: { path: '/home/me/x.png', bytes: 24, contentBase64: PNG_B64 } });
     await call({ out: '/home/me/x.png', name: 'x.png' });
-    expect(dlArgs()).toEqual(['gmail', 'attachment', 'm1', 'a1', '--inline', '--out=/home/me/x.png', '--name=x.png']);
+    expect(dlArgs()).toEqual(['gmail', 'attachment', 'm1', 'a1', '--use-indexed-attachment-ids=false', '--inline', '--inline-max-bytes=3145728', '--out=/home/me/x.png', '--name=x.png']);
   });
 
   it('ignores a caller out on the connector and notes it', async () => {
     stubGog({ download: { path: '/tmp/gog-attachments/m1/report.pdf', bytes: 12 }, drive: { file: { id: 'F3' } } });
     const res = await asConnector(() => call({ out: '/home/claude/report.pdf', name: 'report.pdf' }));
     // download used the temp path, NOT the caller's /home/claude path.
-    expect(dlArgs()).toEqual(['gmail', 'attachment', 'm1', 'a1', '--out=/tmp/gog-attachments/m1/report.pdf', '--name=report.pdf']);
+    expect(dlArgs()).toEqual(['gmail', 'attachment', 'm1', 'a1', '--use-indexed-attachment-ids=false', '--inline-max-bytes=3145728', '--out=/tmp/gog-attachments/m1/report.pdf', '--name=report.pdf']);
     expect(textOf(res)).toContain('`out` was ignored');
   });
 
@@ -473,7 +473,7 @@ describe('gog_gmail_thread_get', () => {
   it('calls runOrDiagnose with threadId', async () => {
     await harness.callTool('gog_gmail_thread_get', { threadId: 't1' });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'thread', 'get', 't1'],
+      ['gmail', 'thread', 'get', 't1', '--use-indexed-attachment-ids=false'],
       { account: undefined },
     );
   });
@@ -487,7 +487,7 @@ describe('gog_gmail_thread_get', () => {
       outDir: '/tmp/atts',
     });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'thread', 'get', 't1', '--download', '--full', '--sanitize-content', '--out-dir=/tmp/atts'],
+      ['gmail', 'thread', 'get', 't1', '--download', '--full', '--sanitize-content', '--out-dir=/tmp/atts', '--use-indexed-attachment-ids=false'],
       { account: undefined },
     );
   });
@@ -500,7 +500,7 @@ describe('gog_gmail_thread_get', () => {
       sanitizeContent: false,
     });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'thread', 'get', 't1'],
+      ['gmail', 'thread', 'get', 't1', '--use-indexed-attachment-ids=false'],
       { account: undefined },
     );
   });
@@ -527,7 +527,7 @@ describe('gog_gmail_thread_get', () => {
     vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(THREAD));
     const result = await harness.callTool('gog_gmail_thread_get', { threadId: 't1', latestN: 2 });
     // latestN is wrapper-side; no CLI flag is added
-    expect(vi.mocked(lib.runOrDiagnose).mock.calls[0]![0]).toEqual(['gmail', 'thread', 'get', 't1']);
+    expect(vi.mocked(lib.runOrDiagnose).mock.calls[0]![0]).toEqual(['gmail', 'thread', 'get', 't1', '--use-indexed-attachment-ids=false']);
     const parsed = JSON.parse(result.content[0].text);
     expect(parsed.thread.messages.map((m: { id: string }) => m.id)).toEqual(['m2', 'm3']);
   });
@@ -598,7 +598,7 @@ describe('gog_gmail_thread_attachments', () => {
   it('calls runOrDiagnose with threadId', async () => {
     await harness.callTool('gog_gmail_thread_attachments', { threadId: 't1' });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'thread', 'attachments', 't1'],
+      ['gmail', 'thread', 'attachments', 't1', '--use-indexed-attachment-ids=false'],
       { account: undefined },
     );
   });
@@ -610,7 +610,7 @@ describe('gog_gmail_thread_attachments', () => {
       outDir: '/tmp/atts',
     });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'thread', 'attachments', 't1', '--download', '--out-dir=/tmp/atts'],
+      ['gmail', 'thread', 'attachments', 't1', '--download', '--out-dir=/tmp/atts', '--use-indexed-attachment-ids=false'],
       { account: undefined },
     );
   });
@@ -714,11 +714,509 @@ describe('gog_gmail_drafts_list', () => {
   });
 });
 
+// ===========================================================================
+// REQUIREMENT 2 — the listing must say where each draft came from and whether
+// sending it would start a NEW conversation, and TIER 0 MUST COST NOTHING.
+//
+// Hazard B (N+1) is enforced here by assertion, not by intention: the argv has
+// to stay byte-identical to today's and `run` must never be touched. A 20-draft
+// listing that quietly became 20 gog spawns on the one shared Fly machine is the
+// regression these tests exist to make impossible.
+// ===========================================================================
+describe('gog_gmail_drafts_list — tier 0 origin and threading', () => {
+  const LIST = JSON.stringify({
+    drafts: [
+      // API-created reply: sits inside the co-parent's thread.
+      { id: 'r4303011157206680397', messageId: '19f856becba0661d', threadId: '19f856b0000thread' },
+      // The Apple Mail replacement: non-API id, roots its own thread.
+      { id: 's:14092347734530621658', messageId: '19fe8a673d1e5f21', threadId: '19fe8a673d1e5f21' },
+      // Draft ids can be NEGATIVE and still be plain API drafts.
+      { id: 'r-457330811034304502', messageId: 'aaa', threadId: 'bbb' },
+    ],
+    nextPageToken: 'next-tok',
+  });
+
+  it('adds origin and rootsOwnThread without spending a single extra gog call', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(LIST));
+    const result = await harness.callTool('gog_gmail_drafts_list', {});
+
+    // Hazard B: exactly one invocation, and the argv is what it always was.
+    expect(vi.mocked(lib.runOrDiagnose).mock.calls).toHaveLength(1);
+    expect(vi.mocked(lib.runOrDiagnose).mock.calls[0]![0]).toEqual(['gmail', 'drafts', 'list']);
+    expect(lib.run).not.toHaveBeenCalled();
+
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.drafts.map((d: { id: string; origin: string; rootsOwnThread: boolean }) => [d.id, d.origin, d.rootsOwnThread])).toEqual([
+      ['r4303011157206680397', 'api', false],
+      ['s:14092347734530621658', 'non-api', true],
+      ['r-457330811034304502', 'api', false],
+    ]);
+    // Additive only: gog's own fields survive untouched.
+    expect(parsed.drafts[0].messageId).toBe('19f856becba0661d');
+    expect(parsed.nextPageToken).toBe('next-tok');
+  });
+
+  it('never labels a draft apple-mail from the listing alone', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(LIST));
+    const result = await harness.callTool('gog_gmail_drafts_list', {});
+    // Hazard A: an `s:` prefix means IMAP/sync — Thunderbird and Outlook produce
+    // it too. Claiming "apple-mail" here would be a free false positive.
+    expect(JSON.parse(result.content[0].text).drafts[1].origin).toBe('non-api');
+    expect(result.content[0].text).not.toContain('apple-mail');
+  });
+
+  it('explains rootsOwnThread as the consequence the caller cares about', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(LIST));
+    const parsed = JSON.parse((await harness.callTool('gog_gmail_drafts_list', {})).content[0].text);
+    // Emitted ONCE for the whole result and selected by the per-row boolean —
+    // it is one of exactly two constants, so a copy per row was ~300 chars of
+    // duplicated text carrying no extra information.
+    expect(parsed.threadingNotes.rootsOwnThread).toContain('NEW conversation');
+    expect(parsed.threadingNotes.inThread).toContain('existing thread');
+    expect(parsed.drafts[1].rootsOwnThread).toBe(true);
+    expect(parsed.drafts[0].rootsOwnThread).toBe(false);
+    // The `non-api` != Apple caveat and the measured coin-flip figure ride along once.
+    expect(parsed.originNote).toContain('non-api');
+    expect(parsed.originNote).toContain('0.50');
+  });
+
+  it('passes non-JSON output through untouched', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult('No drafts'));
+    const result = await harness.callTool('gog_gmail_drafts_list', {});
+    expect(result.content[0].text).toBe('No drafts');
+  });
+
+  it('passes JSON without a drafts array through untouched', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult('{"error":"nope"}'));
+    const result = await harness.callTool('gog_gmail_drafts_list', {});
+    expect(result.content[0].text).toBe('{"error":"nope"}');
+  });
+
+  it('passes a non-text result through untouched', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce({ content: [{ type: 'image', data: 'AAAA', mimeType: 'image/png' }] });
+    const result = await harness.callTool('gog_gmail_drafts_list', {});
+    expect(result.content[0].type).toBe('image');
+  });
+});
+
+describe('gog_gmail_drafts_list — tier 1 enrich', () => {
+  const LIST = JSON.stringify({
+    drafts: [
+      { id: 'r1', messageId: 'm1', threadId: 't1' },
+      { id: 's:2', messageId: 'm2', threadId: 'm2' },
+    ],
+    nextPageToken: '',
+  });
+  const SEARCH = JSON.stringify({
+    messages: [
+      { id: 'm1', threadId: 't1', from: 'Chris <chris@x.com>', subject: 'Re: August schedule', internalDateIso: '2026-08-09T10:00:00-04:00' },
+    ],
+    nextPageToken: '',
+  });
+
+  it('is off by default — no enrichment fields and no second call', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(LIST));
+    const parsed = JSON.parse((await harness.callTool('gog_gmail_drafts_list', {})).content[0].text);
+    expect(lib.run).not.toHaveBeenCalled();
+    expect(parsed.enrichment).toBeUndefined();
+    expect(parsed.drafts[0].subject).toBeUndefined();
+  });
+
+  it('spends exactly one extra gog call and joins on messageId', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(LIST));
+    vi.mocked(lib.run).mockResolvedValueOnce(SEARCH);
+    const parsed = JSON.parse((await harness.callTool('gog_gmail_drafts_list', { enrich: true })).content[0].text);
+
+    expect(vi.mocked(lib.run).mock.calls).toHaveLength(1);
+    expect(vi.mocked(lib.run).mock.calls[0]![0]).toEqual([
+      'gmail', 'messages', 'search', 'in:drafts', '--max=20',
+      '--include-attachments=false', '--use-indexed-attachment-ids=false',
+    ]);
+    expect(parsed.drafts[0]).toMatchObject({
+      id: 'r1', origin: 'api', subject: 'Re: August schedule', from: 'Chris <chris@x.com>', internalDateIso: '2026-08-09T10:00:00-04:00',
+    });
+    // The unjoined draft keeps its tier-0 fields and gains nothing else.
+    expect(parsed.drafts[1].subject).toBeUndefined();
+    expect(parsed.drafts[1].origin).toBe('non-api');
+    expect(parsed.enrichment).toMatchObject({ requested: true, applied: true, extraGogCalls: 1, matched: 1, unmatched: 1 });
+  });
+
+  it('mirrors max and --all onto the enrichment search', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(LIST));
+    vi.mocked(lib.run).mockResolvedValueOnce(SEARCH);
+    await harness.callTool('gog_gmail_drafts_list', { enrich: true, max: 50, all: true, account: 'a@b.com' });
+    expect(vi.mocked(lib.run).mock.calls[0]![0]).toEqual([
+      'gmail', 'messages', 'search', 'in:drafts', '--max=50', '--all',
+      '--include-attachments=false', '--use-indexed-attachment-ids=false',
+    ]);
+    expect(vi.mocked(lib.run).mock.calls[0]![1]).toEqual({ account: 'a@b.com' });
+  });
+
+  it('degrades to tier 0 instead of erroring when the search fails', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(LIST));
+    vi.mocked(lib.run).mockRejectedValueOnce(new Error('gog exploded'));
+    const result = await harness.callTool('gog_gmail_drafts_list', { enrich: true });
+    const parsed = JSON.parse(result.content[0].text);
+    expect(result.isError).toBeFalsy();
+    expect(parsed.drafts[0].origin).toBe('api'); // tier 0 survives
+    expect(parsed.enrichment).toMatchObject({ requested: true, applied: false, extraGogCalls: 1 });
+    expect(parsed.enrichment.reason).toContain('gog exploded');
+  });
+
+  it('degrades to tier 0 when the search output is not JSON at all', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(LIST));
+    vi.mocked(lib.run).mockResolvedValueOnce('not json at all');
+    const parsed = JSON.parse((await harness.callTool('gog_gmail_drafts_list', { enrich: true })).content[0].text);
+    expect(parsed.enrichment.applied).toBe(false);
+    expect(parsed.drafts[0].rootsOwnThread).toBe(false);
+  });
+
+  it('degrades to tier 0 when the search output is JSON without a messages array', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(LIST));
+    vi.mocked(lib.run).mockResolvedValueOnce('{"error":"quota"}');
+    const parsed = JSON.parse((await harness.callTool('gog_gmail_drafts_list', { enrich: true })).content[0].text);
+    expect(parsed.enrichment.applied).toBe(false);
+    expect(parsed.enrichment.reason).toContain('no messages array');
+    expect(parsed.drafts[1].origin).toBe('non-api');
+  });
+
+  it('skips messages with no id when joining', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(LIST));
+    vi.mocked(lib.run).mockResolvedValueOnce(JSON.stringify({ messages: [{ subject: 'orphan' }] }));
+    const parsed = JSON.parse((await harness.callTool('gog_gmail_drafts_list', { enrich: true })).content[0].text);
+    expect(parsed.enrichment).toMatchObject({ applied: true, matched: 0, unmatched: 2 });
+  });
+
+  it('does not spend the enrichment call when the listing is unparseable', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult('No drafts'));
+    const result = await harness.callTool('gog_gmail_drafts_list', { enrich: true });
+    expect(lib.run).not.toHaveBeenCalled();
+    expect(result.content[0].text).toBe('No drafts');
+  });
+
+  it('tolerates a draft entry with no id', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(JSON.stringify({ drafts: [{ messageId: 'm9', threadId: 'm9' }] })));
+    const parsed = JSON.parse((await harness.callTool('gog_gmail_drafts_list', {})).content[0].text);
+    expect(parsed.drafts[0].origin).toBe('api');
+    expect(parsed.drafts[0].rootsOwnThread).toBe(true);
+  });
+});
+
+// ===========================================================================
+// REQUIREMENT 3 — gog_gmail_drafts_diff.
+//
+// Two named drafts, two gog spawns, never a scan. It answers the question the
+// owner actually has in front of a fork: WHAT diverged, WHAT threading was
+// lost, and — separately and conservatively — whether one plausibly replaced
+// the other.
+// ===========================================================================
+describe('gog_gmail_drafts_diff', () => {
+  const b64 = (s: string) => Buffer.from(s, 'utf8').toString('base64url');
+
+  function draftGetJson(o: {
+    draftId: string; messageId: string; threadId: string; internalDate: string;
+    headers: Array<{ name: string; value: string }>; body: string;
+  }): string {
+    return JSON.stringify({
+      draft: {
+        id: o.draftId,
+        message: {
+          id: o.messageId,
+          threadId: o.threadId,
+          internalDate: o.internalDate,
+          payload: { mimeType: 'text/plain', headers: o.headers, body: { data: b64(o.body) } },
+        },
+      },
+    });
+  }
+
+  // The observed case: an API-created reply threaded onto the co-parent's
+  // message, and the Apple Mail replacement that dropped a paragraph, added a
+  // sentence, and landed on its own thread.
+  const ORIGINAL = draftGetJson({
+    draftId: 'r4303011157206680397',
+    messageId: '19f856becba0661d',
+    threadId: '19f856b0000thread',
+    internalDate: '1000',
+    headers: [
+      { name: 'From', value: 'Chris Hall <chris@x.com>' },
+      { name: 'To', value: 'coparent@y.com' },
+      { name: 'Cc', value: 'coordinator@pc.com' },
+      { name: 'Subject', value: 'Re: August schedule' },
+      { name: 'Message-Id', value: '<orig@mail.gmail.com>' },
+      { name: 'In-Reply-To', value: '<coparent@mail.gmail.com>' },
+      { name: 'References', value: '<coparent@mail.gmail.com>' },
+      { name: 'MIME-Version', value: '1.0' },
+    ],
+    body: 'Thanks for the note.\nI can do the 14th.\nPickup at six.\nTHE PARAGRAPH ONLY GMAIL HAS.\nBest, Chris',
+  });
+  const APPLE_FORK = draftGetJson({
+    draftId: 's:14092347734530621658',
+    messageId: '19fe8a673d1e5f21',
+    threadId: '19fe8a673d1e5f21',
+    internalDate: '2000',
+    headers: [
+      { name: 'From', value: 'chris@x.com' },
+      { name: 'To', value: 'coparent@y.com' },
+      { name: 'Subject', value: 'Re: August schedule' },
+      { name: 'Message-Id', value: '<8F3C1B0A-1111-2222-3333-AABBCCDDEEFF@gmail.com>' },
+      { name: 'Mime-Version', value: '1.0 (1.0)' },
+      { name: 'X-Universally-Unique-Identifier', value: '8F3C1B0A-1111-2222-3333-AABBCCDDEEFF' },
+      { name: 'X-Apple-Notify-Thread', value: 'yes' },
+    ],
+    body: 'Thanks for the note.\nI can do the 14th.\nPickup at six.\nBest, Chris\nTHE SENTENCE ONLY APPLE HAS.',
+  });
+
+  function stub(map: Record<string, string>): void {
+    vi.mocked(lib.run).mockImplementation(async (args) => {
+      const id = (args as string[])[3]!;
+      const payload = map[id];
+      if (payload === undefined) throw new Error(`Google API error (404 notFound): ${id}`);
+      return payload;
+    });
+  }
+
+  const call = (extra: Record<string, unknown> = {}) => harness.callTool('gog_gmail_drafts_diff', {
+    draftIdA: 'r4303011157206680397', draftIdB: 's:14092347734530621658', ...extra,
+  });
+
+  it('costs exactly two gog calls, one per named draft', async () => {
+    stub({ 'r4303011157206680397': ORIGINAL, 's:14092347734530621658': APPLE_FORK });
+    await call();
+    expect(vi.mocked(lib.run).mock.calls).toHaveLength(2);
+    expect(vi.mocked(lib.run).mock.calls[0]![0]).toEqual(['gmail', 'drafts', 'get', 'r4303011157206680397', '--use-indexed-attachment-ids=false']);
+    expect(vi.mocked(lib.run).mock.calls[1]![0]).toEqual(['gmail', 'drafts', 'get', 's:14092347734530621658', '--use-indexed-attachment-ids=false']);
+    expect(lib.runOrDiagnose).not.toHaveBeenCalled();
+  });
+
+  it('shows what each copy alone would lose', async () => {
+    stub({ 'r4303011157206680397': ORIGINAL, 's:14092347734530621658': APPLE_FORK });
+    const parsed = JSON.parse((await call()).content[0].text);
+    expect(parsed.bodyDiff.onlyInA).toEqual(['THE PARAGRAPH ONLY GMAIL HAS.']);
+    expect(parsed.bodyDiff.onlyInB).toEqual(['THE SENTENCE ONLY APPLE HAS.']);
+    expect(parsed.bodyDiff.sharedLineCount).toBe(4);
+    expect(parsed.bodyDiff.neitherIsSuperset).toBe(true);
+    expect(parsed.bodyDiff.note).toContain('NEITHER');
+  });
+
+  it('names the threading that would be lost by sending the fork', async () => {
+    stub({ 'r4303011157206680397': ORIGINAL, 's:14092347734530621658': APPLE_FORK });
+    const parsed = JSON.parse((await call()).content[0].text);
+    expect(parsed.drafts.a).toMatchObject({ origin: 'api', rootsOwnThread: false, inReplyTo: '<coparent@mail.gmail.com>' });
+    expect(parsed.drafts.b).toMatchObject({ origin: 'non-api', rootsOwnThread: true });
+    expect(parsed.drafts.b.inReplyTo).toBeUndefined();
+    expect(parsed.drafts.b.appleIdentitySignals).toEqual([
+      'X-Universally-Unique-Identifier: 8F3C1B0A-1111-2222-3333-AABBCCDDEEFF',
+      'X-Apple-Notify-Thread: yes',
+    ]);
+    expect(parsed.threadingDifferences.join(' ')).toContain('different threadIds');
+    expect(parsed.threadingDifferences.join(' ')).toContain('reply headers');
+  });
+
+  it('confirms the pairing only with an Apple identity header plus real lineage', async () => {
+    stub({ 'r4303011157206680397': ORIGINAL, 's:14092347734530621658': APPLE_FORK });
+    const parsed = JSON.parse((await call()).content[0].text);
+    expect(parsed.forkPairing.verdict).toBe('confirmed');
+    expect(parsed.forkPairing.tier).toBe(2);
+    expect(parsed.forkPairing.originalDraftId).toBe('r4303011157206680397');
+    expect(parsed.forkPairing.candidateDraftId).toBe('s:14092347734530621658');
+    expect(parsed.forkPairing.evidence.join(' ')).toContain('body line similarity');
+  });
+
+  // ---- HAZARD A: the test that matters most. ----
+  it('returns "none" for two unrelated drafts that share every cheap signal', async () => {
+    // Both non-API, both rooting their own thread, both Apple-authored, same
+    // From, same subject, minutes apart — the live mailbox really does hold
+    // deliberate [VERSION A]/[VERSION B] pairs like this. Only LINEAGE is
+    // missing, and without it the answer must be "unrelated".
+    const common = {
+      threadId: 'self', internalDate: '1000',
+      headers: [
+        { name: 'From', value: 'chris@x.com' },
+        { name: 'Subject', value: 'Re: August schedule' },
+        { name: 'X-Universally-Unique-Identifier', value: 'AAAA-1111' },
+      ],
+    };
+    const A = draftGetJson({ ...common, draftId: 's:aaa', messageId: 'self', body: '[VERSION A] I would prefer the 14th and a six oclock pickup.' });
+    const B = draftGetJson({
+      ...common, draftId: 's:bbb', messageId: 'self2', internalDate: '1180',
+      headers: [...common.headers, { name: 'X-Apple-Notify-Thread', value: 'yes' }],
+      body: '[VERSION B] Let us keep the current arrangement through September.',
+    });
+    stub({ 's:aaa': A, 's:bbb': B });
+    const result = await harness.callTool('gog_gmail_drafts_diff', { draftIdA: 's:aaa', draftIdB: 's:bbb' });
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.forkPairing.verdict).toBe('none');
+    expect(parsed.forkPairing.missing.join(' ')).toContain('no lineage signal');
+    // Nothing in the payload may read as an assertion that one replaced the other.
+    expect(result.content[0].text).not.toContain('replaced draft');
+  });
+
+  // The default shape of a co-parenting mailbox: two drafts replying into the
+  // SAME co-parent message, about different things. Shared root, Apple
+  // headers, newer, same From — everything but a link from one to the other.
+  it('returns "none" for two independent replies to the same co-parent message', async () => {
+    const handoff = draftGetJson({
+      draftId: 'r4303011157206680397', messageId: 'm1', threadId: 't1', internalDate: '1000',
+      headers: [
+        { name: 'From', value: 'Chris Hall <chris@x.com>' },
+        { name: 'Message-Id', value: '<orig@mail.gmail.com>' },
+        { name: 'In-Reply-To', value: '<coparent-2026-05-01@mail.gmail.com>' },
+        { name: 'References', value: '<coparent-2026-05-01@mail.gmail.com>' },
+      ],
+      body: 'Confirming the July handoff at six on the 14th.\nI will bring the booster seat.',
+    });
+    const orthodontist = draftGetJson({
+      draftId: 's:14092347734530621658', messageId: 'm2', threadId: 't1', internalDate: '2000',
+      headers: [
+        { name: 'From', value: 'chris@x.com' },
+        { name: 'Message-Id', value: '<9F3A@gmail.com>' },
+        { name: 'In-Reply-To', value: '<coparent-2026-05-01@mail.gmail.com>' },
+        { name: 'References', value: '<coparent-2026-05-01@mail.gmail.com>' },
+        { name: 'X-Universally-Unique-Identifier', value: '9F3A' },
+      ],
+      body: 'The orthodontist invoice came to 240 dollars.\nI am splitting it per the parenting plan.',
+    });
+    stub({ 'r4303011157206680397': handoff, 's:14092347734530621658': orthodontist });
+    const result = await call();
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.forkPairing.verdict).not.toBe('confirmed');
+    expect(result.content[0].text).not.toContain('replaced draft');
+    expect(parsed.forkPairing.evidence.join(' ')).toContain('CORROBORATING ONLY');
+    expect(parsed.forkPairing.missing.join(' ')).toContain('no lineage signal');
+    expect(parsed.forkPairing.bodyAgreement.similarity).toBe(0);
+  });
+
+  // Apple quotes the original on reply, so two unrelated replies into one
+  // thread share a big identical block. It must not read as agreement.
+  it('ignores the quoted block shared by two unrelated replies', async () => {
+    const quote = Array.from({ length: 20 }, (_, i) => `> quoted line ${i}`).join('\n');
+    const attribution = 'On 1 May 2026, at 09:14, Co Parent <co@x.com> wrote:';
+    const mk = (id: string, msgId: string, date: string, body: string, extra: Array<{ name: string; value: string }>) => draftGetJson({
+      draftId: id, messageId: msgId, threadId: msgId, internalDate: date,
+      headers: [{ name: 'From', value: 'chris@x.com' }, ...extra],
+      body: `${body}\n${attribution}\n${quote}`,
+    });
+    stub({
+      r1: mk('r1', 'm1', '1000', 'Tuition is due on the 5th.\nI paid the deposit already.', []),
+      's:2': mk('s:2', 'm2', '2000', 'The passport renewal needs both signatures.\nI booked the 3rd.', [{ name: 'X-Apple-Notify-Thread', value: 'yes' }]),
+    });
+    const parsed = JSON.parse((await harness.callTool('gog_gmail_drafts_diff', { draftIdA: 'r1', draftIdB: 's:2' })).content[0].text);
+    expect(parsed.forkPairing.verdict).toBe('none');
+    expect(parsed.forkPairing.bodyAgreement.similarity).toBe(0);
+    expect(parsed.forkPairing.bodyAgreement.quotedLinesIgnored).toEqual({ original: 21, candidate: 21 });
+    // The whole-body diff still shows the quoted block as shared — that is a
+    // different question (what would be lost), and it stays honest.
+    expect(parsed.bodyDiff.sharedLineCount).toBe(21);
+  });
+
+  it('downgrades to "candidate" when lineage exists but the candidate is not newer', async () => {
+    const older = draftGetJson({
+      draftId: 's:old', messageId: 'x1', threadId: 'x1', internalDate: '500',
+      headers: [{ name: 'From', value: 'chris@x.com' }, { name: 'X-Apple-Notify-Thread', value: 'yes' }],
+      body: 'Thanks for the note.\nI can do the 14th.\nPickup at six.\nBest, Chris',
+    });
+    stub({ 'r4303011157206680397': ORIGINAL, 's:old': older });
+    const parsed = JSON.parse((await harness.callTool('gog_gmail_drafts_diff', { draftIdA: 'r4303011157206680397', draftIdB: 's:old' })).content[0].text);
+    // Draft B is older, so it is treated as the ORIGINAL and A as the candidate.
+    expect(parsed.forkPairing.originalDraftId).toBe('s:old');
+    expect(parsed.forkPairing.candidateDraftId).toBe('r4303011157206680397');
+    expect(parsed.forkPairing.verdict).toBe('candidate');
+    expect(parsed.forkPairing.note).toContain('Unconfirmed');
+  });
+
+  it('reports identical bodies and no threading difference', async () => {
+    const same = (id: string) => draftGetJson({
+      draftId: id, messageId: 'same', threadId: 'thr', internalDate: '1000',
+      headers: [{ name: 'From', value: 'chris@x.com' }, { name: 'In-Reply-To', value: '<z@y>' }],
+      body: 'one\ntwo',
+    });
+    stub({ 'r1': same('r1'), 'r2': same('r2') });
+    const parsed = JSON.parse((await harness.callTool('gog_gmail_drafts_diff', { draftIdA: 'r1', draftIdB: 'r2' })).content[0].text);
+    expect(parsed.bodyDiff.note).toContain('identical');
+    expect(parsed.threadingDifferences).toEqual(['No threading difference: the two drafts share a threadId and agree on whether they carry reply headers.']);
+  });
+
+  it('names a one-sided superset in each direction', async () => {
+    const short = draftGetJson({ draftId: 'r1', messageId: 'm', threadId: 'm', internalDate: '1', headers: [], body: 'one\ntwo' });
+    const long = draftGetJson({ draftId: 'r2', messageId: 'm', threadId: 'm', internalDate: '2', headers: [], body: 'one\ntwo\nthree' });
+    stub({ 'r1': short, 'r2': long });
+    expect(JSON.parse((await harness.callTool('gog_gmail_drafts_diff', { draftIdA: 'r1', draftIdB: 'r2' })).content[0].text).bodyDiff.note)
+      .toContain('Draft B is a superset');
+    stub({ 'r3': long, 'r4': short });
+    expect(JSON.parse((await harness.callTool('gog_gmail_drafts_diff', { draftIdA: 'r3', draftIdB: 'r4' })).content[0].text).bodyDiff.note)
+      .toContain('Draft A is a superset');
+  });
+
+  it('makes no containment claim when one draft’s body could not be read', async () => {
+    const empty = JSON.stringify({
+      draft: { id: 'r1', message: { id: 'm1', threadId: 'm1', internalDate: '1', payload: { mimeType: 'application/octet-stream', headers: [], body: {} } } },
+    });
+    const full = draftGetJson({ draftId: 'r2', messageId: 'm2', threadId: 'm2', internalDate: '2', headers: [], body: 'one\ntwo' });
+    stub({ r1: empty, r2: full });
+    const parsed = JSON.parse((await harness.callTool('gog_gmail_drafts_diff', { draftIdA: 'r1', draftIdB: 'r2' })).content[0].text);
+    expect(parsed.bodyDiff.comparability).toBe('a-unreadable');
+    expect(parsed.bodyDiff.supersetClaim).toBe('not-assessed');
+    expect(parsed.bodyDiff.neitherIsSuperset).toBeNull();
+    expect(parsed.bodyDiff.note).not.toMatch(/superset/i);
+    expect(parsed.drafts.a.bodyLineCount).toBe(0);
+  });
+
+  it('caps the reported diff lines and says so', async () => {
+    const many = (n: number, tag: string) => Array.from({ length: n }, (_, i) => `${tag}-${i}`).join('\n');
+    stub({
+      'r1': draftGetJson({ draftId: 'r1', messageId: 'm', threadId: 'm', internalDate: '1', headers: [], body: many(5, 'a') }),
+      'r2': draftGetJson({ draftId: 'r2', messageId: 'm', threadId: 'm', internalDate: '2', headers: [], body: many(5, 'b') }),
+    });
+    const parsed = JSON.parse((await harness.callTool('gog_gmail_drafts_diff', { draftIdA: 'r1', draftIdB: 'r2', maxDiffLines: 2 })).content[0].text);
+    expect(parsed.bodyDiff.onlyInA).toHaveLength(2);
+    expect(parsed.bodyDiff.onlyInB).toHaveLength(2);
+    expect(parsed.bodyDiff.truncated).toBe(true);
+    expect(parsed.bodyDiff.note).toContain('truncated');
+  });
+
+  it('reports threading differences when one side has no threadId, in both directions', async () => {
+    const noThread = JSON.stringify({
+      draft: { id: 'x', message: { id: 'm1', internalDate: '1', payload: { mimeType: 'text/plain', headers: [], body: { data: b64('x') } } } },
+    });
+    const threaded = draftGetJson({
+      draftId: 'r2', messageId: 'm2', threadId: 'thr', internalDate: '2',
+      headers: [{ name: 'References', value: '<z@y>' }], body: 'y',
+    });
+    // A has no threadId and no reply headers; B has both.
+    stub({ r1: noThread, r2: threaded });
+    const first = JSON.parse((await harness.callTool('gog_gmail_drafts_diff', { draftIdA: 'r1', draftIdB: 'r2' })).content[0].text);
+    expect(first.threadingDifferences[0]).toContain('((none) vs thr)');
+    expect(first.threadingDifferences[1]).toContain('Draft r2 carries reply headers');
+    expect(first.threadingDifferences[1]).toContain('draft r1 does not');
+    // Mirror image: now it is B that has no threadId.
+    stub({ r3: threaded, r4: noThread });
+    const second = JSON.parse((await harness.callTool('gog_gmail_drafts_diff', { draftIdA: 'r3', draftIdB: 'r4' })).content[0].text);
+    expect(second.threadingDifferences[0]).toContain('(thr vs (none))');
+  });
+
+  it('diagnoses a draft id that no longer resolves, spending only the calls it made', async () => {
+    stub({ 'r4303011157206680397': ORIGINAL });
+    const result = await call();
+    expect(vi.mocked(lib.run).mock.calls).toHaveLength(2);
+    expect(lib.diagnose).toHaveBeenCalled();
+    expect(String(vi.mocked(lib.diagnose).mock.calls[0]![0])).toContain('s:14092347734530621658');
+    expect(result.content[0].text).toBe('diagnosed');
+  });
+
+  it('errors clearly when either draft payload is unreadable', async () => {
+    stub({ 'r4303011157206680397': 'not json', 's:14092347734530621658': APPLE_FORK });
+    expect((await call()).content[0].text).toContain('r4303011157206680397');
+    stub({ 'r4303011157206680397': ORIGINAL, 's:14092347734530621658': '{"draft":{}}' });
+    expect((await call()).content[0].text).toContain('s:14092347734530621658');
+  });
+});
+
 describe('gog_gmail_drafts_get', () => {
   it('calls runOrDiagnose with draftId', async () => {
     await harness.callTool('gog_gmail_drafts_get', { draftId: 'd1' });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'drafts', 'get', 'd1'],
+      ['gmail', 'drafts', 'get', 'd1', '--use-indexed-attachment-ids=false'],
       { account: undefined },
     );
   });
@@ -726,7 +1224,7 @@ describe('gog_gmail_drafts_get', () => {
   it('passes --download when true', async () => {
     await harness.callTool('gog_gmail_drafts_get', { draftId: 'd1', download: true });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'drafts', 'get', 'd1', '--download'],
+      ['gmail', 'drafts', 'get', 'd1', '--download', '--use-indexed-attachment-ids=false'],
       { account: undefined },
     );
   });
@@ -739,7 +1237,7 @@ describe('gog_gmail_drafts_create', () => {
       body: 'Hello',
     });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'drafts', 'create', '--subject=Hi', '--body=Hello'],
+      ['gmail', 'drafts', 'create', '--subject=Hi', '--body=Hello', '--auto-from-addressed-alias=false'],
       { account: undefined },
     );
   });
@@ -772,7 +1270,7 @@ describe('gog_gmail_drafts_create', () => {
         '--quote',
         '--attach=/tmp/a.pdf',
         '--attach=/tmp/b.pdf',
-        '--from=me@x.com',
+        '--from=me@x.com', '--auto-from-addressed-alias=false'
       ],
       { account: undefined },
     );
@@ -785,7 +1283,7 @@ describe('gog_gmail_drafts_create', () => {
       bodyHtmlFile: '/tmp/body.html',
     });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'drafts', 'create', '--subject=Hi', '--body=Hello', '--body-html-file=/tmp/body.html'],
+      ['gmail', 'drafts', 'create', '--subject=Hi', '--body=Hello', '--body-html-file=/tmp/body.html', '--auto-from-addressed-alias=false'],
       { account: undefined },
     );
   });
@@ -798,7 +1296,7 @@ describe('gog_gmail_drafts_create', () => {
       replyAll: true,
     });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'drafts', 'create', '--subject=Re: Hi', '--body=Hello all', '--thread-id=t1', '--reply-all'],
+      ['gmail', 'drafts', 'create', '--subject=Re: Hi', '--body=Hello all', '--thread-id=t1', '--reply-all', '--auto-from-addressed-alias=false'],
       { account: undefined },
     );
   });
@@ -809,7 +1307,7 @@ describe('gog_gmail_drafts_create', () => {
       subject: 'Hi', body: 'Hello', omitRecipients: true,
     });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'drafts', 'create', '--subject=Hi', '--body=Hello'],
+      ['gmail', 'drafts', 'create', '--subject=Hi', '--body=Hello', '--auto-from-addressed-alias=false'],
       { account: undefined },
     );
   });
@@ -822,9 +1320,9 @@ describe('gog_gmail_drafts_create', () => {
       subject: 'Hi', body: 'Hello', returnFull: true,
     });
     expect(lib.runOrDiagnose).toHaveBeenNthCalledWith(1,
-      ['gmail', 'drafts', 'create', '--subject=Hi', '--body=Hello'], { account: undefined });
+      ['gmail', 'drafts', 'create', '--subject=Hi', '--body=Hello', '--auto-from-addressed-alias=false'], { account: undefined });
     expect(lib.runOrDiagnose).toHaveBeenNthCalledWith(2,
-      ['gmail', 'drafts', 'get', 'd9'], { account: undefined });
+      ['gmail', 'drafts', 'get', 'd9', '--use-indexed-attachment-ids=false'], { account: undefined });
     expect(result.content[0].text).toContain('"subject":"Hi"');
   });
 
@@ -859,7 +1357,7 @@ describe('gmail draft reply threading (native --thread-id)', () => {
     // gog resolves the thread's latest-message headers itself — no extra fetch.
     expect(lib.runOrDiagnose).toHaveBeenCalledTimes(1);
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'drafts', 'create', '--subject=Re: roof', '--body=Sounds good', '--thread-id=19dffe06f9668b28'],
+      ['gmail', 'drafts', 'create', '--subject=Re: roof', '--body=Sounds good', '--thread-id=19dffe06f9668b28', '--auto-from-addressed-alias=false'],
       { account: 'me@x.com' },
     );
   });
@@ -869,7 +1367,7 @@ describe('gmail draft reply threading (native --thread-id)', () => {
       draftId: 'd1', subject: 'S', body: 'B', replyToThreadId: 't1',
     });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'drafts', 'update', 'd1', '--subject=S', '--body=B', '--thread-id=t1'],
+      ['gmail', 'drafts', 'update', 'd1', '--subject=S', '--body=B', '--thread-id=t1', '--auto-from-addressed-alias=false'],
       { account: undefined },
     );
   });
@@ -880,7 +1378,7 @@ describe('gmail draft reply threading (native --thread-id)', () => {
     });
     expect(lib.runOrDiagnose).toHaveBeenCalledTimes(1);
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'drafts', 'create', '--subject=S', '--body=B', '--reply-to-message-id=mExplicit'],
+      ['gmail', 'drafts', 'create', '--subject=S', '--body=B', '--reply-to-message-id=mExplicit', '--auto-from-addressed-alias=false'],
       { account: undefined },
     );
   });
@@ -894,7 +1392,7 @@ describe('gog_gmail_drafts_update', () => {
       body: 'New body',
     });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'drafts', 'update', 'd1', '--subject=New subject', '--body=New body'],
+      ['gmail', 'drafts', 'update', 'd1', '--subject=New subject', '--body=New body', '--auto-from-addressed-alias=false'],
       { account: undefined },
     );
   });
@@ -907,7 +1405,7 @@ describe('gog_gmail_drafts_update', () => {
       attach: ['/tmp/x.pdf'],
     });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'drafts', 'update', 'd1', '--subject=S', '--body=B', '--attach=/tmp/x.pdf'],
+      ['gmail', 'drafts', 'update', 'd1', '--subject=S', '--body=B', '--attach=/tmp/x.pdf', '--auto-from-addressed-alias=false'],
       { account: undefined },
     );
   });
@@ -917,7 +1415,7 @@ describe('gog_gmail_drafts_update', () => {
       draftId: 'd1', to: 'a@b.com', subject: 'S', body: 'B', omitRecipients: true,
     });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'drafts', 'update', 'd1', '--subject=S', '--body=B'],
+      ['gmail', 'drafts', 'update', 'd1', '--subject=S', '--body=B', '--auto-from-addressed-alias=false'],
       { account: undefined },
     );
   });
@@ -927,7 +1425,7 @@ describe('gog_gmail_drafts_update', () => {
       draftId: 'd1', subject: 'S', body: 'B', clearAttachments: true,
     });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'drafts', 'update', 'd1', '--subject=S', '--body=B', '--clear-attachments'],
+      ['gmail', 'drafts', 'update', 'd1', '--subject=S', '--body=B', '--auto-from-addressed-alias=false', '--clear-attachments'],
       { account: undefined },
     );
   });
@@ -937,7 +1435,7 @@ describe('gog_gmail_drafts_update', () => {
       draftId: 'd1', subject: 'S', body: 'B', clearReplyContext: true,
     });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'drafts', 'update', 'd1', '--subject=S', '--body=B', '--clear-reply-context'],
+      ['gmail', 'drafts', 'update', 'd1', '--subject=S', '--body=B', '--auto-from-addressed-alias=false', '--clear-reply-context'],
       { account: undefined },
     );
   });
@@ -961,7 +1459,7 @@ describe('gog_gmail_drafts_update', () => {
     });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
       ['gmail', 'drafts', 'update', 'd1', '--subject=S', '--body=B',
-        '--clear-attachments', '--clear-reply-context'],
+        '--auto-from-addressed-alias=false', '--clear-attachments', '--clear-reply-context'],
       { account: undefined },
     );
   });
@@ -974,7 +1472,7 @@ describe('gog_gmail_drafts_update', () => {
       draftId: 'd1', subject: 'S', body: 'B', returnFull: true,
     });
     expect(lib.runOrDiagnose).toHaveBeenNthCalledWith(2,
-      ['gmail', 'drafts', 'get', 'd1'], { account: undefined });
+      ['gmail', 'drafts', 'get', 'd1', '--use-indexed-attachment-ids=false'], { account: undefined });
     expect(result.content[0].text).toContain('"subject":"S"');
   });
 
@@ -1071,7 +1569,7 @@ describe('gog_gmail_reply', () => {
   it('calls runOrDiagnose with messageId and --body', async () => {
     await harness.callTool('gog_gmail_reply', { messageId: 'm1', body: 'Thanks' });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'reply', 'm1', '--body=Thanks'],
+      ['gmail', 'reply', 'm1', '--body=Thanks', '--auto-from-addressed-alias=false'],
       { account: undefined },
     );
   });
@@ -1111,7 +1609,7 @@ describe('gog_gmail_reply', () => {
         '--from=me@x.com',
         '--signature',
         '--signature-from=alias@x.com',
-        '--signature-file=/tmp/sig.txt',
+        '--signature-file=/tmp/sig.txt', '--auto-from-addressed-alias=false'
       ],
       { account: 'me@gmail.com' },
     );
@@ -1120,7 +1618,7 @@ describe('gog_gmail_reply', () => {
   it('omits --no-quote and --signature when false', async () => {
     await harness.callTool('gog_gmail_reply', { messageId: 'm1', body: 'Hi', noQuote: false, signature: false });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'reply', 'm1', '--body=Hi'],
+      ['gmail', 'reply', 'm1', '--body=Hi', '--auto-from-addressed-alias=false'],
       { account: undefined },
     );
   });
@@ -1130,7 +1628,7 @@ describe('gog_gmail_reply_all', () => {
   it('uses the reply-all subcommand', async () => {
     await harness.callTool('gog_gmail_reply_all', { messageId: 'm1', body: 'Thanks all' });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'reply-all', 'm1', '--body=Thanks all'],
+      ['gmail', 'reply-all', 'm1', '--body=Thanks all', '--auto-from-addressed-alias=false'],
       { account: undefined },
     );
   });
@@ -1150,7 +1648,7 @@ describe('gog_gmail_reply_all', () => {
         '--cc=x@y.com',
         '--cc=z@y.com',
         '--remove=drop@y.com',
-        '--signature-file=/tmp/sig.html',
+        '--signature-file=/tmp/sig.html', '--auto-from-addressed-alias=false'
       ],
       { account: undefined },
     );
@@ -1228,7 +1726,7 @@ describe('gog_gmail_messages_search', () => {
   it('calls runOrDiagnose with just the query', async () => {
     await harness.callTool('gog_gmail_messages_search', { query: 'from:alice' });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'messages', 'search', 'from:alice'],
+      ['gmail', 'messages', 'search', 'from:alice', '--include-attachments=false', '--use-indexed-attachment-ids=false'],
       { account: undefined },
     );
   });
@@ -1245,7 +1743,7 @@ describe('gog_gmail_messages_search', () => {
       account: 'me@x.com',
     });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'messages', 'search', 'is:unread', '--max=10', '--page=tok', '--all', '--include-body', '--full', '--body-format=html'],
+      ['gmail', 'messages', 'search', 'is:unread', '--max=10', '--page=tok', '--all', '--include-body', '--full', '--body-format=html', '--include-attachments=false', '--use-indexed-attachment-ids=false'],
       { account: 'me@x.com' },
     );
   });
@@ -1253,7 +1751,7 @@ describe('gog_gmail_messages_search', () => {
   it('omits flags when false/absent', async () => {
     await harness.callTool('gog_gmail_messages_search', { query: 'x', all: false, includeBody: false, full: false });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'messages', 'search', 'x'],
+      ['gmail', 'messages', 'search', 'x', '--include-attachments=false', '--use-indexed-attachment-ids=false'],
       { account: undefined },
     );
   });
@@ -1550,7 +2048,7 @@ describe('large payloads route to file args', () => {
   it('keeps a body at exactly the threshold inline', async () => {
     const atLimit = 'x'.repeat(lib.PAYLOAD_INLINE_MAX);
     await harness.callTool('gog_gmail_drafts_create', { subject: 'S', body: atLimit });
-    expect(args()).toEqual(['gmail', 'drafts', 'create', '--subject=S', `--body=${atLimit}`]);
+    expect(args()).toEqual(['gmail', 'drafts', 'create', '--subject=S', `--body=${atLimit}`, '--auto-from-addressed-alias=false']);
   });
 
   it('measures bytes, not characters, so a multibyte body crosses earlier', async () => {
@@ -1568,7 +2066,7 @@ describe('large payloads route to file args', () => {
     expect(args()).toEqual([
       'gmail', 'drafts', 'create',
       '--subject=S',
-      { kind: 'file', flag: 'body-file', contents: big, ext: undefined },
+      { kind: 'file', flag: 'body-file', contents: big, ext: undefined }, '--auto-from-addressed-alias=false'
     ]);
   });
 
@@ -1579,7 +2077,7 @@ describe('large payloads route to file args', () => {
       'gmail', 'drafts', 'create',
       '--subject=S',
       '--body=plain',
-      { kind: 'file', flag: 'body-html-file', contents: bigHtml, ext: 'html' },
+      { kind: 'file', flag: 'body-html-file', contents: bigHtml, ext: 'html' }, '--auto-from-addressed-alias=false'
     ]);
   });
 
@@ -1588,7 +2086,7 @@ describe('large payloads route to file args', () => {
     expect(args()).toEqual([
       'gmail', 'drafts', 'update', 'd1',
       '--subject=S',
-      { kind: 'file', flag: 'body-file', contents: big, ext: undefined },
+      { kind: 'file', flag: 'body-file', contents: big, ext: undefined }, '--auto-from-addressed-alias=false'
     ]);
   });
 
@@ -1599,7 +2097,7 @@ describe('large payloads route to file args', () => {
     expect(args()).toEqual([
       'gmail', 'drafts', 'create',
       '--subject=S',
-      { kind: 'file', flag: 'body-file', contents: big, ext: undefined },
+      { kind: 'file', flag: 'body-file', contents: big, ext: undefined }, '--auto-from-addressed-alias=false'
     ]);
   });
 
@@ -1612,7 +2110,7 @@ describe('large payloads route to file args', () => {
       '--subject=S',
       { kind: 'file', flag: 'body-file', contents: big, ext: undefined },
       '--thread-id=t1',
-      '--attach=/tmp/a.pdf',
+      '--attach=/tmp/a.pdf', '--auto-from-addressed-alias=false'
     ]);
   });
 
@@ -1629,7 +2127,7 @@ describe('large payloads route to file args', () => {
     expect(args()).toEqual([
       'gmail', 'reply', 'm1',
       { kind: 'file', flag: 'body-file', contents: big, ext: undefined },
-      { kind: 'file', flag: 'body-html-file', contents: bigHtml, ext: 'html' },
+      { kind: 'file', flag: 'body-html-file', contents: bigHtml, ext: 'html' }, '--auto-from-addressed-alias=false'
     ]);
   });
 
@@ -1638,7 +2136,7 @@ describe('large payloads route to file args', () => {
     expect(args()).toEqual([
       'gmail', 'reply-all', 'm1',
       { kind: 'file', flag: 'body-file', contents: big, ext: undefined },
-      '--signature',
+      '--signature', '--auto-from-addressed-alias=false'
     ]);
   });
 
@@ -1710,8 +2208,1107 @@ describe('inline/file param conflicts are rejected before gog runs', () => {
   it('bodyHtmlFile alone still passes through as --body-html-file', async () => {
     await harness.callTool('gog_gmail_reply', { messageId: 'm1', body: 'Hi', bodyHtmlFile: '/tmp/b.html' });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'reply', 'm1', '--body=Hi', '--body-html-file=/tmp/b.html'],
+      ['gmail', 'reply', 'm1', '--body=Hi', '--body-html-file=/tmp/b.html', '--auto-from-addressed-alias=false'],
+      { account: undefined },
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// gog 0.35.0 capabilities (MIN_GOG_VERSION floor).
+//
+// Every flag below is env-bound in gog, so an ambient GOG_GMAIL_* var on the
+// host silently changes the SHAPE of the output (or, for the attachment
+// download, makes gog reject the caller's own argument). runner.ts strips only
+// *_TOKEN/*_SECRET/*_API_KEY/*_PRIVATE_KEY, and on the remote runner the child
+// env belongs to a backend this wrapper does not control — so the tests below
+// assert the flag is PINNED on every call, not merely pushed when true.
+// ---------------------------------------------------------------------------
+
+describe('gog 0.35.0 — indexed attachment ids (gog_gmail_attachment)', () => {
+  const PDF_B64 = 'JVBERi0xLjUKJVBFRgo=';
+  const INDEXED_LIST = {
+    attachments: [
+      { filename: 'cover.png', mimeType: 'image/png', attachmentIndex: 0, size: 11 },
+      { filename: 'Guest_Copy.pdf', mimeType: 'application/pdf', attachmentIndex: 1, size: 99723 },
+    ],
+  };
+
+  function stub(opts: { meta?: unknown; metaError?: Error; download?: unknown; downloadError?: unknown }): void {
+    vi.mocked(lib.run).mockImplementation(async (args) => {
+      const a = args as string[];
+      if (a[0] === 'gmail' && a[1] === 'get') {
+        if (opts.metaError) throw opts.metaError;
+        return JSON.stringify(opts.meta ?? { attachments: [] });
+      }
+      if (a[0] === 'gmail' && a[1] === 'attachment') {
+        if (opts.downloadError) throw opts.downloadError;
+        return JSON.stringify(opts.download ?? {});
+      }
+      return '{}';
+    });
+  }
+  const runArgs = () => vi.mocked(lib.run).mock.calls.map((c) => c[0] as string[]);
+  const dlArgs = () => runArgs().find((a) => a[1] === 'attachment')!;
+  const textOf = (res: { content: unknown[] }) => (res.content[0] as { text: string }).text;
+
+  it('resolves the real filename BEFORE the download and never runs the size heuristic', async () => {
+    stub({ meta: INDEXED_LIST, download: { path: '/tmp/gog-attachments/m1/Guest_Copy.pdf', bytes: 99723, contentBase64: PDF_B64 } });
+    const res = await harness.callTool('gog_gmail_attachment', { messageId: 'm1', attachmentIndex: 1 });
+    // exactly one metadata read, and it happens BEFORE the download.
+    expect(runArgs().map((a) => a.slice(0, 2))).toEqual([['gmail', 'get'], ['gmail', 'attachment']]);
+    expect(runArgs()[0]).toEqual(['gmail', 'get', 'm1', '--use-indexed-attachment-ids']);
+    // the index rides in the positional slot, and gog is told to read it as one.
+    expect(dlArgs()).toEqual([
+      'gmail', 'attachment', 'm1', '1', '--use-indexed-attachment-ids', '--inline', '--inline-max-bytes=3145728',
+      '--out=/tmp/gog-attachments/m1/Guest_Copy.pdf', '--name=Guest_Copy.pdf',
+    ]);
+    expect(JSON.parse(textOf(res))).toMatchObject({ fileName: 'Guest_Copy.pdf', mimeType: 'application/pdf' });
+  });
+
+  it('pins the mode OFF on the legacy attachmentId path', async () => {
+    stub({ download: { path: '/tmp/gog-attachments/m1/x.pdf', bytes: 12, contentBase64: PDF_B64 } });
+    await harness.callTool('gog_gmail_attachment', { messageId: 'm1', attachmentId: 'OPAQUE1', name: 'x.pdf' });
+    expect(dlArgs()).toEqual([
+      'gmail', 'attachment', 'm1', 'OPAQUE1', '--use-indexed-attachment-ids=false', '--inline', '--inline-max-bytes=3145728',
+      '--out=/tmp/gog-attachments/m1/x.pdf', '--name=x.pdf',
+    ]);
+  });
+
+  it('rejects both attachmentId and attachmentIndex', async () => {
+    const res = await harness.callTool('gog_gmail_attachment', { messageId: 'm1', attachmentId: 'a1', attachmentIndex: 0 });
+    expect(res.isError).toBe(true);
+    expect(textOf(res)).toContain('exactly one');
+    expect(lib.run).not.toHaveBeenCalled();
+  });
+
+  it('rejects neither attachmentId nor attachmentIndex', async () => {
+    const res = await harness.callTool('gog_gmail_attachment', { messageId: 'm1' });
+    expect(res.isError).toBe(true);
+    expect(textOf(res)).toContain('exactly one');
+    expect(lib.run).not.toHaveBeenCalled();
+  });
+
+  it('a caller-supplied name skips the index lookup', async () => {
+    stub({ meta: INDEXED_LIST, download: { path: '/tmp/gog-attachments/m1/mine.pdf', bytes: 5, contentBase64: PDF_B64 } });
+    await harness.callTool('gog_gmail_attachment', { messageId: 'm1', attachmentIndex: 1, name: 'mine.pdf' });
+    expect(runArgs().some((a) => a[1] === 'get')).toBe(false);
+  });
+
+  it('survives an index lookup failure without falling back to the size heuristic', async () => {
+    stub({ metaError: new Error('get failed'), download: { path: '/tmp/gog-attachments/m1/attachment', bytes: 12, contentBase64: PDF_B64 } });
+    const res = await harness.callTool('gog_gmail_attachment', { messageId: 'm1', attachmentIndex: 0 });
+    // only the (failed) pre-download lookup — resolveBySize must not run after it.
+    expect(runArgs().filter((a) => a[1] === 'get')).toHaveLength(1);
+    expect(JSON.parse(textOf(res))).toMatchObject({ fileName: 'attachment.pdf', mimeType: 'application/pdf' });
+  });
+
+  it('tolerates a message whose listing carries no attachments array', async () => {
+    stub({ meta: {}, download: { path: '/tmp/gog-attachments/m1/attachment', bytes: 12, contentBase64: PDF_B64 } });
+    const res = await harness.callTool('gog_gmail_attachment', { messageId: 'm1', attachmentIndex: 3 });
+    expect(JSON.parse(textOf(res))).toMatchObject({ fileName: 'attachment.pdf' });
+  });
+
+  it('uses the filename/mimeType gog itself reports on an --inline download', async () => {
+    // gog >= 0.34 returns the part metadata alongside the bytes; prefer it over
+    // any wrapper-side guess.
+    stub({ meta: { attachments: [{}] }, download: {
+      path: '/tmp/gog-attachments/m1/attachment', bytes: 12, contentBase64: PDF_B64,
+      filename: 'From_Gog.pdf', mimeType: 'application/pdf',
+    } });
+    const res = await harness.callTool('gog_gmail_attachment', { messageId: 'm1', attachmentIndex: 0 });
+    expect(JSON.parse(textOf(res))).toMatchObject({ fileName: 'From_Gog.pdf', mimeType: 'application/pdf' });
+  });
+
+  it('prefers a caller name over the one gog reports', async () => {
+    stub({ download: {
+      path: '/tmp/gog-attachments/m1/mine.pdf', bytes: 12, contentBase64: PDF_B64,
+      filename: 'From_Gog.pdf', mimeType: 'application/pdf',
+    } });
+    const res = await harness.callTool('gog_gmail_attachment', { messageId: 'm1', attachmentIndex: 0, name: 'mine.pdf' });
+    expect(JSON.parse(textOf(res))).toMatchObject({ fileName: 'mine.pdf', mimeType: 'application/pdf' });
+  });
+
+  it('passes inlineMaxBytes through as --inline-max-bytes', async () => {
+    stub({ meta: INDEXED_LIST, download: { path: '/tmp/gog-attachments/m1/cover.png', bytes: 11 } });
+    await harness.callTool('gog_gmail_attachment', { messageId: 'm1', attachmentIndex: 0, inlineMaxBytes: 1048576 });
+    expect(dlArgs()).toEqual([
+      'gmail', 'attachment', 'm1', '0', '--use-indexed-attachment-ids', '--inline', '--inline-max-bytes=1048576',
+      '--out=/tmp/gog-attachments/m1/cover.png', '--name=cover.png',
+    ]);
+  });
+
+  it('does not mangle an indexed failure message while redacting (no bare-digit substitution)', async () => {
+    stub({ downloadError: new Error('Command failed: gog gmail attachment m1 0\nquota exceeded: 1000 requests') });
+    await harness.callTool('gog_gmail_attachment', { messageId: 'm1', attachmentIndex: 0 });
+    const passed = (vi.mocked(lib.diagnose).mock.calls[0]![0] as Error).message;
+    expect(passed).toBe('quota exceeded: 1000 requests');
+  });
+});
+
+describe('gog 0.35.0 — indexed ids are pinned on every listing that emits attachments', () => {
+  const args = () => vi.mocked(lib.runOrDiagnose).mock.calls[0]![0] as string[];
+
+  it('gog_gmail_thread_get pins the mode off by default and on when asked', async () => {
+    await harness.callTool('gog_gmail_thread_get', { threadId: 't1' });
+    expect(args()).toEqual(['gmail', 'thread', 'get', 't1', '--use-indexed-attachment-ids=false']);
+    vi.clearAllMocks();
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(rawTextResult('{}'));
+    await harness.callTool('gog_gmail_thread_get', { threadId: 't1', useIndexedAttachmentIds: true });
+    expect(args()).toEqual(['gmail', 'thread', 'get', 't1', '--use-indexed-attachment-ids']);
+  });
+
+  it('gog_gmail_thread_attachments pins the mode — a flat list needs per-message indexes', async () => {
+    await harness.callTool('gog_gmail_thread_attachments', { threadId: 't1' });
+    expect(args()).toEqual(['gmail', 'thread', 'attachments', 't1', '--use-indexed-attachment-ids=false']);
+    vi.clearAllMocks();
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(rawTextResult('{}'));
+    await harness.callTool('gog_gmail_thread_attachments', { threadId: 't1', useIndexedAttachmentIds: true, download: true });
+    expect(args()).toEqual(['gmail', 'thread', 'attachments', 't1', '--download', '--use-indexed-attachment-ids']);
+  });
+
+  it('gog_gmail_drafts_get pins the mode', async () => {
+    await harness.callTool('gog_gmail_drafts_get', { draftId: 'd1' });
+    expect(args()).toEqual(['gmail', 'drafts', 'get', 'd1', '--use-indexed-attachment-ids=false']);
+    vi.clearAllMocks();
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(rawTextResult('{}'));
+    await harness.callTool('gog_gmail_drafts_get', { draftId: 'd1', useIndexedAttachmentIds: true, download: true });
+    expect(args()).toEqual(['gmail', 'drafts', 'get', 'd1', '--download', '--use-indexed-attachment-ids']);
+  });
+
+  it('gog_gmail_messages_search pins BOTH attachment-shaping flags', async () => {
+    await harness.callTool('gog_gmail_messages_search', { query: 'x' });
+    expect(args()).toEqual([
+      'gmail', 'messages', 'search', 'x', '--include-attachments=false', '--use-indexed-attachment-ids=false',
+    ]);
+    vi.clearAllMocks();
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(rawTextResult('{}'));
+    await harness.callTool('gog_gmail_messages_search', { query: 'x', includeAttachments: true, useIndexedAttachmentIds: true });
+    expect(args()).toEqual([
+      'gmail', 'messages', 'search', 'x', '--include-attachments', '--use-indexed-attachment-ids',
+    ]);
+  });
+});
+
+describe('gog 0.35.0 — --auto-from-addressed-alias is pinned on every send-shaped write', () => {
+  const args = () => vi.mocked(lib.runOrDiagnose).mock.calls[0]![0] as string[];
+
+  it('gog_gmail_drafts_create pins it off, and sets it when asked', async () => {
+    await harness.callTool('gog_gmail_drafts_create', { subject: 'S', body: 'B' });
+    expect(args()).toEqual(['gmail', 'drafts', 'create', '--subject=S', '--body=B', '--auto-from-addressed-alias=false']);
+    vi.clearAllMocks();
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(rawTextResult('{}'));
+    await harness.callTool('gog_gmail_drafts_create', { subject: 'S', body: 'B', autoFromAddressedAlias: true });
+    expect(args()).toEqual(['gmail', 'drafts', 'create', '--subject=S', '--body=B', '--auto-from-addressed-alias']);
+  });
+
+  it('gog_gmail_drafts_update pins it', async () => {
+    await harness.callTool('gog_gmail_drafts_update', { draftId: 'd1', subject: 'S', body: 'B', autoFromAddressedAlias: true });
+    expect(args()).toEqual(['gmail', 'drafts', 'update', 'd1', '--subject=S', '--body=B', '--auto-from-addressed-alias']);
+  });
+
+  it('gog_gmail_reply and gog_gmail_reply_all pin it', async () => {
+    await harness.callTool('gog_gmail_reply', { messageId: 'm1', body: 'Hi' });
+    expect(args()).toEqual(['gmail', 'reply', 'm1', '--body=Hi', '--auto-from-addressed-alias=false']);
+    vi.clearAllMocks();
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(rawTextResult('{}'));
+    await harness.callTool('gog_gmail_reply_all', { messageId: 'm1', body: 'Hi', autoFromAddressedAlias: true });
+    expect(args()).toEqual(['gmail', 'reply-all', 'm1', '--body=Hi', '--auto-from-addressed-alias']);
+  });
+});
+
+describe('gog 0.35.0 — gog_gmail_import', () => {
+  const args = () => vi.mocked(lib.runOrDiagnose).mock.calls[0]![0] as string[];
+
+  it('imports a file with no options', async () => {
+    await harness.callTool('gog_gmail_import', { file: '/tmp/msg.eml' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['gmail', 'import', '/tmp/msg.eml'], { account: undefined });
+  });
+
+  it('passes every option, repeating --label', async () => {
+    await harness.callTool('gog_gmail_import', {
+      file: '/srv/exports/archived.eml',
+      labels: ['INBOX', 'Archive/2026'],
+      internalDateSource: 'receivedTime',
+      neverMarkSpam: true,
+      processForCalendar: true,
+      account: 'me@x.com',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'import', '/srv/exports/archived.eml', '--label=INBOX', '--label=Archive/2026', '--internal-date-source=receivedTime', '--never-mark-spam', '--process-for-calendar'],
+      { account: 'me@x.com' },
+    );
+  });
+
+  it('omits flags that are false or absent', async () => {
+    await harness.callTool('gog_gmail_import', { file: '/tmp/m.eml', neverMarkSpam: false, processForCalendar: false });
+    expect(args()).toEqual(['gmail', 'import', '/tmp/m.eml']);
+  });
+
+  it('rejects an internalDateSource outside gog\'s enum', async () => {
+    const res = await harness.callTool('gog_gmail_import', { file: '/tmp/m.eml', internalDateSource: 'yesterday' });
+    expect(res.isError).toBe(true);
+  });
+
+  it('never appends --force — gog gates no confirmation on import', async () => {
+    await harness.callTool('gog_gmail_import', { file: '/tmp/m.eml' });
+    expect(args()).not.toContain('--force');
+  });
+});
+
+// gog reads a "-" path argument with io.ReadAll(stdinReader(ctx)) — os.Stdin,
+// unaffected by --no-input (gmail_import.go:102, gmail_body_input.go:45 at
+// upstream-v0.35.0). runner.ts's spawnGog spawns with default stdio and never
+// writes to or ends child.stdin, so gog blocks forever on a read that never
+// EOFs: `spawn('gog', ['gmail','import','-','--dry-run','--json','--no-input'])`
+// was still running with no output after 5s. Under run() that burns the whole
+// 30s timeout and returns "gog timed out after 30s". No description may offer
+// it as a usable option.
+describe('server-side file params never advertise stdin as usable', () => {
+  const STDIN_PARAMS: Array<[tool: string, param: string]> = [
+    ['gog_gmail_import', 'file'],
+    ['gog_gmail_drafts_create', 'bodyHtmlFile'],
+    ['gog_gmail_drafts_update', 'bodyHtmlFile'],
+    ['gog_gmail_reply', 'bodyHtmlFile'],
+    ['gog_gmail_reply_all', 'bodyHtmlFile'],
+  ];
+
+  async function paramDescriptions(): Promise<Map<string, Record<string, { description?: string }>>> {
+    const { McpServer } = await import('@modelcontextprotocol/sdk/server/mcp.js');
+    const server = new McpServer({ name: 'test', version: '0.0.0' });
+    const configs = new Map<string, Record<string, { description?: string }>>();
+    vi.spyOn(server, 'registerTool').mockImplementation((name, config) => {
+      configs.set(name, (config as { inputSchema: Record<string, { description?: string }> }).inputSchema);
+      return undefined as never;
+    });
+    registerExtraGmailTools(server);
+    return configs;
+  }
+
+  it.each(STDIN_PARAMS)('%s.%s warns that stdin hangs instead of offering it', async (tool, param) => {
+    const schema = (await paramDescriptions()).get(tool);
+    const desc = schema?.[param]?.description ?? '';
+    expect(desc).not.toBe('');
+    expect(desc).not.toMatch(/(?:or|use)\s+"?-"?\s+(?:for|to read)/i);
+    expect(desc).toMatch(/stdin/i);
+    expect(desc).toMatch(/hang|never writes/i);
+  });
+});
+
+// Every env-bound gog flag this tool depends on is pinned on the call, because
+// the child env on the remote runner belongs to a backend we do not control.
+// --inline-max-bytes is declared env:"GOG_GMAIL_INLINE_MAX_BYTES"
+// (gmail_attachment.go:27 at upstream-v0.35.0), so an ambient value would
+// silently decide whether contentBase64 comes back at all.
+describe('gog_gmail_attachment pins --inline-max-bytes', () => {
+  const args = () => vi.mocked(lib.run).mock.calls[0]![0] as string[];
+
+  it('pins gog\'s default when the caller supplies nothing', async () => {
+    vi.mocked(lib.run).mockResolvedValue(JSON.stringify({ bytes: 10, contentBase64: 'AAAA', mimeType: 'image/png', filename: 'a.png' }));
+    await harness.callTool('gog_gmail_attachment', { messageId: 'm1', attachmentId: 'a1', deliver: 'inline' });
+    expect(args()).toContain('--inline-max-bytes=3145728');
+  });
+
+  it('pins the caller\'s value when supplied', async () => {
+    vi.mocked(lib.run).mockResolvedValue(JSON.stringify({ bytes: 10, contentBase64: 'AAAA', mimeType: 'image/png', filename: 'a.png' }));
+    await harness.callTool('gog_gmail_attachment', { messageId: 'm1', attachmentId: 'a1', deliver: 'inline', inlineMaxBytes: 99 });
+    expect(args()).toContain('--inline-max-bytes=99');
+  });
+});
+
+// ===========================================================================
+// REQUIREMENT 4 — VERIFY (and repair) THREADING ON AN UPDATE.
+//
+// gog already does the repair: `--thread-id` on `gmail drafts update` sets
+// replyToThreadID, so buildDraftMessage RESOLVES In-Reply-To/References from
+// the thread's latest non-draft message, and Users.Drafts.Update keeps the
+// draft id (internal/cmd/gmail_drafts.go, upstream-v0.35.0). What was missing
+// is the VERIFICATION: gog reports inReplyTo/references/replyContextSource in
+// its own ack, and nothing was reading them back to the caller.
+//
+// The silent failure this catches: the thread branch of fetchReplyInfo has no
+// "target has no Message-ID header" guard (the message branch does), so a
+// thread whose latest message lacks a Message-Id resolves NO lineage — and
+// because an explicit reply target suppresses the carry-forward branch, the
+// draft is MOVED to the new thread and ends up with NO reply headers at all.
+// ===========================================================================
+describe('gog_gmail_drafts_update — threading verification', () => {
+  const ACK = (over: Record<string, unknown> = {}): string => JSON.stringify({
+    draftId: 'r4303011157206680397',
+    threadId: '19f856becba0661d',
+    inReplyTo: '<CAO@mail.gmail.com>',
+    references: '<CAO@mail.gmail.com>',
+    replyContextSource: 'caller',
+    ...over,
+  });
+
+  it('adopts a draft onto a thread in one call, keeps its id, and reports the effective headers', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(ACK()));
+    const result = await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'r4303011157206680397',
+      subject: 'Re: pickup schedule',
+      body: 'merged text',
+      replyToThreadId: '19f856becba0661d',
+    });
+
+    // One gog invocation: gog resolves the thread's reply headers server-side.
+    expect(lib.runOrDiagnose).toHaveBeenCalledTimes(1);
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'drafts', 'update', 'r4303011157206680397', '--subject=Re: pickup schedule',
+        '--body=merged text', '--thread-id=19f856becba0661d', '--auto-from-addressed-alias=false'],
       { account: undefined },
     );
+
+    const parsed = JSON.parse(result.content[0].text);
+    // The id survives the adoption — that is the whole point of updating in place.
+    expect(parsed.draftId).toBe('r4303011157206680397');
+    expect(parsed.threadingVerification).toMatchObject({
+      requested: 'set',
+      via: 'replyToThreadId',
+      target: '19f856becba0661d',
+      ok: true,
+      effective: {
+        threadId: '19f856becba0661d',
+        inReplyTo: '<CAO@mail.gmail.com>',
+        references: '<CAO@mail.gmail.com>',
+        replyContextSource: 'caller',
+      },
+    });
+    // Every update rewrites the body — gog requires --body. Say so.
+    expect(parsed.threadingVerification.note).toMatch(/body/i);
+  });
+
+  it('WARNS when the re-thread moved the draft but produced no reply headers', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(
+      ACK({ inReplyTo: null, references: null, replyContextSource: null }),
+    ));
+    const result = await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'r4303011157206680397', subject: 'S', body: 'B', replyToThreadId: '19f856becba0661d',
+    });
+    const v = JSON.parse(result.content[0].text).threadingVerification;
+    expect(v.ok).toBe(false);
+    expect(v.note).toMatch(/WARNING/);
+    expect(v.note).toMatch(/not arrive as a reply/i);
+    // The dangerous half: it DID move threads, so it is not a no-op to ignore.
+    expect(v.note).toContain('19f856becba0661d');
+  });
+
+  it('anchors to a message id when both reply targets are given, and says which it used', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(ACK()));
+    const result = await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'd1', subject: 'S', body: 'B', replyToMessageId: 'mExplicit', replyToThreadId: 't1',
+    });
+    const args = vi.mocked(lib.runOrDiagnose).mock.calls[0]![0] as string[];
+    expect(args).toContain('--reply-to-message-id=mExplicit');
+    expect(args.some((a) => a.startsWith('--thread-id'))).toBe(false);
+    expect(JSON.parse(result.content[0].text).threadingVerification).toMatchObject({
+      requested: 'set', via: 'replyToMessageId', target: 'mExplicit', ok: true,
+    });
+  });
+
+  it('confirms clearReplyContext actually dropped the lineage, and that the threadId stayed', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(
+      ACK({ inReplyTo: null, references: null, replyContextSource: null }),
+    ));
+    const result = await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'd1', subject: 'S', body: 'B', clearReplyContext: true,
+    });
+    const v = JSON.parse(result.content[0].text).threadingVerification;
+    expect(v).toMatchObject({ requested: 'clear', ok: true });
+    expect(v.note).not.toMatch(/WARNING/);
+    expect(v.effective.threadId).toBe('19f856becba0661d');
+  });
+
+  it('WARNS when clearReplyContext left reply headers in place', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(ACK()));
+    const result = await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'd1', subject: 'S', body: 'B', clearReplyContext: true,
+    });
+    const v = JSON.parse(result.content[0].text).threadingVerification;
+    expect(v.ok).toBe(false);
+    expect(v.note).toMatch(/WARNING/);
+    expect(v.note).toContain('<CAO@mail.gmail.com>');
+  });
+
+  it('adds nothing at all when no reply-context change was requested', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(ACK()));
+    const result = await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'd1', subject: 'S', body: 'B',
+    });
+    // Byte-identical passthrough: an update that changes no threading must not
+    // acquire a new output shape.
+    expect(result.content[0].text).toBe(ACK());
+  });
+
+  it('carries the verification onto the returnFull re-fetch', async () => {
+    vi.mocked(lib.runOrDiagnose)
+      .mockResolvedValueOnce(rawTextResult(ACK()))
+      .mockResolvedValueOnce(rawTextResult('{"draft":{"id":"r4303011157206680397"}}'));
+    const result = await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'r4303011157206680397', subject: 'S', body: 'B', replyToThreadId: '19f856becba0661d', returnFull: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledTimes(2);
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.draft.id).toBe('r4303011157206680397');
+    expect(parsed.threadingVerification.ok).toBe(true);
+  });
+
+  it('degrades to a prose note when the final result is not a JSON object', async () => {
+    vi.mocked(lib.runOrDiagnose)
+      .mockResolvedValueOnce(rawTextResult(ACK()))
+      .mockResolvedValueOnce(rawTextResult('draft_id\tr4303011157206680397'));
+    const result = await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'r4303011157206680397', subject: 'S', body: 'B', replyToThreadId: '19f856becba0661d', returnFull: true,
+    });
+    expect(result.content[0].text).toMatch(/threadingVerification/);
+    expect(result.content[1].text).toBe('draft_id\tr4303011157206680397');
+  });
+
+  it('labels an unreported threadId rather than interpolating undefined', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(JSON.stringify({
+      draftId: 'd1', inReplyTo: null, references: null, replyContextSource: null,
+    })));
+    const result = await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'd1', subject: 'S', body: 'B', replyToThreadId: 't1',
+    });
+    const v = JSON.parse(result.content[0].text).threadingVerification;
+    expect(v.effective.threadId).toBeUndefined();
+    expect(v.note).toContain('(none reported)');
+    expect(v.note).not.toContain('undefined');
+  });
+
+  it('says nothing when the write itself failed (no JSON ack to verify against)', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(errorResult('Error: usage: --subject required'));
+    const result = await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'd1', subject: 'S', body: 'B', replyToThreadId: 't1',
+    });
+    expect(result.content[0].text).toContain('usage: --subject required');
+    expect(result.content[0].text).not.toContain('threadingVerification');
+  });
+});
+
+// ===========================================================================
+// REQUIREMENT 1 — a 404 on a draft id is a FORK REPORT, not a bare notFound.
+//
+// A draft created here and then edited in a mail client is not updated in
+// place: the client writes a NEW draft and abandons the original, so the
+// original id stops resolving and `gog gmail drafts update` returns
+// `Google API error (404 notFound)` with nothing to say it was replaced.
+//
+// HAZARD A governs the shape of the answer: with the original unfetchable
+// there is nothing left to establish LINEAGE against, so this report may never
+// name a replacement. It lists what exists and hands the caller the tool that
+// can decide (gog_gmail_drafts_diff, on a named pair).
+// HAZARD B governs its cost: at most 2 extra gog invocations, constant, and
+// only on a call that has ALREADY failed.
+// ===========================================================================
+describe('gog_gmail_drafts_update — DRAFT_FORKED on 404', () => {
+  const NOT_FOUND = 'Error: Google API error (404 notFound): Requested entity was not found.';
+  const LIST = JSON.stringify({
+    drafts: [
+      { id: 's:14092347734530621658', messageId: '19fe8a673d1e5f21', threadId: '19fe8a673d1e5f21' },
+      { id: 'r-457330811034304502', messageId: 'aaa', threadId: 'bbb' },
+      // gog declares every field `omitempty`, so a draft can arrive with none
+      // of them. It must still be listed, not crash the report.
+      {},
+    ],
+  });
+  const SEARCH = JSON.stringify({
+    messages: [
+      { id: '19fe8a673d1e5f21', subject: 'Re: pickup schedule', from: 'me@x.com', internalDateIso: '2026-08-09T10:00:00Z' },
+      { id: 'aaa', subject: 'Unrelated note to the plumber', from: 'me@x.com', internalDateIso: '2026-08-01T09:00:00Z' },
+      { subject: 'a search hit with no id joins to nothing' },
+    ],
+  });
+
+  function stub404(): void {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(errorResult(NOT_FOUND));
+    vi.mocked(lib.run).mockImplementation(async (args) => {
+      const argv = args as string[];
+      if (argv[1] === 'drafts' && argv[2] === 'list') return LIST;
+      if (argv[1] === 'messages' && argv[2] === 'search') return SEARCH;
+      throw new Error(`unexpected gog call: ${argv.join(' ')}`);
+    });
+  }
+
+  it('explains the 404 as a possible client-side fork and keeps gog\'s own error', async () => {
+    stub404();
+    const result = await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'r4303011157206680397', subject: 'S', body: 'B',
+    });
+    expect(result.isError).toBe(true);
+    const text = result.content[0].text as string;
+    expect(text).toContain('DRAFT_FORKED');
+    expect(text).toContain('r4303011157206680397');
+    // gog's own words survive verbatim — the diagnosis is added, never swapped in.
+    expect(text).toContain('Google API error (404 notFound)');
+    const parsed = JSON.parse(text.slice(text.indexOf('{')));
+    expect(parsed.code).toBe('DRAFT_FORKED');
+    expect(parsed.currentDrafts.map((d: { id?: string; origin: string; subject?: string }) => [d.id, d.origin, d.subject])).toEqual([
+      ['s:14092347734530621658', 'non-api', 'Re: pickup schedule'],
+      ['r-457330811034304502', 'api', 'Unrelated note to the plumber'],
+      // An id-less draft is reported as `api` — the ONLY thing `non-api` may
+      // ever mean is a literal `s:` prefix, so an absent id must not claim one.
+      [undefined, 'api', undefined],
+    ]);
+    expect(parsed.nextSteps.join(' ')).toContain('gog_gmail_drafts_diff');
+  });
+
+  it('names NO replacement, even when a newer non-api draft is sitting right there', async () => {
+    stub404();
+    const result = await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'r4303011157206680397', subject: 'S', body: 'B',
+    });
+    const text = result.content[0].text as string;
+    const parsed = JSON.parse(text.slice(text.indexOf('{')));
+    // Hazard A: the 404'd draft cannot be fetched, so no lineage signal can
+    // exist and no pairing verdict is possible. Not "candidate" — none.
+    expect(parsed.forkClaim).toBeNull();
+    expect(text).not.toContain('confirmed');
+    expect(text).not.toContain('apple-mail');
+    for (const d of parsed.currentDrafts) expect(d).not.toHaveProperty('verdict');
+    // The list is ordering, not evidence, and it says so.
+    expect(parsed.forkClaimNote).toMatch(/ordering is presentation, not evidence/i);
+    // And the 404 has innocent explanations too.
+    expect(parsed.otherExplanations.join(' ')).toMatch(/deleted|sent/i);
+  });
+
+  it('spends at most two extra gog invocations, both constant in the number of drafts', async () => {
+    stub404();
+    await harness.callTool('gog_gmail_drafts_update', { draftId: 'r43', subject: 'S', body: 'B' });
+    expect(vi.mocked(lib.run).mock.calls.map((c) => (c[0] as string[]).slice(0, 3))).toEqual([
+      ['gmail', 'drafts', 'list'],
+      ['gmail', 'messages', 'search'],
+    ]);
+    expect(vi.mocked(lib.run)).toHaveBeenCalledTimes(2);
+  });
+
+  it('leaves a non-404 failure completely alone, and spends nothing', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(errorResult('Error: Google API error (403 forbidden): insufficient scope'));
+    const result = await harness.callTool('gog_gmail_drafts_update', { draftId: 'd1', subject: 'S', body: 'B' });
+    expect(result.content[0].text).toBe('Error: Google API error (403 forbidden): insufficient scope');
+    expect(lib.run).not.toHaveBeenCalled();
+  });
+
+  it('does not fire on a SUCCESSFUL result that merely mentions 404', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult('{"draftId":"d1","message":{"snippet":"the 404 not found page"}}'));
+    const result = await harness.callTool('gog_gmail_drafts_update', { draftId: 'd1', subject: 'S', body: 'B' });
+    expect(result.content[0].text).toContain('the 404 not found page');
+    expect(result.content[0].text).not.toContain('DRAFT_FORKED');
+    expect(lib.run).not.toHaveBeenCalled();
+  });
+
+  it('still reports the fork explanation when the draft listing itself fails', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(errorResult(NOT_FOUND));
+    vi.mocked(lib.run).mockRejectedValue(new Error('gog timed out after 30s'));
+    const result = await harness.callTool('gog_gmail_drafts_update', { draftId: 'd1', subject: 'S', body: 'B' });
+    const text = result.content[0].text as string;
+    expect(text).toContain('DRAFT_FORKED');
+    const parsed = JSON.parse(text.slice(text.indexOf('{')));
+    expect(parsed.currentDrafts).toBeUndefined();
+    expect(parsed.currentDraftsUnavailable).toContain('gog timed out');
+    expect(vi.mocked(lib.run)).toHaveBeenCalledTimes(1);
+  });
+
+  it('keeps the free tier-0 fields when only the enrichment search fails', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(errorResult(NOT_FOUND));
+    vi.mocked(lib.run).mockImplementation(async (args) => {
+      if ((args as string[])[2] === 'list') return LIST;
+      throw new Error('search exploded');
+    });
+    const result = await harness.callTool('gog_gmail_drafts_update', { draftId: 'd1', subject: 'S', body: 'B' });
+    const text = result.content[0].text as string;
+    const parsed = JSON.parse(text.slice(text.indexOf('{')));
+    expect(parsed.currentDrafts).toHaveLength(3);
+    expect(parsed.currentDrafts[0].origin).toBe('non-api');
+    expect(parsed.currentDrafts[0].subject).toBeUndefined();
+    expect(parsed.enrichmentNote).toContain('search exploded');
+  });
+
+  it('treats a listing without a drafts array as unavailable rather than empty', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(errorResult(NOT_FOUND));
+    // Parses as JSON, but carries no drafts array — a different failure from
+    // gog's plain-text "No drafts", and it must not read as "you have none".
+    vi.mocked(lib.run).mockResolvedValue('{"nextPageToken":"tok"}');
+    const result = await harness.callTool('gog_gmail_drafts_update', { draftId: 'd1', subject: 'S', body: 'B' });
+    const parsed = JSON.parse((result.content[0].text as string).slice((result.content[0].text as string).indexOf('{')));
+    expect(parsed.currentDraftsUnavailable).toContain('no drafts array');
+  });
+
+  it('fires for gog_gmail_drafts_send too — the draft you meant to send is gone', async () => {
+    stub404();
+    const result = await harness.callTool('gog_gmail_drafts_send', { draftId: 'r4303011157206680397' });
+    expect(result.isError).toBe(true);
+    const text = result.content[0].text as string;
+    expect(text).toContain('DRAFT_FORKED');
+    expect(text).toContain('gog_gmail_drafts_send');
+    expect(vi.mocked(lib.run)).toHaveBeenCalledTimes(2);
+  });
+
+  // `gmail drafts update` resolves THREE Google entities and gog renders all
+  // three 404s identically: the draft (Users.Drafts.Get/Update), the thread
+  // behind --thread-id (Users.Threads.Get) and the message behind
+  // --reply-to-message-id (Users.Messages.Get). Claiming DRAFT_FORKED on a
+  // stale THREAD id — while listing that same draft id under currentDrafts —
+  // sends the caller hunting for a replacement draft that does not exist.
+  it('does not call it a fork when the draft is still listed: the 404 came from the reply target', async () => {
+    stub404();
+    const result = await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'r-457330811034304502', subject: 'S', body: 'B',
+      replyToThreadId: 'THREAD-THAT-DOES-NOT-EXIST',
+    });
+    expect(result.isError).toBe(true);
+    const text = result.content[0].text as string;
+    expect(text).not.toContain('DRAFT_FORKED');
+    const parsed = JSON.parse(text.slice(text.indexOf('{')));
+    expect(parsed.code).toBe('GOOGLE_404_NOT_THE_DRAFT');
+    expect(parsed.replyTarget).toEqual({ via: 'replyToThreadId', target: 'THREAD-THAT-DOES-NOT-EXIST' });
+    // The payload may not contradict itself: it lists the draft AND says it is gone.
+    expect(parsed.currentDrafts.map((d: { id?: string }) => d.id)).toContain('r-457330811034304502');
+    expect(parsed.whatHappened).not.toMatch(/no longer has a draft|has no draft under this id/i);
+    expect(parsed.whatHappened).toMatch(/still exists|still listed/i);
+    expect(parsed.nextSteps.join(' ')).toMatch(/thread id/i);
+    // gog's own words survive, and the cost cap is unchanged.
+    expect(text).toContain('Google API error (404 notFound)');
+    expect(vi.mocked(lib.run)).toHaveBeenCalledTimes(2);
+  });
+
+  it('says the same for a send whose 404 cannot be about the draft id either', async () => {
+    stub404();
+    const result = await harness.callTool('gog_gmail_drafts_send', { draftId: 's:14092347734530621658' });
+    const text = result.content[0].text as string;
+    expect(text).not.toContain('DRAFT_FORKED');
+    const parsed = JSON.parse(text.slice(text.indexOf('{')));
+    expect(parsed.code).toBe('GOOGLE_404_NOT_THE_DRAFT');
+    expect(parsed.replyTarget).toBeNull();
+    expect(parsed.raceNote).toMatch(/AFTER the failure/i);
+  });
+
+  it('recognises a 404 that gog reported without a reason word', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(errorResult('Error: Google API error (404): Requested entity was not found.'));
+    vi.mocked(lib.run).mockResolvedValue(LIST);
+    const result = await harness.callTool('gog_gmail_drafts_send', { draftId: 'd1' });
+    expect(result.content[0].text).toContain('DRAFT_FORKED');
+  });
+});
+
+// ===========================================================================
+// REQUIREMENT 5 — DO NOT LET AN ADOPTION SILENTLY DROP THE OTHER COPY'S TEXT.
+//
+// `draftComposeInput.validate()` (gmail_drafts.go:321) hard-requires a body on
+// every update: "required: --body, --body-file, --body-html, or
+// --body-html-file". There is no header-only edit, so re-threading a mail
+// client's replacement back onto the original conversation ALWAYS rewrites the
+// whole body — the exact operation that drops the paragraph living only in the
+// sibling copy. In the observed case neither copy was a superset.
+//
+// COST (hazard B): the check is opt-in and costs exactly ONE extra gog
+// invocation, on a NAMED sibling. It never scans, and with the param absent it
+// spends nothing and changes no argv.
+//
+// CLAIMS (hazard A): it compares two bodies. It never says one draft replaced
+// the other — that verdict needs gog_gmail_drafts_diff.
+// ===========================================================================
+describe('gog_gmail_drafts_update — content-loss check', () => {
+  const b64 = (s: string) => Buffer.from(s, 'utf8').toString('base64url');
+  const siblingGet = (body: string): string => JSON.stringify({
+    draft: { id: 's:14092347734530621658', message: { id: 'm2', threadId: 'm2', payload: { mimeType: 'text/plain', body: { data: b64(body) } } } },
+  });
+  const ACK = '{"draftId":"r4303011157206680397","threadId":"19f856becba0661d","inReplyTo":"<orig@mail.gmail.com>"}';
+
+  // The observed divergence: the mail-client copy kept a paragraph the merged
+  // body forgot.
+  const SIBLING_BODY = 'Thanks for the note.\nI can do the 14th.\nTHE PARAGRAPH ONLY APPLE HAS.\nBest, Chris';
+
+  it('spends nothing and changes no argv when no sibling is named', async () => {
+    await harness.callTool('gog_gmail_drafts_update', { draftId: 'd1', subject: 'S', body: 'B' });
+    expect(lib.run).not.toHaveBeenCalled();
+    expect(lib.runOrDiagnose).toHaveBeenCalledTimes(1);
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'drafts', 'update', 'd1', '--subject=S', '--body=B', '--auto-from-addressed-alias=false'],
+      { account: undefined },
+    );
+  });
+
+  it('costs exactly one extra invocation, and reads the sibling BEFORE writing', async () => {
+    vi.mocked(lib.run).mockResolvedValue(siblingGet(SIBLING_BODY));
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(ACK));
+    await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'r4303011157206680397', subject: 'S', body: SIBLING_BODY,
+      forkSiblingDraftId: 's:14092347734530621658',
+    });
+    expect(lib.run).toHaveBeenCalledTimes(1);
+    expect(lib.run).toHaveBeenCalledWith(
+      ['gmail', 'drafts', 'get', 's:14092347734530621658', '--use-indexed-attachment-ids=false'],
+      { account: undefined },
+    );
+    expect(lib.runOrDiagnose).toHaveBeenCalledTimes(1);
+    // Reading after the write would be a report on damage already done.
+    expect(vi.mocked(lib.run).mock.invocationCallOrder[0])
+      .toBeLessThan(vi.mocked(lib.runOrDiagnose).mock.invocationCallOrder[0]!);
+  });
+
+  it('writes, and reports the check, when the new body keeps every sibling line', async () => {
+    vi.mocked(lib.run).mockResolvedValue(siblingGet(SIBLING_BODY));
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(ACK));
+    const result = await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'r4303011157206680397', subject: 'S', body: `${SIBLING_BODY}\nplus a line the Gmail copy added`,
+      forkSiblingDraftId: 's:14092347734530621658', replyToThreadId: '19f856becba0661d',
+    });
+    expect(result.isError).toBeFalsy();
+    const parsed = JSON.parse(result.content[0].text as string);
+    expect(parsed.draftId).toBe('r4303011157206680397');
+    expect(parsed.contentLossCheck).toMatchObject({
+      siblingDraftId: 's:14092347734530621658', status: 'clean', linesOnlyInSibling: [],
+    });
+    // The adoption still reports what it actually threaded.
+    expect(parsed.threadingVerification.ok).toBe(true);
+  });
+
+  it('REFUSES the write when the body would drop a line the sibling holds — and writes nothing', async () => {
+    vi.mocked(lib.run).mockResolvedValue(siblingGet(SIBLING_BODY));
+    const result = await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'r4303011157206680397', subject: 'S',
+      body: 'Thanks for the note.\nI can do the 14th.\nBest, Chris',
+      forkSiblingDraftId: 's:14092347734530621658', replyToThreadId: '19f856becba0661d',
+    });
+    expect(result.isError).toBe(true);
+    // THE point: the draft is untouched.
+    expect(lib.runOrDiagnose).not.toHaveBeenCalled();
+    const text = result.content[0].text as string;
+    expect(text).toContain('DRAFT_CONTENT_LOSS');
+    expect(text).toContain('THE PARAGRAPH ONLY APPLE HAS.');
+    expect(text).toMatch(/nothing was written/i);
+    const parsed = JSON.parse(text.slice(text.indexOf('{')));
+    expect(parsed.contentLossCheck.status).toBe('would-lose');
+    expect(parsed.contentLossCheck.linesOnlyInSiblingCount).toBe(1);
+  });
+
+  it('writes anyway, with the loss spelled out, when acceptContentLoss is set', async () => {
+    vi.mocked(lib.run).mockResolvedValue(siblingGet(SIBLING_BODY));
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(ACK));
+    const result = await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'r4303011157206680397', subject: 'S', body: 'Thanks for the note.\nBest, Chris',
+      forkSiblingDraftId: 's:14092347734530621658', acceptContentLoss: true,
+    });
+    expect(result.isError).toBeFalsy();
+    expect(lib.runOrDiagnose).toHaveBeenCalledTimes(1);
+    const check = JSON.parse(result.content[0].text as string).contentLossCheck;
+    expect(check.status).toBe('would-lose');
+    expect(check.acknowledged).toBe(true);
+    expect(check.linesOnlyInSibling).toContain('THE PARAGRAPH ONLY APPLE HAS.');
+  });
+
+  it('refuses when the sibling cannot be fetched — an unrun check is not a passed check', async () => {
+    vi.mocked(lib.run).mockRejectedValue(new Error('Google API error (404 notFound): Requested entity was not found.'));
+    const result = await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'd1', subject: 'S', body: 'B', forkSiblingDraftId: 's:gone',
+    });
+    expect(result.isError).toBe(true);
+    expect(lib.runOrDiagnose).not.toHaveBeenCalled();
+    const text = result.content[0].text as string;
+    expect(text).toContain('DRAFT_CONTENT_LOSS_UNCHECKED');
+    expect(text).toContain('404 notFound');
+  });
+
+  it('refuses when the sibling fetch returned something with no readable body', async () => {
+    vi.mocked(lib.run).mockResolvedValue('not json at all');
+    const result = await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'd1', subject: 'S', body: 'B', forkSiblingDraftId: 's:weird',
+    });
+    expect(result.content[0].text).toContain('DRAFT_CONTENT_LOSS_UNCHECKED');
+    expect(lib.runOrDiagnose).not.toHaveBeenCalled();
+  });
+
+  it('refuses when the sibling parsed but carried no body text', async () => {
+    vi.mocked(lib.run).mockResolvedValue(JSON.stringify({ draft: { message: { payload: { mimeType: 'text/plain' } } } }));
+    const result = await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'd1', subject: 'S', body: 'B', forkSiblingDraftId: 's:empty',
+    });
+    expect(result.content[0].text).toContain('DRAFT_CONTENT_LOSS_UNCHECKED');
+    expect(lib.runOrDiagnose).not.toHaveBeenCalled();
+  });
+
+  it('lets acceptContentLoss override an unrunnable check too', async () => {
+    vi.mocked(lib.run).mockRejectedValue(new Error('boom'));
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(ACK));
+    const result = await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'd1', subject: 'S', body: 'B', forkSiblingDraftId: 's:gone', acceptContentLoss: true,
+    });
+    expect(result.isError).toBeFalsy();
+    expect(JSON.parse(result.content[0].text as string).contentLossCheck.status).toBe('unchecked');
+  });
+
+  it('degrades to a prose note when the write result is not a JSON object', async () => {
+    vi.mocked(lib.run).mockResolvedValue(siblingGet('kept'));
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult('Draft updated.'));
+    const result = await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'd1', subject: 'S', body: 'kept', forkSiblingDraftId: 's:1',
+    });
+    // The note is prepended; gog's own output is kept verbatim beneath it.
+    expect(result.content[0].text).toContain('contentLossCheck:');
+    expect(result.content[1].text).toBe('Draft updated.');
+  });
+
+  // HAZARD A. The caller names the sibling; this server does not decide the
+  // pair. Two unrelated drafts produce a total-divergence report, which is the
+  // same shape a real fork produces — so the answer must never read as a
+  // pairing verdict, and must point at the one tool that can issue one.
+  it('never claims the sibling is a fork, however the bodies compare', async () => {
+    vi.mocked(lib.run).mockResolvedValue(siblingGet('dentist appointment friday\ninsurance card is in the drawer'));
+    const result = await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'r4303011157206680397', subject: 'Re: August schedule', body: 'Entirely unrelated invoice text.',
+      forkSiblingDraftId: 's:unrelated',
+    });
+    const text = result.content[0].text as string;
+    const parsed = JSON.parse(text.slice(text.indexOf('{')));
+    expect(parsed.contentLossCheck.forkClaim).toBeNull();
+    expect(parsed.contentLossCheck.forkClaimNote).toContain('gog_gmail_drafts_diff');
+    expect(text).not.toMatch(/\bconfirmed\b/);
+    expect(text).not.toMatch(/replaced draft|is a fork of/i);
+  });
+
+  it('is not offered on drafts_create — there is no earlier body to lose', async () => {
+    const { tools } = await harness.client.listTools();
+    const create = tools.find((t) => t.name === 'gog_gmail_drafts_create');
+    const update = tools.find((t) => t.name === 'gog_gmail_drafts_update');
+    expect(Object.keys(create!.inputSchema.properties ?? {})).not.toContain('forkSiblingDraftId');
+    expect(Object.keys(update!.inputSchema.properties ?? {})).toContain('forkSiblingDraftId');
+  });
+});
+
+// ===========================================================================
+// CLAIMS CORRECTNESS — three things the reports asserted on evidence they did
+// not have. Each of these is a sentence a caller acts on: "the update WAS
+// written", "draft X no longer resolves", "these two drafts are the same
+// message". Getting any of them wrong costs real text in a legal-adjacent
+// correspondence, so each is pinned to the evidence that actually exists.
+// ===========================================================================
+
+// HAZARD A, through the real RPC path: two genuinely unrelated Apple Mail
+// drafts — different subjects, different threadIds, no shared reply root — that
+// agree on nothing but `Hi Jennifer,` / `Thanks,` / `Chris` /
+// `Sent from my iPhone`. That is 4 lines and 43 characters of pure apparatus,
+// and it used to clear all three lineage minimums and come back `confirmed`.
+describe('gog_gmail_drafts_diff — boilerplate is never lineage', () => {
+  const b64 = (s: string) => Buffer.from(s, 'utf8').toString('base64url');
+  const appleDraft = (o: { draftId: string; messageId: string; subject: string; date: string; sentence: string }) =>
+    JSON.stringify({
+      draft: {
+        id: o.draftId,
+        message: {
+          id: o.messageId, threadId: o.messageId, internalDate: o.date,
+          payload: {
+            mimeType: 'text/plain',
+            headers: [
+              { name: 'From', value: 'Chris Hall <chris@x.com>' },
+              { name: 'Subject', value: o.subject },
+              { name: 'Message-Id', value: `<${o.messageId}@apple.com>` },
+              { name: 'X-Universally-Unique-Identifier', value: o.messageId.toUpperCase() },
+            ],
+            body: { data: b64(`Hi Jennifer,\n\n${o.sentence}\n\nThanks,\nChris\n\nSent from my iPhone`) },
+          },
+        },
+      },
+    });
+
+  it('does not pair two unrelated notes that share only the greeting and the signature', async () => {
+    const A = appleDraft({ draftId: 'rOLD', messageId: 'aaa1', subject: 'Tuesday pickup', date: '1000', sentence: 'Tuesday pickup at 5 works for me.' });
+    const B = appleDraft({ draftId: 's:NEW', messageId: 'bbb2', subject: 'Orthodontist invoice', date: '2000', sentence: 'I paid the orthodontist invoice today.' });
+    vi.mocked(lib.run).mockImplementation(async (args) => ({ rOLD: A, 's:NEW': B }[(args as string[])[3]!]!));
+    const result = await harness.callTool('gog_gmail_drafts_diff', { draftIdA: 'rOLD', draftIdB: 's:NEW' });
+    const text = result.content[0].text as string;
+    const parsed = JSON.parse(text);
+    expect(parsed.forkPairing.verdict).toBe('none');
+    expect(parsed.forkPairing.bodyAgreement.meetsThreshold).toBe(false);
+    expect(parsed.forkPairing.bodyAgreement.sharedAuthoredLines).toBe(0);
+    expect(parsed.forkPairing.bodyAgreement.sharedAuthoredChars).toBe(0);
+    expect(parsed.forkPairing.bodyAgreement.boilerplateLinesIgnored).toEqual({ original: 4, candidate: 4 });
+    expect(text).not.toContain('replaced draft');
+    expect(text).not.toContain('All four signals are present');
+    // The divergence report is a DIFFERENT question and stays honest: the
+    // apparatus really is text both copies hold.
+    expect(parsed.bodyDiff.sharedLineCount).toBe(4);
+  });
+});
+
+describe('gog_gmail_drafts_diff — truncation reports its magnitude, and the cap is validated', () => {
+  const b64 = (s: string) => Buffer.from(s, 'utf8').toString('base64url');
+  const body = (tag: string, n: number) => JSON.stringify({
+    draft: { id: tag, message: { id: tag, threadId: tag, internalDate: '1', payload: { mimeType: 'text/plain', headers: [], body: { data: b64(Array.from({ length: n }, (_, i) => `${tag}-${i}`).join('\n')) } } } },
+  });
+
+  beforeEach(() => {
+    vi.mocked(lib.run).mockImplementation(async (args) => body((args as string[])[3]!, 500));
+  });
+
+  it('says how many lines each side actually held, not just that it truncated', async () => {
+    const parsed = JSON.parse((await harness.callTool('gog_gmail_drafts_diff', { draftIdA: 'a', draftIdB: 'b' })).content[0].text);
+    expect(parsed.bodyDiff.onlyInA).toHaveLength(200);
+    expect(parsed.bodyDiff.truncated).toBe(true);
+    // Without these the caller cannot tell 200-of-201 from 200-of-500, and the
+    // whole point of the diff is deciding what to merge before an overwrite.
+    expect(parsed.bodyDiff.onlyInACount).toBe(500);
+    expect(parsed.bodyDiff.onlyInBCount).toBe(500);
+    expect(parsed.bodyDiff.note).toContain('500');
+  });
+
+  it('rejects maxDiffLines 0 and negatives instead of printing an empty divergence report', async () => {
+    const zero = await harness.callTool('gog_gmail_drafts_diff', { draftIdA: 'a', draftIdB: 'b', maxDiffLines: 0 });
+    expect(zero.isError).toBe(true);
+    const negative = await harness.callTool('gog_gmail_drafts_diff', { draftIdA: 'a', draftIdB: 'b', maxDiffLines: -1 });
+    expect(negative.isError).toBe(true);
+    const fractional = await harness.callTool('gog_gmail_drafts_diff', { draftIdA: 'a', draftIdB: 'b', maxDiffLines: 1.5 });
+    expect(fractional.isError).toBe(true);
+  });
+});
+
+describe('gog_gmail_drafts_list — the threading note is emitted once, not per row', () => {
+  const rows = (n: number) => JSON.stringify({
+    drafts: Array.from({ length: n }, (_, i) => ({ id: `r${i}`, messageId: `m${i}`, threadId: i % 2 === 0 ? `m${i}` : `t${i}` })),
+  });
+
+  it('carries both note variants at the top level and none on the rows', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult(rows(20)));
+    const text = (await harness.callTool('gog_gmail_drafts_list', {})).content[0].text as string;
+    const parsed = JSON.parse(text);
+    for (const d of parsed.drafts) expect(d).not.toHaveProperty('threadingNote');
+    expect(parsed.threadingNotes.rootsOwnThread).toContain('NEW conversation');
+    expect(parsed.threadingNotes.inThread).toContain('existing thread');
+    // The selector stays on the row, so the note still resolves per draft.
+    expect(parsed.drafts[0].rootsOwnThread).toBe(true);
+    expect(parsed.drafts[1].rootsOwnThread).toBe(false);
+    // ~300 chars x 20 rows of a constant is a per-call token cost that carries
+    // no information. Still exactly one gog spawn — hazard B was never the
+    // issue here.
+    expect(text.length).toBeLessThan(3000);
+    expect(lib.run).not.toHaveBeenCalled();
+  });
+});
+
+// A caller who believes "the update WAS written" may delete or overwrite the
+// sibling that now holds the only copy of the lines the check just listed.
+describe('gog_gmail_drafts_update — acceptContentLoss reports the write that ACTUALLY happened', () => {
+  const b64 = (s: string) => Buffer.from(s, 'utf8').toString('base64url');
+  const SIBLING = JSON.stringify({
+    draft: { id: 's:sib', message: { id: 'm2', threadId: 'm2', payload: { mimeType: 'text/plain', body: { data: b64('kept line\nTHE PARAGRAPH ONLY THE SIBLING HAS.') } } } },
+  });
+  const call = () => harness.callTool('gog_gmail_drafts_update', {
+    draftId: 'r43', subject: 'S', body: 'kept line', forkSiblingDraftId: 's:sib', acceptContentLoss: true,
+  });
+
+  it('says the write was ATTEMPTED AND FAILED when gog returned a plain error', async () => {
+    vi.mocked(lib.run).mockResolvedValue(SIBLING);
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(errorResult('Error: gog: permission denied'));
+    const result = await call();
+    expect(result.isError).toBe(true);
+    const text = result.content.map((c: { text?: string }) => c.text).join('\n');
+    expect(text).not.toContain('WAS written');
+    expect(text).toMatch(/FAILED/);
+    expect(text).toMatch(/nothing was saved/i);
+  });
+
+  it('does not claim a write on the 404 path, where it also says the draft is gone', async () => {
+    vi.mocked(lib.run).mockImplementation(async (args) => {
+      const a = args as string[];
+      if (a[2] === 'get') return SIBLING;
+      if (a[2] === 'list') return JSON.stringify({ drafts: [{ id: 's:sib', messageId: 'm2', threadId: 'm2' }] });
+      return JSON.stringify({ messages: [] });
+    });
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(errorResult('Error: Google API error (404 notFound): Requested entity was not found.'));
+    const result = await call();
+    // A result that says the draft no longer exists AND that the update was
+    // written is self-contradictory, and the caller acts on the second half.
+    const text = result.content.map((c: { text?: string }) => c.text).join('\n');
+    expect(text).toContain('DRAFT_FORKED');
+    expect(text).not.toContain('WAS written');
+    expect(text).toMatch(/FAILED/);
+    expect(text).toMatch(/NOTHING WAS SAVED/i);
+  });
+
+  it('still says the update WAS written when the write succeeded', async () => {
+    vi.mocked(lib.run).mockResolvedValue(SIBLING);
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(rawTextResult('{"draftId":"r43"}'));
+    const result = await call();
+    expect(result.isError).toBeFalsy();
+    const parsed = JSON.parse(result.content[0].text as string);
+    expect(parsed.contentLossCheck.written).toBe(true);
+    expect(parsed.contentLossCheck.acknowledged).toBe(true);
+    expect(parsed.contentLossCheck.note).toContain('WAS written');
+  });
+});
+
+// `not listed` is not `does not exist`. The fork report's listing is capped at
+// 20 by construction (it is a failure path and must not grow with the mailbox),
+// so on a mailbox with more drafts than that, absence of evidence was becoming
+// the fork story by default — and sending the caller hunting for a replacement
+// that does not exist is exactly the cost this report was built to avoid.
+describe('gog_gmail_drafts_update — DRAFT_FORKED states what its listing can and cannot show', () => {
+  const NOT_FOUND = 'Error: Google API error (404 notFound): Requested entity was not found.';
+  const fullWindow = JSON.stringify({
+    drafts: Array.from({ length: 20 }, (_, i) => ({ id: `r${i}`, messageId: `m${i}`, threadId: `t${i}` })),
+  });
+  const shortWindow = JSON.stringify({ drafts: [{ id: 'r1', messageId: 'm1', threadId: 't1' }] });
+
+  function stub(list: string): void {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(errorResult(NOT_FOUND));
+    vi.mocked(lib.run).mockImplementation(async (args) => {
+      const a = args as string[];
+      if (a[2] === 'list') return list;
+      return JSON.stringify({ messages: [] });
+    });
+  }
+  const parse = (result: { content: Array<{ text?: string }> }) => {
+    const text = result.content[0].text as string;
+    return { text, parsed: JSON.parse(text.slice(text.indexOf('{'))) };
+  };
+
+  it('does not assert the draft is gone when the 20-draft window came back FULL', async () => {
+    stub(fullWindow);
+    const { text, parsed } = parse(await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'rSTILL_EXISTS_BUT_RANK_25', subject: 'S', body: 'B',
+    }));
+    expect(text).not.toMatch(/no longer resolves/);
+    expect(parsed.listingEvidence.basis).toBe('capped-listing');
+    expect(parsed.listingEvidence.windowSize).toBe(20);
+    expect(parsed.listingEvidence.draftsListed).toBe(20);
+    expect(parsed.listingEvidence.note).toMatch(/not evidence|does not establish/i);
+    expect(parsed.listingEvidence.note).toContain('gog_gmail_drafts_list');
+  });
+
+  it('does assert it when the listing came back SHORT of the window, so it covered the folder', async () => {
+    stub(shortWindow);
+    const { text, parsed } = parse(await harness.callTool('gog_gmail_drafts_update', { draftId: 'rGONE', subject: 'S', body: 'B' }));
+    expect(text).toMatch(/no longer resolves/);
+    expect(parsed.listingEvidence.basis).toBe('complete-listing');
+    expect(parsed.listingEvidence.draftsListed).toBe(1);
+  });
+
+  it('claims nothing about the draft when the listing itself failed', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(errorResult(NOT_FOUND));
+    vi.mocked(lib.run).mockRejectedValue(new Error('gog timed out after 30s'));
+    const { text, parsed } = parse(await harness.callTool('gog_gmail_drafts_update', { draftId: 'rUNKNOWN', subject: 'S', body: 'B' }));
+    expect(text).not.toMatch(/no longer resolves/);
+    expect(parsed.listingEvidence.basis).toBe('listing-unavailable');
+    expect(parsed.listingEvidence.note).toMatch(/failed/i);
+  });
+
+  // The branch that CANNOT confirm the fork story was also the one whose
+  // explanations omitted the leading alternative the caller literally handed it.
+  it('carries the reply target and names it as an explanation', async () => {
+    stub(fullWindow);
+    const { parsed } = parse(await harness.callTool('gog_gmail_drafts_update', {
+      draftId: 'rUNSEEN', subject: 'S', body: 'B', replyToThreadId: 'STALE-THREAD',
+    }));
+    expect(parsed.replyTarget).toEqual({ via: 'replyToThreadId', target: 'STALE-THREAD' });
+    expect(parsed.otherExplanations.join(' ')).toMatch(/replyToThreadId=STALE-THREAD/);
+    expect(parsed.otherExplanations.join(' ')).toMatch(/not the draft|reply target/i);
+  });
+
+  it('omits the reply-target explanation when the call named no target', async () => {
+    stub(shortWindow);
+    const { parsed } = parse(await harness.callTool('gog_gmail_drafts_send', { draftId: 'rGONE' }));
+    expect(parsed.replyTarget).toBeNull();
+    expect(parsed.otherExplanations.join(' ')).not.toMatch(/reply target/i);
   });
 });