diff --git a/app/e2e-mock-ipc.js b/app/e2e-mock-ipc.js
index 1ed12fb5..7b0558ff 100644
--- a/app/e2e-mock-ipc.js
+++ b/app/e2e-mock-ipc.js
@@ -525,6 +525,48 @@ function install({ ipcMain }) {
       return { success: true, path: seamPath };
     },
 
+    // Share capability. Injectable precisely because the real answer is a
+    // platform fact: gating the renderer on this instead of navigator.platform
+    // is what lets a T1 spec exercise BOTH branches on any OS, including the
+    // absent branch that keeps Windows away from a ShareMenu it does not have.
+    'share-capability': async () => process.env.STENOAI_E2E_SHARE_CAPABLE === '1',
+
+    // Mirror the real share-note-file handler far enough to observe the call.
+    // Appends one JSON line per call to STENOAI_E2E_SHARE_LOG so a spec can
+    // count calls (the pending guard) and read back what was passed. No file is
+    // materialised and no sheet is popped: that is the real handler's job and
+    // the T2 spec's assertion. STENOAI_E2E_SHARE_DELAY_MS holds the call open so
+    // the "Preparing…" state is observable without racing the clock.
+    //
+    // STENOAI_E2E_SHARE_PAYLOAD_PATH writes the payload VERBATIM, the same seam
+    // STENOAI_E2E_EXPORT_PATH gives the save path. The log's 200-char head is
+    // enough to tell a PDF from markdown, but a branded PDF's first 200 chars
+    // are doctype and font CSS — the note itself is thousands of characters in,
+    // so asserting WHICH note was shared needs the whole payload.
+    'share-note-file': async (_event, kind, defaultFilename, payload, anchor) => {
+      const logPath = process.env.STENOAI_E2E_SHARE_LOG;
+      if (logPath) {
+        fs.appendFileSync(
+          logPath,
+          JSON.stringify({
+            kind,
+            defaultFilename,
+            anchor,
+            payloadLength: typeof payload === 'string' ? payload.length : null,
+            payloadHead: typeof payload === 'string' ? payload.slice(0, 200) : null,
+          }) + '\n',
+          'utf-8',
+        );
+      }
+      const payloadPath = process.env.STENOAI_E2E_SHARE_PAYLOAD_PATH;
+      if (payloadPath && typeof payload === 'string') {
+        fs.writeFileSync(payloadPath, payload, 'utf-8');
+      }
+      const delay = Number(process.env.STENOAI_E2E_SHARE_DELAY_MS || 0);
+      if (delay > 0) await new Promise((resolve) => setTimeout(resolve, delay));
+      return { success: true };
+    },
+
     'org-status': async () => {
       if (!state.orgSession) {
         return { signedIn: false, everSignedIn: state.everSignedIn };
diff --git a/app/main.js b/app/main.js
index 413cb0df..e4fc6e17 100644
--- a/app/main.js
+++ b/app/main.js
@@ -62,6 +62,7 @@ const { isOSUpdateEligible, MIN_MACOS_FOR_AUTOUPDATE } = require('./update-os-ga
 const processingLog = require('./processing-log');
 const { isMeetingApp, allowsDeviceLevelFallback, isMacos14Plus } = require('./meeting-detect');
 const { sweepOrphanedLiveSnapshots } = require('./live-snapshot-sweep');
+const { shareTempDir, sweepShareTemp, SHARE_TEMP_MAX_AGE_MS } = require('./share-temp');
 const { userNotesFilePath } = require('./notes-file');
 const { makeLineReader } = require('./backend-stream');
 // Pure deep-link (stenoai://) parsing/sanitizing lives in ./shortcut-url
@@ -113,6 +114,24 @@ if (process.env.STENOAI_USER_DATA_DIR) {
   app.setPath('userData', process.env.STENOAI_USER_DATA_DIR);
 }
 const IS_E2E = process.env.STENOAI_E2E === '1';
+// The subset of the harness that redirects WHERE BYTES GO: the STENOAI_E2E_*_PATH
+// seams in export-transcript / export-note-pdf / save-diagnostics, and the
+// path-returning seam in share-note-file. Those need a second condition beyond
+// IS_E2E, because IS_E2E is nothing but an environment variable: a signed build
+// started with STENOAI_E2E=1 plus one of those paths would silently write a
+// user's export to an attacker-chosen location instead of the file they picked
+// in the save dialog, and never show the dialog at all.
+//
+// `!app.isPackaged` is the right second condition rather than a stricter one:
+// every e2e lane launches the DEV binary from source (`electron.launch({ args:
+// ['.'] })` in e2e/fixtures/electron.ts, and the release gate's T1 smoke runs
+// the same way), so no legitimate test run is packaged. A packaged build now
+// ignores these seams entirely, whatever it is started with.
+//
+// Deliberately NOT folded into IS_E2E itself: its other ~30 uses gate the tray,
+// the dock, the scheduler and telemetry, and re-gating those on packaging would
+// be a far wider behavioural change than closing this hole.
+const ALLOW_E2E_PATH_SEAMS = IS_E2E && !app.isPackaged;
 const IS_E2E_MOCK_IPC = process.env.STENOAI_E2E_MOCK_IPC === '1';
 
 // Global (system-wide) accelerator to toggle recording. CommandOrControl
@@ -2182,6 +2201,25 @@ if (!gotSingleInstanceLock) {
       console.warn('Live-snapshot sweep failed (non-fatal):', e?.message);
     }
 
+    // Sweep share-sheet temp files older than a day. This is the ONLY cleanup
+    // for that directory: a file handed to ShareMenu must survive as long as the
+    // destination holds it (an open Mail draft, an AirDrop transfer waiting to be
+    // accepted), and popup() never reports when that ends - so nothing is deleted
+    // during a session. See share-temp.js for the full reasoning. Best-effort: an
+    // undeletable temp directory must not interrupt a launch.
+    try {
+      const { deleted } = sweepShareTemp(
+        shareTempDir(app.getPath('temp')),
+        Date.now(),
+        SHARE_TEMP_MAX_AGE_MS,
+      );
+      if (deleted.length > 0) {
+        sendDebugLog(`Swept ${deleted.length} stale share temp file(s)`);
+      }
+    } catch (e) {
+      console.warn('Share temp sweep failed (non-fatal):', e?.message);
+    }
+
     // Load custom storage path for file validation. Skipped under E2E (spawns
     // the backend; the test tiers keep startup backend-free).
     if (!IS_E2E) {
@@ -3759,9 +3797,10 @@ ipcMain.handle('export-transcript', async (event, defaultFilename, content) => {
       return { success: false, error: 'No transcript content to export.' };
     }
 
-    // Test-only seam: only honor it under e2e, so a stray env var in a real
-    // launch can't silently redirect a user's export to an arbitrary path.
-    const seamPath = IS_E2E ? process.env.STENOAI_E2E_EXPORT_PATH : undefined;
+    // Test-only seam: honored only in an UNPACKAGED e2e run, so a stray env var
+    // in a real launch can't silently redirect a user's export to an arbitrary
+    // path. See ALLOW_E2E_PATH_SEAMS - IS_E2E alone is just an env var.
+    const seamPath = ALLOW_E2E_PATH_SEAMS ? process.env.STENOAI_E2E_EXPORT_PATH : undefined;
     let targetPath = seamPath;
 
     if (!targetPath) {
@@ -3883,9 +3922,10 @@ ipcMain.handle('export-note-pdf', async (event, defaultFilename, html) => {
       return { success: false, error: 'No notes content to export.' };
     }
 
-    // Test-only seam: only honor it under e2e, so a stray env var in a real
-    // launch can't silently redirect a user's export to an arbitrary path.
-    const seamPath = IS_E2E ? process.env.STENOAI_E2E_EXPORT_PATH : undefined;
+    // Test-only seam: honored only in an UNPACKAGED e2e run (see
+    // ALLOW_E2E_PATH_SEAMS), so a stray env var in a real launch can't silently
+    // redirect a user's export to an arbitrary path.
+    const seamPath = ALLOW_E2E_PATH_SEAMS ? process.env.STENOAI_E2E_EXPORT_PATH : undefined;
     let targetPath = seamPath;
 
     if (!targetPath) {
@@ -3937,9 +3977,10 @@ ipcMain.handle('save-diagnostics', async (event, defaultFilename, content) => {
       return { success: false, error: 'No diagnostics content to save.' };
     }
 
-    // Test-only seam: only honor it under e2e, so a stray env var in a real
-    // launch can't silently redirect a user's save to an arbitrary path.
-    const seamPath = IS_E2E ? process.env.STENOAI_E2E_DIAGNOSTICS_PATH : undefined;
+    // Test-only seam: honored only in an UNPACKAGED e2e run (see
+    // ALLOW_E2E_PATH_SEAMS), so a stray env var in a real launch can't silently
+    // redirect a user's save to an arbitrary path.
+    const seamPath = ALLOW_E2E_PATH_SEAMS ? process.env.STENOAI_E2E_DIAGNOSTICS_PATH : undefined;
     let targetPath = seamPath;
 
     if (!targetPath) {
@@ -3978,6 +4019,129 @@ ipcMain.handle('save-diagnostics', async (event, defaultFilename, content) => {
   }
 });
 
+// Whether a native share sheet actually exists on this machine. macOS-only:
+// Electron exposes ShareMenu on darwin and nothing anywhere else. The second
+// half of the check is not paranoia - if a future Electron drops or renames the
+// export, this degrades to a hidden menu group instead of a main-process crash
+// on `new undefined(...)`.
+function shareSheetAvailable() {
+  if (process.platform !== 'darwin') return false;
+  try {
+    return typeof require('electron').ShareMenu === 'function';
+  } catch (_) {
+    return false;
+  }
+}
+
+// The renderer asks once and hides the three share entries when this is false.
+// That flag is only a hint for what to draw; the handler below re-checks, which
+// is what actually keeps a stray call from crashing the process.
+ipcMain.handle('share-capability', () => shareSheetAvailable());
+
+// Hand a note to the native macOS share sheet (AirDrop, Mail, Messages, Notes).
+// Follows the same split as the three export handlers above: the renderer builds
+// the content, we own the bytes. Differences from them, all deliberate:
+//   - No save dialog. The destination is our own managed temp directory, because
+//     the sheet needs a real file and the user never picks a location.
+//   - The filename is user-visible: it becomes the attachment name the recipient
+//     reads, so defaultExportFilename()'s dated slug is used as-is.
+//   - Files are never deleted during the session (see share-temp.js).
+// Returns { success } only; success means the sheet opened, since popup() has no
+// completion callback and the app never learns the destination.
+ipcMain.handle('share-note-file', async (event, kind, defaultFilename, payload, anchor) => {
+  try {
+    if (kind !== 'pdf' && kind !== 'text') {
+      return { success: false, error: 'Unsupported share type.' };
+    }
+    if (typeof payload !== 'string' || payload.length === 0) {
+      return { success: false, error: 'No content to share.' };
+    }
+
+    // Fail before rendering: a stray call off darwin must not pay for a 15
+    // second PDF render just to be refused. In an unpackaged e2e run we
+    // deliberately continue on every platform, because the file write is what
+    // those specs assert and T2 runs on Windows too.
+    if (!ALLOW_E2E_PATH_SEAMS && !shareSheetAvailable()) {
+      return { success: false, error: 'Sharing is not available on this platform.' };
+    }
+
+    // The renderer supplies a suggested name only. Unlike the export handlers,
+    // where the reduced name merely seeds a dialog the user confirms, here it is
+    // joined onto a directory we write into - so `.` and `..` have to be rejected
+    // as well, not just directory components.
+    const fallback = kind === 'pdf' ? 'notes.pdf' : 'notes.md';
+    let base = fallback;
+    if (typeof defaultFilename === 'string' && defaultFilename.trim()) {
+      const reduced = path.basename(defaultFilename).slice(0, 200);
+      if (reduced && reduced !== '.' && reduced !== '..') base = reduced;
+    }
+
+    const dir = shareTempDir(app.getPath('temp'));
+    const targetPath = path.join(dir, base);
+
+    // Rasterise BEFORE touching the destination, so a render failure leaves no
+    // file behind. Mirrors export-note-pdf.
+    const bytes = kind === 'pdf' ? await renderHtmlToPdf(payload) : payload;
+
+    // Atomic write: tmp file in the SAME directory, then rename into place.
+    // Sharing the same note twice overwrites the first file, which is fine: the
+    // content is identical and Mail copies an attachment into the draft. The
+    // exception, since the name is deliberately not randomised: another process
+    // running as the same user could have planted a file of that name in this
+    // directory first, and the rename would replace it. Accepted - the filename
+    // has to stay the readable one the recipient sees, and anyone who can write
+    // here can already read the notes we put here.
+    const tmpPath = path.join(dir, `.${base}.${require('crypto').randomBytes(6).toString('hex')}.tmp`);
+    try {
+      await fs.promises.writeFile(tmpPath, bytes, kind === 'pdf' ? undefined : 'utf-8');
+      await fs.promises.rename(tmpPath, targetPath);
+    } catch (writeErr) {
+      try { await fs.promises.unlink(tmpPath); } catch (_) {}
+      throw writeErr;
+    }
+
+    // Test-only seam, mirroring STENOAI_E2E_EXPORT_PATH: a native sheet cannot be
+    // automated (Playwright can neither see nor dismiss it, and an open sheet
+    // blocks the run), so under e2e we stop after the write and return where the
+    // file went. The path is returned ONLY here - outside the seam the renderer
+    // has no business knowing, and a leaked absolute path is exactly what the
+    // basename reduction exists to prevent.
+    if (ALLOW_E2E_PATH_SEAMS) return { success: true, path: targetPath };
+
+    // Re-check rather than trust the entry gate above: this is the line that
+    // stops `new undefined(...)` from taking the main process down.
+    if (!shareSheetAvailable()) {
+      return { success: false, error: 'Sharing is not available on this platform.' };
+    }
+    if (!mainWindow || mainWindow.isDestroyed()) {
+      return { success: false, error: 'No window to share from.' };
+    }
+    const { ShareMenu } = require('electron');
+    const menu = new ShareMenu({ filePaths: [targetPath] });
+    // Anchor on the clicked entry so the sheet pops from the button rather than
+    // the window corner. The rectangle was read up to 15 seconds ago, before the
+    // PDF render, so a scroll, a window move or a resize can have moved it, and
+    // after a shrink it can sit outside the window entirely. An out-of-range
+    // anchor is worse than none: dropping it lets Electron place the sheet with
+    // coordinates that are at least current. A malformed anchor is dropped for
+    // the same reason rather than defaulted to 0,0.
+    const popupOptions = { window: mainWindow };
+    if (anchor && Number.isFinite(anchor.x) && Number.isFinite(anchor.y)) {
+      const { width, height } = mainWindow.getContentBounds();
+      const x = Math.round(anchor.x);
+      const y = Math.round(anchor.y);
+      if (x >= 0 && y >= 0 && x <= width && y <= height) {
+        popupOptions.x = x;
+        popupOptions.y = y;
+      }
+    }
+    menu.popup(popupOptions);
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: String(err && err.message ? err.message : err) };
+  }
+});
+
 // Replace (or remove, when empty) the "## User Notes" section at the tail of a
 // meeting markdown body. Kept a pure string transform so it's unit-testable and
 // never touches the summary/transcript sections above it. `body` is everything
diff --git a/app/package.json b/app/package.json
index 904fc7bc..c16269ff 100644
--- a/app/package.json
+++ b/app/package.json
@@ -19,7 +19,7 @@
     "typecheck:renderer": "tsc -p renderer/tsconfig.json --noEmit",
     "lint:renderer": "eslint --config renderer/eslint.config.mjs renderer/src",
     "format:renderer": "prettier --write renderer/src",
-    "test:unit": "node --test processing-log.test.js meeting-detect.test.js notes-file.test.js backend-stream.test.js ipc-contract.test.js shortcut-url.test.js setup-check-parse.test.js diagnostics-forward.test.js analytics-helpers.test.js live-snapshot-sweep.test.js backend-cli.test.js debug-log.test.js teardown.test.js folders-ipc.test.js settings-ipc.test.js regen-title-busy-guard.test.js update-idle-gate.test.js update-os-gate.test.js update-error-copy.test.js && vitest run",
+    "test:unit": "node --test processing-log.test.js meeting-detect.test.js notes-file.test.js backend-stream.test.js ipc-contract.test.js shortcut-url.test.js setup-check-parse.test.js diagnostics-forward.test.js analytics-helpers.test.js live-snapshot-sweep.test.js backend-cli.test.js debug-log.test.js teardown.test.js folders-ipc.test.js settings-ipc.test.js regen-title-busy-guard.test.js update-idle-gate.test.js update-os-gate.test.js update-error-copy.test.js share-temp.test.js && vitest run",
     "build": "npm run build:renderer && electron-builder",
     "pack:unsigned": "npm run build:renderer && electron-builder --dir --config electron-builder.ci.yml",
     "build-mac": "npm run build:renderer && electron-builder --mac",
diff --git a/app/preload.js b/app/preload.js
index 6b7a50a5..1f97bae1 100644
--- a/app/preload.js
+++ b/app/preload.js
@@ -346,6 +346,16 @@ const stenoai = {
     chatStream: (streamId, payload) => send('org-chat-stream', streamId, payload),
   },
 
+  // Native macOS share sheet. canShare answers "does a share sheet exist here",
+  // NOT "does the user agent look like a Mac" - the renderer's isMac is a
+  // module-level navigator.platform constant frozen at import, so it can neither
+  // be flipped at runtime nor exercised in both directions by a test.
+  share: {
+    canShare: () => invoke('share-capability'),
+    shareFile: (kind, defaultFilename, payload, anchor) =>
+      invoke('share-note-file', kind, defaultFilename, payload, anchor),
+  },
+
   dialog: {
     respondQuit: (confirmed) => send('quit-dialog-response', { confirmed }),
   },
diff --git a/app/renderer/src/lib/ipc.ts b/app/renderer/src/lib/ipc.ts
index 04f35f3b..6323ecdb 100644
--- a/app/renderer/src/lib/ipc.ts
+++ b/app/renderer/src/lib/ipc.ts
@@ -1193,6 +1193,27 @@ export interface StenoaiBridge {
     chatStream: SendFn<[streamId: string, payload: OrgChatPayload]>;
   };
 
+  share: {
+    /** Whether a native share sheet exists on this machine (macOS only). Treat
+     *  an unresolved query as false so the entries never flash in before the
+     *  capability is known. */
+    canShare: RequestFn<[], boolean>;
+    /** Write the payload into the managed share temp directory and pop the
+     *  native sheet on it. `kind: 'pdf'` takes HTML and rasterises it first;
+     *  `'text'` is written as UTF-8. `anchor` is a point in window coordinates
+     *  so the sheet pops from the clicked entry. `success` means only that the
+     *  sheet opened - the destination is never reported back. */
+    shareFile: RequestFn<
+      [
+        kind: 'pdf' | 'text',
+        defaultFilename: string,
+        payload: string,
+        anchor: { x: number; y: number },
+      ],
+      Result<Record<string, never>>
+    >;
+  };
+
   dialog: {
     respondQuit: SendFn<[confirmed: boolean]>;
   };
diff --git a/app/renderer/src/lib/notesMarkdown.test.ts b/app/renderer/src/lib/notesMarkdown.test.ts
new file mode 100644
index 00000000..44dcf921
--- /dev/null
+++ b/app/renderer/src/lib/notesMarkdown.test.ts
@@ -0,0 +1,129 @@
+import { describe, expect, test } from 'vitest';
+import type { StructuredNoteSections } from './notesCopy';
+import { buildNotesMarkdown } from './notesMarkdown';
+
+const fullSections: StructuredNoteSections = {
+  name: 'Weekly *sync*',
+  meta: 'Mon, Jun 23, 2026, 10:00 AM · 45m',
+  summary: 'We discussed **the roadmap**.',
+  discussionAreas: [
+    {
+      title: 'Roadmap & scope',
+      analysis: 'Q3 priorities [agreed](https://example.com/roadmap).',
+    },
+    { title: 'Hiring' },
+  ],
+  keyPoints: ['Ship `v2` in July'],
+  actionItems: ['Ben: prepare <the draft>'],
+  participants: ['Ben', 'Ruzin & Alex'],
+};
+
+describe('buildNotesMarkdown', () => {
+  test('renders every structured field in copy-export order without escaping body text', () => {
+    expect(buildNotesMarkdown(fullSections, null)).toBe(
+      [
+        '# Weekly *sync*',
+        'Mon, Jun 23, 2026, 10:00 AM · 45m',
+        '',
+        '## Summary',
+        '',
+        'We discussed **the roadmap**.',
+        '',
+        '## Key Topics',
+        '',
+        '### Roadmap & scope',
+        '',
+        'Q3 priorities [agreed](https://example.com/roadmap).',
+        '',
+        '### Hiring',
+        '',
+        '## Key Points',
+        '',
+        '- Ship `v2` in July',
+        '',
+        '## Action Items',
+        '',
+        '- Ben: prepare <the draft>',
+        '',
+        '## Participants',
+        '',
+        'Ben, Ruzin & Alex',
+      ].join('\n'),
+    );
+  });
+
+  test('removing any handled structured field changes the output', () => {
+    const complete = buildNotesMarkdown(fullSections, null);
+    const removals: Array<[string, StructuredNoteSections]> = [
+      ['title', { ...fullSections, name: '' }],
+      ['meta', { ...fullSections, meta: undefined }],
+      ['summary', { ...fullSections, summary: undefined }],
+      [
+        'discussion title',
+        {
+          ...fullSections,
+          discussionAreas: [
+            { analysis: fullSections.discussionAreas[0].analysis, title: '' },
+            fullSections.discussionAreas[1],
+          ],
+        },
+      ],
+      [
+        'discussion analysis',
+        {
+          ...fullSections,
+          discussionAreas: [
+            { title: fullSections.discussionAreas[0].title },
+            fullSections.discussionAreas[1],
+          ],
+        },
+      ],
+      ['discussion areas', { ...fullSections, discussionAreas: [] }],
+      ['key points', { ...fullSections, keyPoints: [] }],
+      ['action items', { ...fullSections, actionItems: [] }],
+      ['participants', { ...fullSections, participants: [] }],
+    ];
+
+    removals.forEach(([field, sections]) => {
+      expect(buildNotesMarkdown(sections, null), field).not.toBe(complete);
+    });
+  });
+
+  test('omits every empty section without leaving a heading', () => {
+    const markdown = buildNotesMarkdown(
+      {
+        name: 'Empty note',
+        summary: '   ',
+        discussionAreas: [],
+        keyPoints: [],
+        actionItems: [],
+        participants: [],
+      },
+      null,
+    );
+
+    expect(markdown).toBe('# Empty note');
+    expect(markdown).not.toContain('## Summary');
+    expect(markdown).not.toContain('## Key Topics');
+    expect(markdown).not.toContain('## Key Points');
+    expect(markdown).not.toContain('## Action Items');
+    expect(markdown).not.toContain('## Participants');
+  });
+
+  test('an open active report preserves title and meta while replacing the structured body', () => {
+    const content = '## 1:1 Notes\n\n- Roadmap <locked>\n';
+    const markdown = buildNotesMarkdown(fullSections, { content });
+
+    expect(markdown).toBe(
+      [
+        '# Weekly *sync*',
+        'Mon, Jun 23, 2026, 10:00 AM · 45m',
+        '',
+        content,
+      ].join('\n'),
+    );
+    expect(markdown).not.toContain('## Summary');
+    expect(markdown).not.toContain('## Key Topics');
+    expect(buildNotesMarkdown(fullSections, { content: '' })).not.toBe(markdown);
+  });
+});
diff --git a/app/renderer/src/lib/notesMarkdown.ts b/app/renderer/src/lib/notesMarkdown.ts
new file mode 100644
index 00000000..f16379c0
--- /dev/null
+++ b/app/renderer/src/lib/notesMarkdown.ts
@@ -0,0 +1,49 @@
+import type { StructuredNoteSections } from './notesCopy';
+
+function hasText(value: string | undefined): value is string {
+  return Boolean(value?.trim());
+}
+
+export function buildNotesMarkdown(
+  sections: StructuredNoteSections,
+  activeReport: { content: string } | null,
+): string {
+  const titleBlock = [`# ${sections.name}`];
+  if (sections.meta) titleBlock.push(sections.meta);
+
+  const blocks: string[] = [titleBlock.join('\n')];
+
+  if (activeReport) {
+    if (hasText(activeReport.content)) blocks.push(activeReport.content);
+    return blocks.join('\n\n');
+  }
+
+  if (hasText(sections.summary)) {
+    blocks.push(`## Summary\n\n${sections.summary}`);
+  }
+
+  if (sections.discussionAreas.length) {
+    const topics = sections.discussionAreas
+      .map((area) => {
+        const topic = [`### ${area.title}`];
+        if (hasText(area.analysis)) topic.push('', area.analysis);
+        return topic.join('\n');
+      })
+      .join('\n\n');
+    blocks.push(`## Key Topics\n\n${topics}`);
+  }
+
+  if (sections.keyPoints.length) {
+    blocks.push(`## Key Points\n\n${sections.keyPoints.map((point) => `- ${point}`).join('\n')}`);
+  }
+
+  if (sections.actionItems.length) {
+    blocks.push(`## Action Items\n\n${sections.actionItems.map((item) => `- ${item}`).join('\n')}`);
+  }
+
+  if (sections.participants.length) {
+    blocks.push(`## Participants\n\n${sections.participants.join(', ')}`);
+  }
+
+  return blocks.join('\n\n');
+}
diff --git a/app/renderer/src/routes/MeetingDetail.tsx b/app/renderer/src/routes/MeetingDetail.tsx
index b8ff8a1d..26ce4e6c 100644
--- a/app/renderer/src/routes/MeetingDetail.tsx
+++ b/app/renderer/src/routes/MeetingDetail.tsx
@@ -20,11 +20,12 @@ import {
   Mic,
   PencilLine,
   RefreshCw,
+  Share,
   Trash2,
   Users,
 } from 'lucide-react';
 import { Popover, PopoverAnchor, PopoverContent, PopoverTrigger } from '@/components/ui/popover';
-import { useQueryClient } from '@tanstack/react-query';
+import { useQuery, useQueryClient } from '@tanstack/react-query';
 import * as SelectPrimitive from '@radix-ui/react-select';
 import { MeetingsShell } from '@/components/MeetingsShell';
 import { Select, SelectContent, SelectItem, SelectSeparator } from '@/components/ui/select';
@@ -69,6 +70,7 @@ import { useActiveMeeting } from '@/lib/askBarContext';
 import { ipc, type Meeting, type Report, type Template } from '@/lib/ipc';
 import { buildTranscriptBundle, defaultExportFilename } from '@/lib/transcriptBundle';
 import { buildNotesCopyText, type StructuredNoteSections } from '@/lib/notesCopy';
+import { buildNotesMarkdown } from '@/lib/notesMarkdown';
 import { buildNotesHtml, hasNotesContent } from '@/lib/notesPdf';
 import { unwrap } from '@/lib/result';
 import { cn } from '@/lib/utils';
@@ -81,6 +83,28 @@ import { useAutoSummarizeSetting } from '@/hooks/useSettings';
 
 const LAST_OPENED_KEY = 'steno-last-opened-meeting';
 
+// The `…` popover's entry markup, lifted to a constant so the Share menu is
+// visually the same control rather than a near-copy that drifts from it. Both
+// popovers are plain `Popover` + buttons (no roving focus); giving them
+// keyboard navigation is an improvement to that shared pattern, not part of the
+// Share menu.
+const MENU_ENTRY_CLASS =
+  'flex w-full items-center gap-2.5 rounded-md px-3 py-2 text-left text-sm transition-colors hover:bg-[color:var(--surface-hover)] disabled:opacity-50';
+
+// Group separator inside the Share menu. aria-hidden with role="none": it is
+// pure visual grouping, and a `separator` role in a popover that is not a real
+// menu would announce structure the keyboard cannot navigate.
+function MenuDivider() {
+  return (
+    <div
+      role="none"
+      aria-hidden="true"
+      className="mx-2 my-1 h-px"
+      style={{ background: 'var(--border-subtle)' }}
+    />
+  );
+}
+
 // Cross-process sentinel: the export-transcript handler returns this exact error
 // when the user dismisses the save dialog, which we treat as a silent no-op
 // rather than a failure. Must match the producers' value (app/ipc-sentinels.js,
@@ -534,15 +558,19 @@ function DetailContent({
   // rejected clipboard (permission denied, no focus) must not show a false
   // success. The transcript bundle is large and the only thing a user pastes
   // into an LLM, so a silent miscopy is worse here than for the small notes copy.
+  // Returns whether the copy actually landed, so the Share menu only
+  // self-closes on success and a failure keeps the error line in view.
   const copyTranscriptForAi = async () => {
-    if (!transcriptBundle) return;
+    if (!transcriptBundle) return false;
     setExportError(null);
     try {
       await navigator.clipboard.writeText(transcriptBundle);
       setCopiedTranscript(true);
       setTimeout(() => setCopiedTranscript(false), 1500);
+      return true;
     } catch (error) {
       setExportError(`Couldn't copy transcript: ${getErrorMessage(error)}`);
+      return false;
     }
   };
 
@@ -593,26 +621,38 @@ function DetailContent({
     ? Boolean(stripReasoning(activeReport.content).trim())
     : hasNotesContent(noteSections);
 
-  // Branded-PDF export of whichever note is on screen — the open template
-  // report when one is selected, otherwise the Standard structured note. The
-  // report's markdown is serialised with the SAME renderer the view above uses
+  // Branded PDF of whichever note is on screen — the open template report when
+  // one is selected, otherwise the Standard structured note. The report's
+  // markdown is serialised with the SAME renderer the view above uses
   // (react-markdown), so the PDF can't drift from what the user is looking at.
-  // Hands finished HTML to the export-note-pdf IPC, which rasterises + writes it.
-  const saveNotesPdf = async () => {
-    if (!canExportNotesPdf) return;
-    setExportError(null);
-    try {
-      const reportForPdf = activeReport
+  //
+  // Both PDF surfaces go through here — "Save notes as PDF" below and "Share
+  // notes as PDF" in the share menu. They are two adjacent actions on the same
+  // document, and #426 exists because one of them was left exporting the
+  // Standard note while a report was open; a single builder is what keeps them
+  // from disagreeing again. Called on click, never on render: the branded shell
+  // is ~45KB with its base64 font.
+  const buildNotesPdfHtml = () =>
+    buildNotesHtml(
+      noteSections,
+      activeReport
         ? {
             templateName: activeReport.template_name,
             contentHtml: renderToStaticMarkup(
               <ReactMarkdown>{stripReasoning(activeReport.content)}</ReactMarkdown>,
             ),
           }
-        : null;
+        : null
+    );
+
+  // Hands finished HTML to the export-note-pdf IPC, which rasterises + writes it.
+  const saveNotesPdf = async () => {
+    if (!canExportNotesPdf) return;
+    setExportError(null);
+    try {
       const res = await ipc().meetings.exportNotePdf(
         defaultExportFilename(meeting, 'pdf'),
-        buildNotesHtml(noteSections, reportForPdf)
+        buildNotesPdfHtml()
       );
       if (!res.success && res.error !== EXPORT_CANCELED_ERROR) {
         setExportError(`Couldn't save notes: ${res.error || 'unknown error'}`);
@@ -634,6 +674,127 @@ function DetailContent({
     setTimeout(() => setCopied(false), 2000);
   };
 
+  // The active report, reasoning stripped, in the shape the note builders take.
+  // Same selection as copyNotes: whichever note is on screen is what leaves.
+  const reportForExport = activeReport
+    ? { content: stripReasoning(activeReport.content) }
+    : null;
+
+  // Notes exports are off while a summary/report stream is on screen, for the
+  // same reason Copy notes is: otherwise the pre-stream note is written out
+  // while its replacement is still arriving.
+  const notesExportBlocked = streamPhase !== 'idle';
+
+  // Notes and transcript must not suggest the same filename. Both are .md, and
+  // on the share path they land in ONE directory where the second write would
+  // silently replace the first - including under an already-open mail draft,
+  // whose attachment would then quietly become the other document.
+  const notesMarkdownFilename = () =>
+    defaultExportFilename(meeting, 'md').replace(/\.md$/, '-notes.md');
+
+  // Markdown export of the note. Needs no main-process code of its own:
+  // export-transcript already takes an arbitrary string and filters to .md.
+  const saveNotesMarkdown = async () => {
+    if (!canExportNotesPdf || notesExportBlocked) return;
+    setExportError(null);
+    try {
+      const res = await ipc().meetings.exportTranscript(
+        notesMarkdownFilename(),
+        buildNotesMarkdown(noteSections, reportForExport)
+      );
+      if (!res.success && res.error !== EXPORT_CANCELED_ERROR) {
+        setExportError(`Couldn't save notes: ${res.error || 'unknown error'}`);
+      }
+    } catch (error) {
+      setExportError(`Couldn't save notes: ${getErrorMessage(error)}`);
+    }
+  };
+
+  // The Share menu is controlled so a copy can leave its "Copied" label on
+  // screen for a beat before dismissing itself. Inside a menu the old checkmark
+  // feedback would vanish with the popover before it registered.
+  const [shareOpen, setShareOpen] = React.useState(false);
+  const shareCloseTimer = React.useRef<ReturnType<typeof setTimeout> | null>(null);
+  // Identifies the current menu instance. An auto-close belongs to the instance
+  // the copy happened in, and cancelling on open/close is not enough on its own:
+  // the transcript copy awaits the clipboard first, so a menu closed and
+  // reopened during that await has no timer yet to cancel, and the resolving
+  // promise would then schedule one against the new instance. Both the
+  // scheduling and the firing therefore check the epoch.
+  const shareEpoch = React.useRef(0);
+  const cancelShareClose = () => {
+    if (shareCloseTimer.current) {
+      clearTimeout(shareCloseTimer.current);
+      shareCloseTimer.current = null;
+    }
+  };
+  const closeShareAfterCopy = (epoch: number) => {
+    if (shareEpoch.current !== epoch) return;
+    cancelShareClose();
+    shareCloseTimer.current = setTimeout(() => {
+      if (shareEpoch.current === epoch) setShareOpen(false);
+    }, 800);
+  };
+  const onShareOpenChange = (open: boolean) => {
+    cancelShareClose();
+    shareEpoch.current += 1;
+    setShareOpen(open);
+  };
+  React.useEffect(() => cancelShareClose, []);
+
+  // Is there a native share sheet here at all. A capability answered by the main
+  // process, NOT the renderer's isMac: that is a navigator.platform constant
+  // frozen at import, so it can neither be flipped at runtime nor exercised in
+  // both directions by a test - and the absent branch is the one that keeps
+  // Windows from reaching a ShareMenu that does not exist there.
+  // `=== true` means an unresolved query counts as false, so the group never
+  // flashes in before it is known to exist. Cached across notes: the answer
+  // cannot change while the app runs.
+  const shareCapability = useQuery({
+    queryKey: ['share', 'canShare'],
+    queryFn: () => ipc().share.canShare(),
+    staleTime: Infinity,
+  });
+  const canShareToSheet = shareCapability.data === true;
+
+  // Which share is in flight, or null. Unlike the save actions there is no
+  // dialog to react to a click: up to 15 seconds pass before the sheet appears,
+  // and in that gap everyone clicks a second time. So the clicked entry says so,
+  // and only one share may be in flight across all three.
+  type ShareEntry = 'notes-pdf' | 'notes-md' | 'transcript';
+  const [sharing, setSharing] = React.useState<ShareEntry | null>(null);
+
+  const runShare = async (
+    entry: ShareEntry,
+    kind: 'pdf' | 'text',
+    what: 'notes' | 'transcript',
+    filename: string,
+    payload: string,
+    trigger: HTMLElement,
+  ) => {
+    // The disabled attribute already blocks the second click; this is what
+    // actually holds if a re-render lands between the click and the state
+    // update.
+    if (sharing) return;
+    // Read the anchor BEFORE the await: the entry re-renders as "Preparing…"
+    // and the menu can reflow, so a rectangle read afterwards would point at
+    // something else. The sheet is anchored under the clicked entry.
+    const rect = trigger.getBoundingClientRect();
+    const anchor = { x: Math.round(rect.left), y: Math.round(rect.bottom) };
+    setSharing(entry);
+    setExportError(null);
+    try {
+      const res = await ipc().share.shareFile(kind, filename, payload, anchor);
+      if (!res.success) {
+        setExportError(`Couldn't share ${what}: ${res.error || 'unknown error'}`);
+      }
+    } catch (error) {
+      setExportError(`Couldn't share ${what}: ${getErrorMessage(error)}`);
+    } finally {
+      setSharing(null);
+    }
+  };
+
   const summary = meeting.summary?.trim();
   const participants = asStringArray(meeting.participants);
   const keyPoints = meeting.key_points ?? [];
@@ -752,39 +913,6 @@ function DetailContent({
             Home
           </button>
           <div className="flex items-center gap-1">
-            <Tooltip>
-              <TooltipTrigger asChild>
-                {/* Disabled while a summary/report stream is on screen — the
-                    clipboard would otherwise get the old note while the body
-                    shows the in-flux streamed text. */}
-                <ActionIconButton
-                  label={copied ? 'Copied' : 'Copy notes'}
-                  onClick={copyNotes}
-                  disabled={streamPhase !== 'idle'}
-                >
-                  {copied ? <Check className="size-[13px]" /> : <Copy className="size-[13px]" />}
-                </ActionIconButton>
-              </TooltipTrigger>
-              <TooltipContent side="bottom">{copied ? 'Copied!' : 'Copy notes'}</TooltipContent>
-            </Tooltip>
-            <Tooltip>
-              <TooltipTrigger asChild>
-                <ActionIconButton
-                  label={copiedTranscript ? 'Copied' : 'Copy transcript'}
-                  onClick={() => void copyTranscriptForAi()}
-                  disabled={!transcriptBundle}
-                >
-                  {copiedTranscript ? (
-                    <Check className="size-[13px]" />
-                  ) : (
-                    <FileText className="size-[13px]" />
-                  )}
-                </ActionIconButton>
-              </TooltipTrigger>
-              <TooltipContent side="bottom">
-                {copiedTranscript ? 'Copied!' : 'Copy transcript'}
-              </TooltipContent>
-            </Tooltip>
             {/* Re-runs summarisation on the existing transcript. A
                 transcription-failure note has no transcript, so reprocess
                 would exit non-zero and strand the UI on a spinner — hide it
@@ -814,44 +942,62 @@ function DetailContent({
                 <TooltipContent side="bottom">Generate notes</TooltipContent>
               </Tooltip>
             )}
-            <Popover>
+            {/* Everything that carries this note OUT of the app, in one place:
+                the two clipboard actions, the file saves, and (macOS only) the
+                native share sheet. The org share deliberately stays in the `…`
+                menu next to Delete: it uploads to a server and has an inverse
+                action, where every entry here is a one-off local act. */}
+            <Popover open={shareOpen} onOpenChange={onShareOpenChange}>
               <PopoverTrigger asChild>
                 <button
                   type="button"
-                  aria-label="More options"
-                  title="More options"
+                  aria-label="Share"
+                  title="Share"
                   className="inline-flex size-7 items-center justify-center rounded-md transition-colors hover:bg-[color:var(--surface-hover)] hover:text-[color:var(--fg-1)]"
                   style={{ color: 'var(--fg-2)' }}
                 >
-                  <MoreHorizontal className="size-[14px]" />
+                  <Share className="size-[14px]" />
                 </button>
               </PopoverTrigger>
-              <PopoverContent align="end" className="w-56 p-1">
+              <PopoverContent align="end" className="w-60 p-1" data-testid="note-share-menu">
+                {/* Disabled while a summary/report stream is on screen - the
+                    clipboard would otherwise get the old note while the body
+                    shows the in-flux streamed text. */}
                 <button
                   type="button"
-                  className="flex w-full items-center gap-2.5 rounded-md px-3 py-2 text-left text-sm transition-colors hover:bg-[color:var(--surface-hover)]"
+                  className={MENU_ENTRY_CLASS}
                   style={{ color: 'var(--fg-1)' }}
                   onClick={() => {
-                    const file = info.summary_file || info.transcript_file || info.audio_file;
-                    if (file) ipc().meetings.revealFolder(file);
+                    copyNotes();
+                    closeShareAfterCopy(shareEpoch.current);
                   }}
+                  disabled={notesExportBlocked}
                 >
-                  <FolderIcon className="size-[13px] shrink-0" style={{ color: 'var(--fg-2)' }} />
-                  View containing folder
+                  <Copy className="size-[13px] shrink-0" style={{ color: 'var(--fg-2)' }} />
+                  {copied ? 'Copied' : 'Copy notes'}
                 </button>
                 <button
                   type="button"
-                  className="flex w-full items-center gap-2.5 rounded-md px-3 py-2 text-left text-sm transition-colors hover:bg-[color:var(--surface-hover)] disabled:opacity-50"
+                  className={MENU_ENTRY_CLASS}
                   style={{ color: 'var(--fg-1)' }}
-                  onClick={() => void saveTranscript()}
+                  onClick={() => {
+                    // Captured BEFORE the await: if the menu is dismissed and
+                    // reopened while the clipboard write is in flight, this copy
+                    // no longer owns the menu that is on screen.
+                    const epoch = shareEpoch.current;
+                    void copyTranscriptForAi().then((ok) => {
+                      if (ok) closeShareAfterCopy(epoch);
+                    });
+                  }}
                   disabled={!transcriptBundle}
                 >
-                  <Download className="size-[13px] shrink-0" style={{ color: 'var(--fg-2)' }} />
-                  Save transcript as .md…
+                  <FileText className="size-[13px] shrink-0" style={{ color: 'var(--fg-2)' }} />
+                  {copiedTranscript ? 'Copied' : 'Copy transcript'}
                 </button>
+                <MenuDivider />
                 <button
                   type="button"
-                  className="flex w-full items-center gap-2.5 rounded-md px-3 py-2 text-left text-sm transition-colors hover:bg-[color:var(--surface-hover)] disabled:opacity-50"
+                  className={MENU_ENTRY_CLASS}
                   style={{ color: 'var(--fg-1)' }}
                   onClick={() => void saveNotesPdf()}
                   disabled={!canExportNotesPdf}
@@ -859,6 +1005,121 @@ function DetailContent({
                   <FileDown className="size-[13px] shrink-0" style={{ color: 'var(--fg-2)' }} />
                   Save notes as PDF…
                 </button>
+                <button
+                  type="button"
+                  className={MENU_ENTRY_CLASS}
+                  style={{ color: 'var(--fg-1)' }}
+                  onClick={() => void saveNotesMarkdown()}
+                  disabled={!canExportNotesPdf || notesExportBlocked}
+                >
+                  <Download className="size-[13px] shrink-0" style={{ color: 'var(--fg-2)' }} />
+                  Save notes as .md…
+                </button>
+                <button
+                  type="button"
+                  className={MENU_ENTRY_CLASS}
+                  style={{ color: 'var(--fg-1)' }}
+                  onClick={() => void saveTranscript()}
+                  disabled={!transcriptBundle}
+                >
+                  <Download className="size-[13px] shrink-0" style={{ color: 'var(--fg-2)' }} />
+                  Save transcript as .md…
+                </button>
+                {/* Native share sheet (AirDrop, Mail, Messages, Notes). macOS
+                    only, and rendered only when the main process says a sheet
+                    exists. Share transcript stands as its own entry rather than
+                    riding along inside a combined action: it puts the full
+                    verbatim transcript into an outbound channel, and that
+                    deserves a deliberate click. */}
+                {canShareToSheet && (
+                  <>
+                    <MenuDivider />
+                    <button
+                      type="button"
+                      className={MENU_ENTRY_CLASS}
+                      style={{ color: 'var(--fg-1)' }}
+                      onClick={(e) =>
+                        void runShare(
+                          'notes-pdf',
+                          'pdf',
+                          'notes',
+                          defaultExportFilename(meeting, 'pdf'),
+                          buildNotesPdfHtml(),
+                          e.currentTarget
+                        )
+                      }
+                      disabled={!canExportNotesPdf || notesExportBlocked || sharing !== null}
+                    >
+                      <FileDown className="size-[13px] shrink-0" style={{ color: 'var(--fg-2)' }} />
+                      {sharing === 'notes-pdf' ? 'Preparing…' : 'Share notes as PDF…'}
+                    </button>
+                    <button
+                      type="button"
+                      className={MENU_ENTRY_CLASS}
+                      style={{ color: 'var(--fg-1)' }}
+                      onClick={(e) =>
+                        void runShare(
+                          'notes-md',
+                          'text',
+                          'notes',
+                          notesMarkdownFilename(),
+                          buildNotesMarkdown(noteSections, reportForExport),
+                          e.currentTarget
+                        )
+                      }
+                      disabled={!canExportNotesPdf || notesExportBlocked || sharing !== null}
+                    >
+                      <Share className="size-[13px] shrink-0" style={{ color: 'var(--fg-2)' }} />
+                      {sharing === 'notes-md' ? 'Preparing…' : 'Share notes as .md…'}
+                    </button>
+                    <button
+                      type="button"
+                      className={MENU_ENTRY_CLASS}
+                      style={{ color: 'var(--fg-1)' }}
+                      onClick={(e) =>
+                        void runShare(
+                          'transcript',
+                          'text',
+                          'transcript',
+                          defaultExportFilename(meeting),
+                          transcriptBundle ?? '',
+                          e.currentTarget
+                        )
+                      }
+                      disabled={!transcriptBundle || sharing !== null}
+                    >
+                      <FileText className="size-[13px] shrink-0" style={{ color: 'var(--fg-2)' }} />
+                      {sharing === 'transcript' ? 'Preparing…' : 'Share transcript…'}
+                    </button>
+                  </>
+                )}
+              </PopoverContent>
+            </Popover>
+            <Popover>
+              <PopoverTrigger asChild>
+                <button
+                  type="button"
+                  aria-label="More options"
+                  title="More options"
+                  className="inline-flex size-7 items-center justify-center rounded-md transition-colors hover:bg-[color:var(--surface-hover)] hover:text-[color:var(--fg-1)]"
+                  style={{ color: 'var(--fg-2)' }}
+                >
+                  <MoreHorizontal className="size-[14px]" />
+                </button>
+              </PopoverTrigger>
+              <PopoverContent align="end" className="w-56 p-1">
+                <button
+                  type="button"
+                  className="flex w-full items-center gap-2.5 rounded-md px-3 py-2 text-left text-sm transition-colors hover:bg-[color:var(--surface-hover)]"
+                  style={{ color: 'var(--fg-1)' }}
+                  onClick={() => {
+                    const file = info.summary_file || info.transcript_file || info.audio_file;
+                    if (file) ipc().meetings.revealFolder(file);
+                  }}
+                >
+                  <FolderIcon className="size-[13px] shrink-0" style={{ color: 'var(--fg-2)' }} />
+                  View containing folder
+                </button>
                 {/* Re-transcribe (#266): only when the source recording still
                     exists (keep-recordings was on). Disabled while a stream is on
                     screen or a recording is live on this note. */}
diff --git a/app/share-temp.js b/app/share-temp.js
new file mode 100644
index 00000000..47e01128
--- /dev/null
+++ b/app/share-temp.js
@@ -0,0 +1,104 @@
+'use strict';
+
+const fsDefault = require('fs');
+const path = require('path');
+
+// Temp files handed to the native macOS share sheet (ShareMenu). The
+// `share-note-file` handler in main.js materialises a note as a PDF or a
+// markdown file here, then pops the sheet on it.
+//
+// Why this directory is swept at startup and NEVER during a session: the
+// filename becomes the attachment name the recipient reads, and the file has to
+// survive the whole time the destination holds it. A user who picks Mail has an
+// open draft and may type for ten minutes; AirDrop waits for the receiving side
+// to accept. ShareMenu.popup() has no completion callback, so the app is never
+// told when that ends. Deleting on sheet close, or on quit, would pull the
+// attachment out from under an open draft - an open draft at quit time is not an
+// exotic case. Sweeping only files older than a day at the NEXT start means
+// files outlive their own session including any draft, the directory still
+// cannot grow without bound, and there is no moment at which the app deletes a
+// file someone is still reading.
+//
+// No electron import: the caller passes app.getPath('temp') in. That is what
+// keeps this testable under plain node:test.
+
+// Fixed subdirectory name so the sweep can own everything inside it. Because
+// the directory is ours by construction there is no filename pattern to match
+// (unlike live-snapshot-sweep, which sweeps the shared os.tmpdir()), so a
+// crashed atomic write's leftover `.<name>.<hex>.tmp` is reclaimed too.
+const SHARE_TEMP_DIRNAME = 'stenoai-share';
+
+const SHARE_TEMP_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+
+// Resolve (and create) the share temp directory under baseTempPath. Called on
+// every share as well as at startup, so it must never disturb existing files.
+function shareTempDir(baseTempPath) {
+  const dir = path.join(baseTempPath, SHARE_TEMP_DIRNAME);
+  fsDefault.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+// Delete every file in `dir` whose mtime is at least maxAgeMs old, measured
+// against the injected `now`. Best-effort throughout: a missing directory
+// returns quietly and a per-entry failure is recorded and skipped, so one
+// locked file cannot abort the rest. Flat by construction - never recurses.
+//
+// `fs` is injectable for the deterministic failure test.
+// Returns { deleted: string[], kept: string[] } of absolute paths acted on, so
+// the caller can log a count.
+function sweepShareTemp(dir, now, maxAgeMs = SHARE_TEMP_MAX_AGE_MS, fs = fsDefault) {
+  const deleted = [];
+  const kept = [];
+
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch (_) {
+    // Directory missing or unreadable - nothing to sweep.
+    return { deleted, kept };
+  }
+
+  for (const name of entries) {
+    const filePath = path.join(dir, name);
+
+    let stat;
+    try {
+      // lstat, never stat: act only on the regular files we wrote ourselves and
+      // never follow a symlink out of the share directory.
+      stat = fs.lstatSync(filePath);
+    } catch (_) {
+      // Vanished between readdir and lstat - already gone.
+      continue;
+    }
+
+    // Only plain files. A directory (or any other special file) is left alone
+    // and not recursed into.
+    if (!stat.isFile()) {
+      kept.push(filePath);
+      continue;
+    }
+
+    if (now - stat.mtimeMs < maxAgeMs) {
+      kept.push(filePath);
+      continue;
+    }
+
+    try {
+      fs.unlinkSync(filePath);
+      deleted.push(filePath);
+    } catch (_) {
+      // EPERM (a scanner holding it open on Windows) or an ENOENT race. Count it
+      // as kept and continue; a best-effort sweep never throws.
+      kept.push(filePath);
+    }
+  }
+
+  return { deleted, kept };
+}
+
+module.exports = {
+  shareTempDir,
+  sweepShareTemp,
+  SHARE_TEMP_DIRNAME,
+  SHARE_TEMP_MAX_AGE_MS,
+};
diff --git a/app/share-temp.test.js b/app/share-temp.test.js
new file mode 100644
index 00000000..1b0d0a9f
--- /dev/null
+++ b/app/share-temp.test.js
@@ -0,0 +1,160 @@
+const { test, after } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const {
+  shareTempDir,
+  sweepShareTemp,
+  SHARE_TEMP_DIRNAME,
+  SHARE_TEMP_MAX_AGE_MS,
+} = require('./share-temp');
+
+const HOUR_MS = 60 * 60 * 1000;
+
+// Track every temp dir we create so a single after-hook removes them all -
+// otherwise repeated runs accumulate share-temp-test-* dirs in the system temp.
+const createdTmpDirs = [];
+
+function makeTmpDir() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'share-temp-test-'));
+  createdTmpDirs.push(dir);
+  return dir;
+}
+
+after(() => {
+  for (const dir of createdTmpDirs) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// Write a share-shaped file and backdate its mtime by ageMs. Returns the path.
+// mtime is set explicitly (never the wall clock) so the age boundary is exact.
+function writeShared(dir, name, ageMs, now) {
+  const filePath = path.join(dir, name);
+  fs.writeFileSync(filePath, 'payload', 'utf-8');
+  const when = (now - ageMs) / 1000; // fs.utimesSync takes seconds
+  fs.utimesSync(filePath, when, when);
+  return filePath;
+}
+
+test('shareTempDir creates the subdirectory under the injected base path', () => {
+  const base = makeTmpDir();
+
+  const dir = shareTempDir(base);
+
+  assert.strictEqual(dir, path.join(base, SHARE_TEMP_DIRNAME));
+  assert.strictEqual(fs.statSync(dir).isDirectory(), true);
+});
+
+test('shareTempDir is idempotent on an existing directory', () => {
+  const base = makeTmpDir();
+  const first = shareTempDir(base);
+  fs.writeFileSync(path.join(first, 'keep.md'), 'x', 'utf-8');
+
+  const second = shareTempDir(base);
+
+  assert.strictEqual(second, first);
+  // Re-resolving must never wipe what is already in there: a second call
+  // happens on every share, long after the startup sweep decided what stays.
+  assert.strictEqual(fs.existsSync(path.join(first, 'keep.md')), true);
+});
+
+test('deletes a file older than the cutoff', () => {
+  const dir = makeTmpDir();
+  const now = 1_800_000_000_000;
+  const stale = writeShared(dir, '2026-07-01-old.pdf', 25 * HOUR_MS, now);
+
+  const result = sweepShareTemp(dir, now, SHARE_TEMP_MAX_AGE_MS);
+
+  assert.deepStrictEqual(result.deleted, [stale]);
+  assert.strictEqual(fs.existsSync(stale), false);
+});
+
+test('keeps a file younger than the cutoff', () => {
+  // The load-bearing case. A 23-hour-old file may still be the attachment
+  // under an open mail draft; deleting it destroys what the user is sending.
+  const dir = makeTmpDir();
+  const now = 1_800_000_000_000;
+  const fresh = writeShared(dir, '2026-07-30-fresh.pdf', 23 * HOUR_MS, now);
+
+  const result = sweepShareTemp(dir, now, SHARE_TEMP_MAX_AGE_MS);
+
+  assert.deepStrictEqual(result.deleted, []);
+  assert.deepStrictEqual(result.kept, [fresh]);
+  assert.strictEqual(fs.existsSync(fresh), true);
+});
+
+test('the age boundary is exact and deterministic', () => {
+  const dir = makeTmpDir();
+  const now = 1_800_000_000_000;
+
+  // age === maxAgeMs is not younger, so it goes.
+  const atBoundary = writeShared(dir, 'boundary.md', 5000, now);
+  assert.deepStrictEqual(sweepShareTemp(dir, now, 5000).deleted, [atBoundary]);
+
+  // One millisecond inside the window keeps it.
+  writeShared(dir, 'boundary.md', 4999, now);
+  const inside = sweepShareTemp(dir, now, 5000);
+  assert.deepStrictEqual(inside.deleted, []);
+  assert.deepStrictEqual(inside.kept, [atBoundary]);
+});
+
+test('a missing directory does not throw', () => {
+  const missing = path.join(os.tmpdir(), 'share-temp-does-not-exist-xyz');
+
+  const result = sweepShareTemp(missing, Date.now(), SHARE_TEMP_MAX_AGE_MS);
+
+  assert.deepStrictEqual(result, { deleted: [], kept: [] });
+});
+
+test('never removes or recurses into a subdirectory', () => {
+  const dir = makeTmpDir();
+  const now = 1_800_000_000_000;
+  const nested = path.join(dir, 'nested');
+  fs.mkdirSync(nested);
+  const buried = path.join(nested, 'buried.md');
+  fs.writeFileSync(buried, 'x', 'utf-8');
+  const when = (now - 99 * HOUR_MS) / 1000;
+  fs.utimesSync(buried, when, when);
+  fs.utimesSync(nested, when, when);
+
+  const result = sweepShareTemp(dir, now, SHARE_TEMP_MAX_AGE_MS);
+
+  assert.deepStrictEqual(result.deleted, []);
+  assert.deepStrictEqual(result.kept, [nested]);
+  assert.strictEqual(fs.existsSync(buried), true);
+});
+
+test('one unlinkable entry does not abort the rest of the sweep', () => {
+  const dir = makeTmpDir();
+  const now = 1_800_000_000_000;
+  const locked = writeShared(dir, 'locked.pdf', 30 * HOUR_MS, now);
+  const other = writeShared(dir, 'other.pdf', 30 * HOUR_MS, now);
+
+  const stubFs = {
+    readdirSync: fs.readdirSync,
+    lstatSync: fs.lstatSync,
+    unlinkSync: (p) => {
+      if (p === locked) {
+        const err = new Error('EPERM');
+        err.code = 'EPERM';
+        throw err;
+      }
+      return fs.unlinkSync(p);
+    },
+  };
+
+  const result = sweepShareTemp(dir, now, SHARE_TEMP_MAX_AGE_MS, stubFs);
+
+  assert.deepStrictEqual(result.deleted, [other]);
+  assert.deepStrictEqual(result.kept, [locked]);
+  assert.strictEqual(fs.existsSync(locked), true);
+});
+
+test('the default cutoff is 24 hours', () => {
+  // The spec's contract: files outlive their own session including any open
+  // draft, and the directory still cannot grow without bound.
+  assert.strictEqual(SHARE_TEMP_MAX_AGE_MS, 24 * HOUR_MS);
+});
diff --git a/e2e/fixtures/share-menu.ts b/e2e/fixtures/share-menu.ts
new file mode 100644
index 00000000..4ccdc21c
--- /dev/null
+++ b/e2e/fixtures/share-menu.ts
@@ -0,0 +1,19 @@
+import { expect, type Page } from '@playwright/test';
+
+/**
+ * Open the note detail Share menu and return its scoped locator.
+ *
+ * Entries MUST be queried through the returned locator rather than off `page`:
+ * "Copy transcript" is also an AskBar / LiveTranscriptBar control, so an
+ * unscoped role query is ambiguous by accessible name.
+ */
+export async function openShareMenu(page: Page) {
+  const menu = page.getByTestId('note-share-menu');
+  // A copy entry leaves its "Copied" label up for 800 ms before the menu
+  // dismisses itself. Clicking the trigger inside that window would toggle the
+  // still-open menu shut, so wait it out instead of racing it.
+  await expect(menu).toBeHidden();
+  await page.getByRole('button', { name: 'Share', exact: true }).click();
+  await expect(menu).toBeVisible();
+  return menu;
+}
diff --git a/e2e/specs/copy-notes-report.t1.spec.ts b/e2e/specs/copy-notes-report.t1.spec.ts
index 78020fa1..3d3b9ca4 100644
--- a/e2e/specs/copy-notes-report.t1.spec.ts
+++ b/e2e/specs/copy-notes-report.t1.spec.ts
@@ -1,4 +1,5 @@
 import { test, expect } from '../fixtures/electron';
+import { openShareMenu } from '../fixtures/share-menu';
 import type { Page } from '@playwright/test';
 
 /**
@@ -47,7 +48,7 @@ test('Copy notes copies the open report, and the Standard note when none is open
   await page.evaluate((f) => {
     window.location.hash = `#/meetings/${encodeURIComponent(f)}`;
   }, SUMMARY_FILE);
-  await expect(page.getByRole('button', { name: 'Copy notes' })).toBeVisible();
+  await expect(page.getByRole('button', { name: 'Share', exact: true })).toBeVisible();
 
   // The seeded report lives in the view-toggle's template dropdown (opened
   // from the right side of the split pill).
@@ -58,7 +59,7 @@ test('Copy notes copies the open report, and the Standard note when none is open
   await page.keyboard.press('Escape');
 
   // Standard note open (active_report is null) → the structured-note copy.
-  await page.getByRole('button', { name: 'Copy notes' }).click();
+  await (await openShareMenu(page)).getByRole('button', { name: 'Copy notes' }).click();
   let writes = await clipboardWrites(page);
   expect(writes).toHaveLength(1);
   expect(writes[0]).toContain('Epsilon Planning');
@@ -70,7 +71,7 @@ test('Copy notes copies the open report, and the Standard note when none is open
   await page.getByTestId('note-view-menu-trigger').click();
   await menu.getByRole('button', { name: /^Status Report/ }).click();
   await expect(page.getByText('Pipeline healthy')).toBeVisible();
-  await page.getByRole('button', { name: 'Copy notes' }).click();
+  await (await openShareMenu(page)).getByRole('button', { name: 'Copy notes' }).click();
   writes = await clipboardWrites(page);
   expect(writes).toHaveLength(2);
   expect(writes[1]).toContain('Epsilon Planning');
@@ -84,7 +85,7 @@ test('Copy notes copies the open report, and the Standard note when none is open
   // Switching back to Summary (Standard) restores the structured-note copy.
   await page.getByTestId('note-view-menu-trigger').click();
   await menu.getByRole('button', { name: 'Summary' }).click();
-  await page.getByRole('button', { name: 'Copy notes' }).click();
+  await (await openShareMenu(page)).getByRole('button', { name: 'Copy notes' }).click();
   writes = await clipboardWrites(page);
   expect(writes).toHaveLength(3);
   expect(writes[2]).toContain('PARTICIPANTS');
diff --git a/e2e/specs/generate-notes-bar.t1.spec.ts b/e2e/specs/generate-notes-bar.t1.spec.ts
index b0f36334..f4b63809 100644
--- a/e2e/specs/generate-notes-bar.t1.spec.ts
+++ b/e2e/specs/generate-notes-bar.t1.spec.ts
@@ -92,7 +92,7 @@ test('hides the floating Generate notes button for a normal (summarised) note',
   await openMeeting(page, 'epsilon_summary.json');
 
   // The meeting detail resolved (its transcript action is present)…
-  await expect(page.getByRole('button', { name: 'Copy transcript' })).toBeVisible();
+  await expect(page.getByRole('button', { name: 'Share', exact: true })).toBeVisible();
   // …but the note has no notes_generated:false marker, so no floating CTA.
   await expect(page.getByTestId('generate-notes-dock-button')).toHaveCount(0);
 });
diff --git a/e2e/specs/notes-pdf-export.t1.spec.ts b/e2e/specs/notes-pdf-export.t1.spec.ts
index 874e7528..dcbc1259 100644
--- a/e2e/specs/notes-pdf-export.t1.spec.ts
+++ b/e2e/specs/notes-pdf-export.t1.spec.ts
@@ -1,4 +1,5 @@
 import { test, expect } from '../fixtures/electron';
+import { openShareMenu } from '../fixtures/share-menu';
 import type { Page } from '@playwright/test';
 import { readFileSync, rmSync, mkdtempSync } from 'fs';
 import { tmpdir } from 'os';
@@ -20,7 +21,7 @@ async function openDetail(page: Page, summaryFile = SUMMARY_FILE) {
   await page.evaluate((f) => {
     window.location.hash = `#/meetings/${encodeURIComponent(f)}`;
   }, summaryFile);
-  await expect(page.getByRole('button', { name: 'Copy transcript' })).toBeVisible();
+  await expect(page.getByRole('button', { name: 'Share', exact: true })).toBeVisible();
 }
 
 test('Save notes as PDF passes the renderer-built branded HTML to export-note-pdf', async ({
@@ -36,8 +37,8 @@ test('Save notes as PDF passes the renderer-built branded HTML to export-note-pd
   try {
     await openDetail(page);
 
-    await page.getByRole('button', { name: 'More options' }).click();
-    await page.getByRole('button', { name: /Save notes as PDF/ }).click();
+    const menu = await openShareMenu(page);
+    await menu.getByRole('button', { name: /Save notes as PDF/ }).click();
 
     await expect
       .poll(
@@ -70,8 +71,8 @@ test('Save notes as PDF passes the renderer-built branded HTML to export-note-pd
 test('Save notes as PDF is enabled for a note with structured content', async ({ launchApp }) => {
   const { page } = await launchApp({ mockIpc: true, env: { STENOAI_E2E_SEED_MEETING: '1' } });
   await openDetail(page);
-  await page.getByRole('button', { name: 'More options' }).click();
-  await expect(page.getByRole('button', { name: /Save notes as PDF/ })).toBeEnabled();
+  const menu = await openShareMenu(page);
+  await expect(menu.getByRole('button', { name: /Save notes as PDF/ })).toBeEnabled();
 });
 
 test('Save notes as PDF is disabled for a transcript-only note (no structured content)', async ({
@@ -85,9 +86,10 @@ test('Save notes as PDF is disabled for a transcript-only note (no structured co
     env: { STENOAI_E2E_SEED_PENDING_NOTE: '1' },
   });
   await openDetail(page, 'pending_summary.md');
-  await page.getByRole('button', { name: 'More options' }).click();
-  await expect(page.getByRole('button', { name: /Save notes as PDF/ })).toBeDisabled();
-  await expect(page.getByRole('button', { name: /Save transcript as \.md/ })).toBeEnabled();
+  const menu = await openShareMenu(page);
+  await expect(menu.getByRole('button', { name: /Save notes as PDF/ })).toBeDisabled();
+  await expect(menu.getByRole('button', { name: /Save notes as \.md/ })).toBeDisabled();
+  await expect(menu.getByRole('button', { name: /Save transcript as \.md/ })).toBeEnabled();
 });
 
 /**
@@ -119,8 +121,10 @@ test('Save notes as PDF exports the open template report, not the Standard note'
     await menu.getByRole('button', { name: /^Status Report/ }).click();
     await expect(page.getByText('Pipeline healthy')).toBeVisible();
 
-    await page.getByRole('button', { name: 'More options' }).click();
-    await page.getByRole('button', { name: /Save notes as PDF/ }).click();
+    // Same menu as the first case above: this branch moves the save entries out
+    // of the "…" menu into Share, so reach them through the Share fixture.
+    const shareMenu = await openShareMenu(page);
+    await shareMenu.getByRole('button', { name: /Save notes as PDF/ }).click();
 
     await expect
       .poll(
diff --git a/e2e/specs/share-file.t2.spec.ts b/e2e/specs/share-file.t2.spec.ts
new file mode 100644
index 00000000..dceb1dc0
--- /dev/null
+++ b/e2e/specs/share-file.t2.spec.ts
@@ -0,0 +1,178 @@
+import { test, expect } from '../fixtures/electron';
+import { realUserDataDir, fileSig } from '../fixtures/real-user-data';
+import { writeMeetingSummary } from '../fixtures/user-config';
+import { readFileSync, existsSync, statSync, rmSync } from 'fs';
+import path from 'path';
+
+/**
+ * T2 - the real `share-note-file` IPC. It materialises a note into the managed
+ * share temp directory and would then pop the native macOS sheet; under IS_E2E
+ * it stops after the write and returns the path, because a native share sheet
+ * cannot be automated (Playwright can neither see nor dismiss it, and an open
+ * sheet would block the run). So this spec owns exactly the part that can be
+ * checked by machine: the directory, the filename and the bytes.
+ *
+ * What no automated test covers, here or anywhere: that the sheet opens, that
+ * Mail accepts the attachment, and that the recipient sees a usable filename.
+ * That is manual acceptance on the packaged build and must not be reported as
+ * covered.
+ *
+ * Cleanup is explicit: the share directory lives under the OS temp path, NOT
+ * under STENOAI_USER_DATA_DIR, so the per-test data dir being thrown away does
+ * not reclaim these files.
+ */
+
+type ShareResult = { success: boolean; error?: string; path?: string };
+type StenoWindow = Window & {
+  stenoai: {
+    share: {
+      canShare: () => Promise<boolean>;
+      shareFile: (
+        kind: string,
+        defaultFilename: string,
+        payload: string,
+        anchor: { x: number; y: number },
+      ) => Promise<ShareResult>;
+    };
+  };
+};
+
+const HTML =
+  '<!doctype html><html><head><meta charset="utf-8"><title>Epsilon</title></head>' +
+  '<body><h1>Epsilon Planning</h1><p>The team agreed to ship on Friday.</p></body></html>';
+
+const MARKDOWN = '# Epsilon Planning\n\n## Summary\n\nThe team agreed to ship on Friday.\n';
+
+const ANCHOR = { x: 100, y: 200 };
+
+// Every path the handler reports back, so one place removes them all even when
+// an assertion fails part way through.
+const written: string[] = [];
+const share = (
+  page: import('@playwright/test').Page,
+  kind: string,
+  filename: string,
+  payload: string,
+) =>
+  page
+    .evaluate(
+      ([k, f, p, a]) =>
+        (window as StenoWindow).stenoai.share.shareFile(
+          k as string,
+          f as string,
+          p as string,
+          a as { x: number; y: number },
+        ),
+      [kind, filename, payload, ANCHOR] as const,
+    )
+    .then((res) => {
+      if (res.path) written.push(res.path);
+      return res;
+    });
+
+test.afterEach(() => {
+  for (const file of written.splice(0)) {
+    rmSync(file, { force: true });
+  }
+});
+
+test('share-note-file writes a real PDF into the share temp directory', async ({
+  launchApp,
+  userDataDir,
+}) => {
+  const realDirBefore = fileSig(realUserDataDir());
+  writeMeetingSummary(userDataDir, 'epsilon', {
+    name: 'Epsilon Planning',
+    transcript: 'Alice: we ship Friday.',
+  });
+
+  const { page } = await launchApp();
+  const res = await share(page, 'pdf', '2026-07-30-epsilon-planning.pdf', HTML);
+
+  expect(res.success).toBe(true);
+  expect(res.path).toBeTruthy();
+  const file = res.path!;
+  // The managed directory, and the dated slug kept verbatim: this filename is
+  // what the recipient of the attachment reads, so it is deliberately not
+  // given a random suffix.
+  expect(path.dirname(file).endsWith(path.join('stenoai-share'))).toBe(true);
+  expect(path.basename(file)).toBe('2026-07-30-epsilon-planning.pdf');
+  expect(existsSync(file)).toBe(true);
+  expect(readFileSync(file).subarray(0, 5).toString('latin1')).toBe('%PDF-');
+  expect(statSync(file).size).toBeGreaterThan(500);
+
+  // Keystone: the real user-data dir is byte-for-byte untouched.
+  expect(fileSig(realUserDataDir())).toBe(realDirBefore);
+});
+
+test('share-note-file writes text verbatim as UTF-8', async ({ launchApp }) => {
+  const { page } = await launchApp();
+  const res = await share(page, 'text', '2026-07-30-epsilon-planning-notes.md', MARKDOWN);
+
+  expect(res.success).toBe(true);
+  const file = res.path!;
+  expect(path.basename(file)).toBe('2026-07-30-epsilon-planning-notes.md');
+  // Byte for byte, not "contains": the markdown builder's output is the
+  // contract, and re-encoding it would corrupt a note's own formatting.
+  expect(readFileSync(file, 'utf-8')).toBe(MARKDOWN);
+});
+
+test('the notes and transcript names do not collide in the shared directory', async ({
+  launchApp,
+}) => {
+  // Both are .md and both land in ONE directory, so identical names would mean
+  // the second share silently replaces the first - including under an already
+  // open mail draft, whose attachment would quietly become the other document.
+  const { page } = await launchApp();
+  const notes = await share(page, 'text', '2026-07-30-epsilon-planning-notes.md', MARKDOWN);
+  const transcript = await share(page, 'text', '2026-07-30-epsilon-planning.md', '# Transcript\n');
+
+  expect(notes.success && transcript.success).toBe(true);
+  expect(notes.path).not.toBe(transcript.path);
+  expect(readFileSync(notes.path!, 'utf-8')).toBe(MARKDOWN);
+  expect(readFileSync(transcript.path!, 'utf-8')).toBe('# Transcript\n');
+});
+
+test('a suggested filename cannot escape the share directory', async ({ launchApp }) => {
+  const { page } = await launchApp();
+
+  // The renderer never supplies a path, but it is untrusted: unlike the export
+  // handlers - where the reduced name only seeds a dialog the user confirms -
+  // this one is joined onto a directory we write into.
+  const traversal = await share(page, 'text', '../../../evil.md', 'x');
+  expect(traversal.success).toBe(true);
+  expect(path.basename(traversal.path!)).toBe('evil.md');
+  expect(path.dirname(traversal.path!).endsWith(path.join('stenoai-share'))).toBe(true);
+
+  // A name that reduces to a bare directory component falls back instead of
+  // resolving to the directory itself.
+  const dotdot = await share(page, 'text', '..', 'x');
+  expect(dotdot.success).toBe(true);
+  expect(path.basename(dotdot.path!)).toBe('notes.md');
+});
+
+test('share-note-file refuses empty content and an unknown kind without writing', async ({
+  launchApp,
+}) => {
+  const { page } = await launchApp();
+
+  const empty = await share(page, 'text', 'empty.md', '');
+  expect(empty.success).toBe(false);
+  expect(empty.path).toBeUndefined();
+
+  const badKind = await share(page, 'jpeg', 'weird.jpeg', 'x');
+  expect(badKind.success).toBe(false);
+  expect(badKind.path).toBeUndefined();
+});
+
+test('the share capability follows the platform, not the user agent', async ({ launchApp }) => {
+  const { page } = await launchApp();
+  const canShare = await page.evaluate(() =>
+    (window as StenoWindow).stenoai.share.canShare(),
+  );
+
+  // Electron exposes ShareMenu on darwin only. This is also the guard against a
+  // future Electron dropping the export: it would fail here rather than crash
+  // the main process on `new undefined(...)`.
+  expect(canShare).toBe(process.platform === 'darwin');
+});
diff --git a/e2e/specs/share-menu.t1.spec.ts b/e2e/specs/share-menu.t1.spec.ts
new file mode 100644
index 00000000..96513fa9
--- /dev/null
+++ b/e2e/specs/share-menu.t1.spec.ts
@@ -0,0 +1,408 @@
+import { test, expect } from '../fixtures/electron';
+import { openShareMenu } from '../fixtures/share-menu';
+import type { Page } from '@playwright/test';
+import { readFileSync, rmSync, mkdtempSync } from 'fs';
+import { tmpdir } from 'os';
+import path from 'path';
+
+/**
+ * T1 - renderer-only, mock IPC, no backend. The Share menu collects every
+ * action that carries a note out of the app. The interaction itself is the risk
+ * here, which is why this is a UI spec rather than a T2: the entries moved out
+ * of two different homes, and an entry that was DUPLICATED rather than moved
+ * would look correct from the Share menu alone.
+ *
+ * Seams (mirrors of the real ones, see app/e2e-mock-ipc.js):
+ *  - STENOAI_E2E_SEED_MEETING=1 makes list-meetings return one known meeting.
+ *  - the clipboard is captured by replacing navigator.clipboard in-page.
+ *  - STENOAI_E2E_EXPORT_PATH makes the export-transcript mock write its payload
+ *    to disk, so what "Save notes as .md…" passed is observable byte for byte.
+ *  - STENOAI_E2E_SHARE_CAPABLE toggles the share-sheet capability, which is why
+ *    the renderer gates on an injected flag rather than navigator.platform:
+ *    both branches are reachable on any OS, including in CI on Ubuntu.
+ *  - STENOAI_E2E_SHARE_LOG collects one JSON line per share-note-file call, and
+ *    STENOAI_E2E_SHARE_DELAY_MS holds a call open so the pending state can be
+ *    observed without racing the clock.
+ */
+
+const SUMMARY_FILE = 'epsilon_summary.json';
+
+async function installClipboardRecorder(page: Page, delayMs = 0) {
+  await page.evaluate((delay) => {
+    const w = window as unknown as { __clipboardWrites: string[] };
+    w.__clipboardWrites = [];
+    Object.defineProperty(navigator, 'clipboard', {
+      configurable: true,
+      value: {
+        writeText: (text: string) => {
+          w.__clipboardWrites.push(text);
+          // A held-open write makes the transcript copy's await long enough to
+          // reopen the menu inside it, without racing the clock.
+          return delay > 0
+            ? new Promise<void>((resolve) => setTimeout(resolve, delay))
+            : Promise.resolve();
+        },
+      },
+    });
+  }, delayMs);
+}
+
+const clipboardWrites = (page: Page) =>
+  page.evaluate(() => (window as unknown as { __clipboardWrites: string[] }).__clipboardWrites);
+
+async function openDetail(page: Page) {
+  await page.evaluate((f) => {
+    window.location.hash = `#/meetings/${encodeURIComponent(f)}`;
+  }, SUMMARY_FILE);
+  await expect(page.getByRole('button', { name: 'Share', exact: true })).toBeVisible();
+}
+
+test('the copy actions left the toolbar and are reachable from the Share menu', async ({
+  launchApp,
+}) => {
+  const { page } = await launchApp({ mockIpc: true, env: { STENOAI_E2E_SEED_MEETING: '1' } });
+  await openDetail(page);
+  await installClipboardRecorder(page);
+
+  // With the menu closed, neither copy action exists anywhere on the detail
+  // view. This is the half that catches a duplicate: the entries below would
+  // pass just as well if the toolbar icons had been left in place.
+  await expect(page.getByRole('button', { name: 'Copy notes' })).toHaveCount(0);
+  await expect(page.getByRole('button', { name: 'Copy transcript' })).toHaveCount(0);
+
+  const menu = await openShareMenu(page);
+  await expect(menu.getByRole('button', { name: 'Copy notes' })).toBeVisible();
+  await expect(menu.getByRole('button', { name: 'Copy transcript' })).toBeVisible();
+
+  // Both still reach the clipboard from their new home.
+  await menu.getByRole('button', { name: 'Copy notes' }).click();
+  let writes = await clipboardWrites(page);
+  expect(writes).toHaveLength(1);
+  expect(writes[0]).toContain('Epsilon Planning');
+
+  const second = await openShareMenu(page);
+  await second.getByRole('button', { name: 'Copy transcript' }).click();
+  writes = await clipboardWrites(page);
+  expect(writes).toHaveLength(2);
+  expect(writes[1]).toContain('## Transcript');
+});
+
+test('a copy flips its own label to Copied and then dismisses the menu', async ({ launchApp }) => {
+  const { page } = await launchApp({ mockIpc: true, env: { STENOAI_E2E_SEED_MEETING: '1' } });
+  await openDetail(page);
+  await installClipboardRecorder(page);
+
+  const menu = await openShareMenu(page);
+  await menu.getByRole('button', { name: 'Copy notes' }).click();
+
+  // Inside a menu the old checkmark feedback would be dismissed with the
+  // popover before it registered, so the label carries the confirmation and the
+  // menu stays up for a beat.
+  await expect(menu.getByRole('button', { name: 'Copied' })).toBeVisible();
+  await expect(menu).toBeHidden({ timeout: 5_000 });
+});
+
+test('dismissing and reopening after a copy does not inherit the auto-close', async ({
+  launchApp,
+}) => {
+  const { page } = await launchApp({ mockIpc: true, env: { STENOAI_E2E_SEED_MEETING: '1' } });
+  await openDetail(page);
+  await installClipboardRecorder(page);
+
+  const menu = page.getByTestId('note-share-menu');
+  await page.getByRole('button', { name: 'Share', exact: true }).click();
+  await expect(menu).toBeVisible();
+  await menu.getByRole('button', { name: 'Copy notes' }).click();
+
+  // Dismiss and reopen INSIDE the 800 ms auto-close window. That timer belongs
+  // to the menu instance the copy happened in; left pending it would fire
+  // against the new one and shut it in the user's face.
+  await page.keyboard.press('Escape');
+  await expect(menu).toBeHidden();
+  await page.getByRole('button', { name: 'Share', exact: true }).click();
+  await expect(menu).toBeVisible();
+
+  // Well past the point the stale timer would have fired.
+  await page.waitForTimeout(1_500);
+  await expect(menu).toBeVisible();
+});
+
+test('a copy still in flight does not close the menu reopened during it', async ({
+  launchApp,
+}) => {
+  const { page } = await launchApp({ mockIpc: true, env: { STENOAI_E2E_SEED_MEETING: '1' } });
+  await openDetail(page);
+  // Copy transcript awaits the clipboard before scheduling its auto-close, so
+  // during that await there is no timer to cancel. Cancelling on open/close is
+  // therefore not sufficient on its own.
+  await installClipboardRecorder(page, 1_500);
+
+  const menu = page.getByTestId('note-share-menu');
+  await page.getByRole('button', { name: 'Share', exact: true }).click();
+  await expect(menu).toBeVisible();
+  await menu.getByRole('button', { name: 'Copy transcript' }).click();
+
+  // Dismiss and reopen while the write is still in flight.
+  await page.keyboard.press('Escape');
+  await expect(menu).toBeHidden();
+  await page.getByRole('button', { name: 'Share', exact: true }).click();
+  await expect(menu).toBeVisible();
+
+  // Past the write resolving plus the 800 ms the inherited timer would add.
+  await page.waitForTimeout(2_800);
+  await expect(menu).toBeVisible();
+});
+
+test('the file saves moved out of the ... menu, which keeps its management actions', async ({
+  launchApp,
+}) => {
+  const { page } = await launchApp({ mockIpc: true, env: { STENOAI_E2E_SEED_MEETING: '1' } });
+  await openDetail(page);
+
+  await page.getByRole('button', { name: 'More options' }).click();
+  const more = page.getByRole('button', { name: 'View containing folder' });
+  await expect(more).toBeVisible();
+
+  // Neither save entry is offered there any more. No exact entry count is
+  // asserted: Re-transcribe and the org share are conditional, so a count would
+  // fail for reasons unrelated to this change.
+  await expect(page.getByRole('button', { name: /Save transcript as \.md/ })).toHaveCount(0);
+  await expect(page.getByRole('button', { name: /Save notes as PDF/ })).toHaveCount(0);
+  await expect(page.getByRole('button', { name: /Save notes as \.md/ })).toHaveCount(0);
+  // The management actions it owns are untouched.
+  await expect(page.getByRole('button', { name: 'Delete note' })).toBeVisible();
+
+  await page.keyboard.press('Escape');
+
+  // All three saves live in the Share menu now.
+  const menu = await openShareMenu(page);
+  await expect(menu.getByRole('button', { name: /Save notes as PDF/ })).toBeVisible();
+  await expect(menu.getByRole('button', { name: /Save notes as \.md/ })).toBeVisible();
+  await expect(menu.getByRole('button', { name: /Save transcript as \.md/ })).toBeVisible();
+});
+
+test('Save notes as .md passes markdown, not the running text Copy notes builds', async ({
+  launchApp,
+}) => {
+  const outDir = mkdtempSync(path.join(tmpdir(), 'steno-share-md-t1-'));
+  const outFile = path.join(outDir, 'notes.md');
+  const { page } = await launchApp({
+    mockIpc: true,
+    env: { STENOAI_E2E_SEED_MEETING: '1', STENOAI_E2E_EXPORT_PATH: outFile },
+  });
+
+  try {
+    await openDetail(page);
+
+    const menu = await openShareMenu(page);
+    await menu.getByRole('button', { name: /Save notes as \.md/ }).click();
+
+    await expect
+      .poll(
+        () => {
+          try {
+            return readFileSync(outFile, 'utf8');
+          } catch {
+            return '';
+          }
+        },
+        { timeout: 10_000, intervals: [200] },
+      )
+      .toContain('# Epsilon Planning');
+
+    const md = readFileSync(outFile, 'utf8');
+    // Real markdown headings, not notesCopy's uppercase labels - the assertion
+    // that separates the third builder from the one it sits next to.
+    expect(md).toContain('## Summary');
+    expect(md).toContain('## Participants');
+    expect(md).toContain('Alice, Bob');
+    expect(md).not.toContain('SUMMARY');
+    expect(md).not.toContain('PARTICIPANTS');
+  } finally {
+    rmSync(outDir, { recursive: true, force: true });
+  }
+});
+
+const SHARE_ENTRIES = [/Share notes as PDF/, /Share notes as \.md/, /Share transcript/];
+
+function shareCalls(logFile: string) {
+  try {
+    return readFileSync(logFile, 'utf8')
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => JSON.parse(line) as { kind: string; defaultFilename: string; payloadHead: string });
+  } catch {
+    return [];
+  }
+}
+
+test('the share entries are absent when no share sheet exists here', async ({ launchApp }) => {
+  // The branch that matters on Windows: Electron exports no ShareMenu there, so
+  // an entry that rendered anyway would reach a constructor that is undefined.
+  const { page } = await launchApp({ mockIpc: true, env: { STENOAI_E2E_SEED_MEETING: '1' } });
+  await openDetail(page);
+
+  const menu = await openShareMenu(page);
+  // The rest of the menu is unaffected - Windows keeps every non-sheet action.
+  await expect(menu.getByRole('button', { name: 'Copy notes' })).toBeVisible();
+  await expect(menu.getByRole('button', { name: /Save transcript as \.md/ })).toBeVisible();
+  for (const entry of SHARE_ENTRIES) {
+    await expect(menu.getByRole('button', { name: entry })).toHaveCount(0);
+  }
+});
+
+test('the share entries render when a share sheet exists, and pass the right file', async ({
+  launchApp,
+}) => {
+  const outDir = mkdtempSync(path.join(tmpdir(), 'steno-share-t1-'));
+  const logFile = path.join(outDir, 'share-calls.jsonl');
+  const { page } = await launchApp({
+    mockIpc: true,
+    env: {
+      STENOAI_E2E_SEED_MEETING: '1',
+      STENOAI_E2E_SHARE_CAPABLE: '1',
+      STENOAI_E2E_SHARE_LOG: logFile,
+    },
+  });
+
+  try {
+    await openDetail(page);
+    const menu = await openShareMenu(page);
+    for (const entry of SHARE_ENTRIES) {
+      await expect(menu.getByRole('button', { name: entry })).toBeVisible();
+    }
+
+    // Notes as PDF hands over the same branded HTML the save path builds, under
+    // a dated .pdf name - the filename is what the recipient reads.
+    await menu.getByRole('button', { name: /Share notes as PDF/ }).click();
+    await expect.poll(() => shareCalls(logFile).length, { timeout: 10_000 }).toBe(1);
+    let call = shareCalls(logFile)[0];
+    expect(call.kind).toBe('pdf');
+    expect(call.defaultFilename).toMatch(/^\d{4}-\d{2}-\d{2}-epsilon-planning\.pdf$/);
+    expect(call.payloadHead).toContain('<!doctype html>');
+
+    // A share does not dismiss the menu (unlike a copy), so the next entry is
+    // clicked in the same open menu.
+    await expect(menu).toBeVisible();
+
+    // Transcript goes as text under the plain dated .md name.
+    await menu.getByRole('button', { name: /Share transcript/ }).click();
+    await expect.poll(() => shareCalls(logFile).length, { timeout: 10_000 }).toBe(2);
+    call = shareCalls(logFile)[1];
+    expect(call.kind).toBe('text');
+    expect(call.defaultFilename).toMatch(/^\d{4}-\d{2}-\d{2}-epsilon-planning\.md$/);
+    expect(call.payloadHead).toContain('# Epsilon Planning');
+
+    // Notes as .md carries the -notes suffix, so it cannot overwrite the
+    // transcript file that the entry above just wrote into the same directory.
+    await menu.getByRole('button', { name: /Share notes as \.md/ }).click();
+    await expect.poll(() => shareCalls(logFile).length, { timeout: 10_000 }).toBe(3);
+    call = shareCalls(logFile)[2];
+    expect(call.kind).toBe('text');
+    expect(call.defaultFilename).toMatch(/^\d{4}-\d{2}-\d{2}-epsilon-planning-notes\.md$/);
+    expect(call.defaultFilename).not.toBe(shareCalls(logFile)[1].defaultFilename);
+    expect(call.payloadHead).toContain('## Summary');
+  } finally {
+    rmSync(outDir, { recursive: true, force: true });
+  }
+});
+
+test('a share in flight shows Preparing and swallows a second click', async ({ launchApp }) => {
+  const outDir = mkdtempSync(path.join(tmpdir(), 'steno-share-pending-t1-'));
+  const logFile = path.join(outDir, 'share-calls.jsonl');
+  const { page } = await launchApp({
+    mockIpc: true,
+    env: {
+      STENOAI_E2E_SEED_MEETING: '1',
+      STENOAI_E2E_SHARE_CAPABLE: '1',
+      STENOAI_E2E_SHARE_LOG: logFile,
+      STENOAI_E2E_SHARE_DELAY_MS: '3000',
+    },
+  });
+
+  try {
+    await openDetail(page);
+    const menu = await openShareMenu(page);
+    await menu.getByRole('button', { name: /Share notes as PDF/ }).click();
+
+    // The menu stays open and the clicked entry says what it is doing. Without
+    // this the user sees nothing happen for up to 15 seconds.
+    await expect(menu.getByRole('button', { name: 'Preparing…' })).toBeVisible();
+    await expect(menu).toBeVisible();
+    // Every share entry is off while one is in flight, not just the clicked one.
+    for (const entry of [/Share notes as \.md/, /Share transcript/]) {
+      await expect(menu.getByRole('button', { name: entry })).toBeDisabled();
+    }
+
+    // force: past the disabled attribute, so this tests the guard in the handler
+    // rather than only the rendered state. A second sheet must not be queued.
+    await menu.getByRole('button', { name: 'Preparing…' }).click({ force: true });
+    await expect.poll(() => shareCalls(logFile).length, { timeout: 5_000 }).toBe(1);
+
+    // It resolves back to its own label rather than staying stuck.
+    await expect(menu.getByRole('button', { name: /Share notes as PDF/ })).toBeEnabled({
+      timeout: 10_000,
+    });
+  } finally {
+    rmSync(outDir, { recursive: true, force: true });
+  }
+});
+
+/**
+ * "Share notes as PDF" and "Save notes as PDF" are two entries in the same menu
+ * for the same document. #426 fixed the save entry to export whichever note is
+ * on screen; the share entry arrived on this branch in parallel and had no way
+ * to know about it, so integrating main was the moment the two could silently
+ * disagree again — the exact failure #426 was filed for, one entry lower.
+ *
+ * Asserting the shared PAYLOAD rather than the call shape is the point: both
+ * entries produce a branded HTML document, so a wrong one still passes every
+ * kind/filename/doctype check above.
+ */
+test('Share notes as PDF shares the open template report, like the save entry', async ({
+  launchApp,
+}) => {
+  const outDir = mkdtempSync(path.join(tmpdir(), 'steno-share-report-t1-'));
+  const logFile = path.join(outDir, 'share-calls.jsonl');
+  const payloadFile = path.join(outDir, 'shared-notes.html');
+  const { page } = await launchApp({
+    mockIpc: true,
+    env: {
+      STENOAI_E2E_SEED_MEETING: '1',
+      STENOAI_E2E_SEED_REPORT: '1',
+      STENOAI_E2E_SHARE_CAPABLE: '1',
+      STENOAI_E2E_SHARE_LOG: logFile,
+      STENOAI_E2E_SHARE_PAYLOAD_PATH: payloadFile,
+    },
+  });
+
+  try {
+    await openDetail(page);
+
+    // Open the seeded report from the view-toggle's template dropdown, so the
+    // screen is showing the report and not the Standard note.
+    const viewMenu = page.getByTestId('note-view-menu');
+    await page.getByTestId('note-view-menu-trigger').click();
+    await viewMenu.getByRole('button', { name: /^Status Report/ }).click();
+    await expect(page.getByText('Pipeline healthy')).toBeVisible();
+
+    const menu = await openShareMenu(page);
+    await menu.getByRole('button', { name: /Share notes as PDF/ }).click();
+    await expect.poll(() => shareCalls(logFile).length, { timeout: 10_000 }).toBe(1);
+
+    const html = readFileSync(payloadFile, 'utf8');
+
+    // The report arrives RENDERED, the same react-markdown output the detail
+    // view shows and the save path writes.
+    expect(html).toContain('<li>Pipeline healthy</li>');
+    expect(html).toContain('>Status Report</h2>');
+    // The Standard note's sections did NOT ride along instead.
+    expect(html).not.toContain('>Key Topics</h2>');
+    // Reasoning stays stripped on the way into an outbound channel.
+    expect(html).not.toContain('secret chain of thought');
+    // Brand chrome is the save path's, unchanged.
+    expect(html).toContain('<h1>Epsilon Planning</h1>');
+  } finally {
+    rmSync(outDir, { recursive: true, force: true });
+  }
+});
diff --git a/e2e/specs/transcript-export.t1.spec.ts b/e2e/specs/transcript-export.t1.spec.ts
index 5218e682..0dd42f82 100644
--- a/e2e/specs/transcript-export.t1.spec.ts
+++ b/e2e/specs/transcript-export.t1.spec.ts
@@ -1,4 +1,5 @@
 import { test, expect } from '../fixtures/electron';
+import { openShareMenu } from '../fixtures/share-menu';
 import type { Page } from '@playwright/test';
 import { readFileSync, rmSync, mkdtempSync } from 'fs';
 import { tmpdir } from 'os';
@@ -6,7 +7,8 @@ import path from 'path';
 
 /**
  * T1 — renderer-only, mock IPC, no backend. Drives the REAL MeetingDetail
- * transcript actions (Copy transcript / Save transcript as .md…) against a
+ * transcript actions (Copy transcript / Save transcript as .md…, both now
+ * inside the Share menu) against a
  * seeded meeting, proving the renderer BUILDS the bundle from meeting data and
  * WIRES it to both sinks. The T2 spec only asserts the backend writes whatever
  * string it's handed; the build + the copy/save wiring the renderer performs
@@ -54,9 +56,9 @@ async function openDetail(page: Page) {
   await page.evaluate((f) => {
     window.location.hash = `#/meetings/${encodeURIComponent(f)}`;
   }, SUMMARY_FILE);
-  // The seeded meeting's title and the transcript actions are present once the
-  // detail route has resolved the meeting from the mocked list.
-  await expect(page.getByRole('button', { name: 'Copy transcript' })).toBeVisible();
+  // The Share menu's trigger is present once the detail route has resolved the
+  // meeting from the mocked list; the transcript actions live inside it.
+  await expect(page.getByRole('button', { name: 'Share', exact: true })).toBeVisible();
 }
 
 test('Copy transcript copies the renderer-built bundle and confirms only on success', async ({
@@ -66,7 +68,8 @@ test('Copy transcript copies the renderer-built bundle and confirms only on succ
   await openDetail(page);
   await installClipboardRecorder(page);
 
-  await page.getByRole('button', { name: 'Copy transcript' }).click();
+  const menu = await openShareMenu(page);
+  await menu.getByRole('button', { name: 'Copy transcript' }).click();
 
   // Exactly one write, carrying the bundle BUILT from the meeting (not an
   // arbitrary string): English metadata labels + headings, the notes and the
@@ -84,8 +87,8 @@ test('Copy transcript copies the renderer-built bundle and confirms only on succ
     expect(bundle).not.toContain(german);
   }
 
-  // The button confirms the copy only after the write resolved.
-  await expect(page.getByRole('button', { name: 'Copied' })).toBeVisible();
+  // The entry confirms the copy only after the write resolved.
+  await expect(menu.getByRole('button', { name: 'Copied' })).toBeVisible();
 });
 
 test('Copy transcript does not confirm when the clipboard write is rejected', async ({
@@ -98,13 +101,15 @@ test('Copy transcript does not confirm when the clipboard write is rejected', as
     (window as unknown as { __clipboardReject: boolean }).__clipboardReject = true;
   });
 
-  await page.getByRole('button', { name: 'Copy transcript' }).click();
+  const menu = await openShareMenu(page);
+  await menu.getByRole('button', { name: 'Copy transcript' }).click();
 
-  // The write was attempted but rejected, so the button must NOT flip to
-  // "Copied"; the failure surfaces instead.
+  // The write was attempted but rejected, so the entry must NOT flip to
+  // "Copied", and the menu must stay open rather than self-dismissing over the
+  // error the user needs to read.
   await expect(page.getByText(/Couldn't copy transcript/)).toBeVisible();
-  await expect(page.getByRole('button', { name: 'Copied' })).toHaveCount(0);
-  await expect(page.getByRole('button', { name: 'Copy transcript' })).toBeVisible();
+  await expect(menu.getByRole('button', { name: 'Copied' })).toHaveCount(0);
+  await expect(menu.getByRole('button', { name: 'Copy transcript' })).toBeVisible();
 });
 
 test('Save transcript as .md passes the same built bundle to export-transcript', async ({
@@ -123,12 +128,13 @@ test('Save transcript as .md passes the same built bundle to export-transcript',
 
     // Capture what Copy puts on the clipboard, then Save, and assert the file
     // the export handler received is byte-for-byte the same bundle.
-    await page.getByRole('button', { name: 'Copy transcript' }).click();
+    const copyMenu = await openShareMenu(page);
+    await copyMenu.getByRole('button', { name: 'Copy transcript' }).click();
     const [copied] = await clipboardWrites(page);
     expect(copied).toBeTruthy();
 
-    await page.getByRole('button', { name: 'More options' }).click();
-    await page.getByRole('button', { name: /Save transcript as \.md/ }).click();
+    const saveMenu = await openShareMenu(page);
+    await saveMenu.getByRole('button', { name: /Save transcript as \.md/ }).click();
 
     await expect.poll(() => {
       try {