From 45ab27fabf46743a8de7cea1fca694c4f10a86e3 Mon Sep 17 00:00:00 2001
From: JSdotNet <Job.Schepers@gmail.com>
Date: Sun, 27 Sep 2026 00:32:49 +0200
Subject: [PATCH 1/2] Add the talk-note screen with pictures and file
 attachments

A note taken during a conference talk (what was said, the slide photo, the
handout) now lands in the desktop Inbox as one ordinary capture. It is called a
talk note throughout, never a session note: Sessions is its own bounded context.

- /note in Backlog.Mobile.UI has a title, a Markdown body that dictation
  appends to, the speaker as one @name, tags, and an attachment strip. The
  draft lives in a scoped TalkNoteDraft, so it survives tab switches and
  backgrounding.
- IAttachmentPicker mirrors ISpeechTranscriber. Android uses MediaPicker and
  FilePicker (CAMERA and the IMAGE_CAPTURE query are in the manifest). The
  harness uses hidden <InputFile multiple> elements.
- A file over the 25 MB cap or off the ADR 0014 allowlist is refused on its
  tile with the reason, and the note is not sent until it is removed. The cap
  and the allowlist move to SyncAttachmentLimits in Sync.Abstractions, so the
  phone and the service share one list.
- Pictures are downscaled with SkiaSharp before they queue: 1600 px longest
  edge, JPEG, EXIF reduced to the orientation. A per-note "Send originals"
  switch keeps them as taken.
- A sent note is one outbox entry of kind talk-note. It uploads each file
  (PUT /api/sync/attachments/{id}) and checkpoints it through the new
  IStagedOutboxKind, so a retry never re-sends an uploaded id and each file
  gets its own attempt budget. It then posts the capture naming them.
  DeviceOutbox.Sending drives "waiting / uploading 2 of 3 / synced".
- Pending talk notes show in the phone's Inbox list, marked waiting.
- An AttachmentStrip library component with its storybook page.
- The button reads "Send to Inbox" rather than "Save".
  interaction-guidelines.md#auto-save-no-save-buttons forbids a Save button
  as the means of persistence.
- Devbook: a Talk note sub-feature in capture/features.md, a Talk Note Upload
  sequence in arc42/06, and a SkiaSharp entry in tech/mobile.md.

Plan item talk-note-screen of plan mobile-inbox-slice.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .devbook/arc42/06-runtime-view.md             |  67 +++-
 .devbook/domain/capture/features.md           |  32 ++
 .devbook/tech/mobile.md                       |  22 ++
 .qa-workspacetalk-note-screenpage.html        |   1 +
 .qa-workspacetalk-note-screentool.exe         |   1 +
 Directory.Packages.props                      |   6 +
 .../Backlog.Mobile.UI.csproj                  |   2 +
 .../Components/Pages/Inbox.razor              |  10 +-
 .../Components/Pages/Note.razor               | 298 +++++++++++++++-
 .../Components/WebAttachmentInputs.razor      |  34 ++
 .../Backlog.Mobile.UI/Outbox/DeviceOutbox.cs  |  38 ++-
 .../Backlog.Mobile.UI/Outbox/IOutboxKind.cs   |  19 ++
 .../Outbox/TalkNoteOutboxKind.cs              | 121 +++++++
 .../Services/CloudSyncClient.cs               |  29 ++
 .../Services/IAttachmentPicker.cs             |  54 +++
 .../MobileShellServiceCollectionExtensions.cs |   8 +
 .../Services/WebAttachmentPicker.cs           | 161 +++++++++
 .../TalkNotes/AttachmentRules.cs              | 112 ++++++
 .../TalkNotes/ExifOrientation.cs              | 132 ++++++++
 .../TalkNotes/PictureDownscaler.cs            | 101 ++++++
 .../TalkNotes/TalkNoteComposer.cs             |  88 +++++
 .../TalkNotes/TalkNoteDraft.cs                |  96 ++++++
 .../TalkNotes/TalkNoteFiles.cs                |  92 +++++
 .../TalkNotes/TalkNoteTitle.cs                |  51 +++
 src/App/Backlog.Mobile.UI/wwwroot/app.css     |  24 ++
 .../Backlog.Mobile.UI/wwwroot/attachments.js  |  14 +
 src/App/Backlog.Mobile/MauiProgram.cs         |   4 +
 .../Platforms/Android/AndroidManifest.xml     |   8 +
 .../Services/AndroidAttachmentPicker.cs       |  87 +++++
 .../Inputs/AttachmentStrip.razor              |  79 +++++
 .../Inputs/AttachmentTile.cs                  |  20 ++
 .../wwwroot/components.css                    |  69 ++++
 .../Backlog.Mobile.WebHarness/Program.cs      |   5 +
 .../Pages/AttachmentStripPage.razor           | 102 ++++++
 .../Components/Shared/StorybookIndex.cs       |   6 +
 .../SyncAttachmentLimits.cs                   |  43 +++
 .../Options/SyncAttachmentOptions.cs          |  30 +-
 .../StorybookOrderTests.cs                    |   2 +-
 .../Backlog.Mobile.UI.UnitTests.csproj        |   6 +
 .../Fixtures/handout.pdf                      | Bin 0 -> 597 bytes
 .../Fixtures/slide-photo.jpg                  | Bin 0 -> 79450 bytes
 .../InMemoryDeviceStore.cs                    |   5 +
 .../PictureDownscalerTests.cs                 |  91 +++++
 .../ScriptedInboxService.cs                   |  26 +-
 .../Backlog.Mobile.UI.UnitTests/ShellHost.cs  |   6 +
 .../ShellNavigationTests.cs                   |   2 +-
 .../TalkNoteOutboxTests.cs                    | 319 ++++++++++++++++++
 .../TalkNoteScreenTests.cs                    | 153 +++++++++
 .../TalkNoteTitleTests.cs                     |  59 ++++
 .../TestAttachmentPicker.cs                   |  46 +++
 .../AttachmentStripTests.cs                   |  71 ++++
 51 files changed, 2811 insertions(+), 41 deletions(-)
 create mode 100644 .qa-workspacetalk-note-screenpage.html
 create mode 100644 .qa-workspacetalk-note-screentool.exe
 create mode 100644 src/App/Backlog.Mobile.UI/Components/WebAttachmentInputs.razor
 create mode 100644 src/App/Backlog.Mobile.UI/Outbox/TalkNoteOutboxKind.cs
 create mode 100644 src/App/Backlog.Mobile.UI/Services/IAttachmentPicker.cs
 create mode 100644 src/App/Backlog.Mobile.UI/Services/WebAttachmentPicker.cs
 create mode 100644 src/App/Backlog.Mobile.UI/TalkNotes/AttachmentRules.cs
 create mode 100644 src/App/Backlog.Mobile.UI/TalkNotes/ExifOrientation.cs
 create mode 100644 src/App/Backlog.Mobile.UI/TalkNotes/PictureDownscaler.cs
 create mode 100644 src/App/Backlog.Mobile.UI/TalkNotes/TalkNoteComposer.cs
 create mode 100644 src/App/Backlog.Mobile.UI/TalkNotes/TalkNoteDraft.cs
 create mode 100644 src/App/Backlog.Mobile.UI/TalkNotes/TalkNoteFiles.cs
 create mode 100644 src/App/Backlog.Mobile.UI/TalkNotes/TalkNoteTitle.cs
 create mode 100644 src/App/Backlog.Mobile.UI/wwwroot/attachments.js
 create mode 100644 src/App/Backlog.Mobile/Services/AndroidAttachmentPicker.cs
 create mode 100644 src/Core/Backlog.UI.Components/Inputs/AttachmentStrip.razor
 create mode 100644 src/Core/Backlog.UI.Components/Inputs/AttachmentTile.cs
 create mode 100644 src/Harness/Backlog.UI.Storybook/Components/Pages/AttachmentStripPage.razor
 create mode 100644 src/Modules/Sync/Backlog.Modules.Sync.Abstractions/SyncAttachmentLimits.cs
 create mode 100644 tests/Backlog.Mobile.UI.UnitTests/Fixtures/handout.pdf
 create mode 100644 tests/Backlog.Mobile.UI.UnitTests/Fixtures/slide-photo.jpg
 create mode 100644 tests/Backlog.Mobile.UI.UnitTests/PictureDownscalerTests.cs
 create mode 100644 tests/Backlog.Mobile.UI.UnitTests/TalkNoteOutboxTests.cs
 create mode 100644 tests/Backlog.Mobile.UI.UnitTests/TalkNoteScreenTests.cs
 create mode 100644 tests/Backlog.Mobile.UI.UnitTests/TalkNoteTitleTests.cs
 create mode 100644 tests/Backlog.Mobile.UI.UnitTests/TestAttachmentPicker.cs
 create mode 100644 tests/Backlog.UI.Components.UnitTests/AttachmentStripTests.cs

diff --git a/.devbook/arc42/06-runtime-view.md b/.devbook/arc42/06-runtime-view.md
index 90ec1dee5..064e1f33d 100644
--- a/.devbook/arc42/06-runtime-view.md
+++ b/.devbook/arc42/06-runtime-view.md
@@ -89,8 +89,9 @@ when the service answers.
 
 - **One outbox, many kinds.** Each row is `id, kind, payload, attempts,
   last_error, created_at`. The `kind` picks the sender; `capture` is the first,
-  and later kinds (an attachment upload that must go ahead of its capture, a task
-  pushed to its own endpoint) join the same queue and the same order.
+  and later kinds join the same queue and the same order: `task`, pushed to its
+  own endpoint, and `talk-note`, one entry that is several requests — see
+  **Talk Note Upload**.
 - **Oldest first, head of line.** A transient failure (no network, a timeout, a
   5xx, or a 401 from a service that restarted with a new signing key) stops the
   flush, so nothing overtakes it. It is retried after 2s, 4s, 8s, 16s. The fifth
@@ -144,8 +145,8 @@ related: [".devbook/arc42/adr/0014-attachments-travel-through-a-blob-store-besid
 A capture's files travel beside it rather than inside it (local ADR 0014). The
 phone uploads each file first, under an id it mints itself, and posts the
 capture that names them after; the capture document carries only their
-metadata. The service side is built; the phone's upload and the desktop's
-intake are later slices.
+metadata. The service side and the phone's upload are built — the phone's half
+is the talk note, below; the desktop's intake is a later slice.
 
 - **Upload, then capture.** `PUT /api/sync/attachments/{id}` carries the bytes,
   their declared `Content-Type` and their SHA-256 in `X-Attachment-Sha256`. The
@@ -202,6 +203,64 @@ sequenceDiagram
     Sync-->>-Desktop: 200
 ```
 
+## Talk Note Upload
+
+```meta
+related: [".devbook/domain/capture/features.md#talk-note", ".devbook/arc42/06-runtime-view.md#capture-attachments", ".devbook/arc42/06-runtime-view.md#mobile-capture-and-sync"]
+```
+
+A talk note is the phone's half of **Capture Attachments**: one outbox entry of
+kind `talk-note` whose payload is the capture — attachment metadata included —
+and the ids of the files already uploaded. The bytes wait beside the database
+in `talk-notes/outbox/`, since an outbox row holds JSON.
+
+- **Prepared once, at Send.** Each picture is downscaled (1600 px longest edge,
+  JPEG, EXIF reduced to the orientation) unless the note keeps originals; the
+  size and SHA-256 are taken from the bytes that will actually go.
+- **Uploads, checkpointed.** An attempt uploads each file not yet listed as
+  uploaded, then posts the capture. Every upload that lands is written back
+  into the entry before the next starts (`IStagedOutboxKind`), and hands the
+  entry its attempts back — so a retry resumes at the first file still to go,
+  and each file has the whole backoff budget of its own.
+- **One refusal refuses the note.** A 409, 413 or 415 on a file sets the entry
+  aside naming the file; the capture is never posted without it.
+- **Released on delivery.** The files are deleted from the phone once the
+  capture is taken (201, or 200 for an id the service already holds).
+- **Status from the outbox.** *synced* once the entry is gone, *uploading i of
+  n* while an attempt is sending its files, *waiting* otherwise, and *waiting —
+  tap to retry* once parked.
+
+```mermaid
+sequenceDiagram
+    actor ME
+    participant App as Phone App
+    participant Outbox as SQLite Outbox
+    participant Files as talk-notes/outbox
+    participant Sync as Sync Service
+
+    ME->>App: Send to Inbox (body, speaker, tags, files)
+    App->>Files: Downscale pictures, move files; size + sha256
+    App->>Outbox: INSERT (id v7, kind=talk-note, capture + uploaded=[])
+    App-->>ME: Inbox row marked waiting; note says "waiting"
+
+    loop Each file not yet uploaded
+        Outbox->>+Sync: PUT /api/sync/attachments/{id} (X-Attachment-Sha256)
+        alt 201, or 200 for the same bytes
+            Sync-->>Outbox: StoredAttachment
+            Outbox->>Outbox: Checkpoint: uploaded += id, attempts = 0
+        else No network, timeout, 5xx or 401
+            Sync-->>Outbox: Transient — attempts+1, back off, stop the flush
+        else 409, 413 or 415
+            Sync-->>-Outbox: Refused — set aside, naming the file
+        end
+    end
+
+    Outbox->>+Sync: POST /api/sync/inbox (same id, attachments: metadata)
+    Sync-->>-Outbox: 201 InboxItem
+    Outbox->>Outbox: DELETE entry
+    Outbox->>Files: Delete the note's files
+    App-->>ME: "synced"
+
 ## Mobile My Day and Task Push
 
 ```meta
diff --git a/.devbook/domain/capture/features.md b/.devbook/domain/capture/features.md
index 0cab1a0d3..851fceed2 100644
--- a/.devbook/domain/capture/features.md
+++ b/.devbook/domain/capture/features.md
@@ -73,6 +73,38 @@ down, on the refresh button and on returning to the app. When the service
 cannot answer, the last list the phone saw stays on screen with a line saying
 why it is not newer.
 
+### Talk note
+
+```meta
+type: sub-feature
+related: [".devbook/arc42/06-runtime-view.md#talk-note-upload", ".devbook/arc42/adr/0014-attachments-travel-through-a-blob-store-beside-the-replica.md"]
+```
+
+A note taken during a conference talk — what was said, the slide photo, the
+handout — that lands in the desktop Inbox as one ordinary capture. It is called
+a talk note, never a session note: Sessions is a bounded context of its own.
+
+The Note tab holds a title, a Markdown body that dictation appends to, the
+speaker as one `@name`, tags, and the files attached to it: photos taken with
+the camera, pictures and files chosen from the phone, several to a note. Each
+file shows its name, type and size. A file cloud sync would not take — over the
+per-file limit, or not a picture, PDF, text or Office file — stays on the strip
+with the reason written under it, and the note is not sent until it is taken
+off. The note being written survives a switch to another tab and the app going
+to the background.
+
+Pictures are made smaller before they leave: at most 1600 pixels on the longest
+side, as JPEG, with the location, camera and time details removed and only the
+way-up kept. A note can keep its pictures as taken instead. Files go as they
+are.
+
+Sending the note keeps it on the phone first, like any capture, and it appears
+in the Inbox list marked waiting. Each file is uploaded before the capture that
+names it; a file that already went is never sent again, and a failed one is
+retried on its own. The note says where it stands — waiting, uploading 2 of 3,
+synced. A note sent without a title is named for the first line of its body,
+or "Photo · <date>" when a picture is attached, or else the first file's name.
+
 ### Share-sheet and shortcuts
 
 ```meta
diff --git a/.devbook/tech/mobile.md b/.devbook/tech/mobile.md
index 2e022c0fa..9676fa5c8 100644
--- a/.devbook/tech/mobile.md
+++ b/.devbook/tech/mobile.md
@@ -48,6 +48,28 @@ JSON-backed on-device storage for captures made while offline.
   (`.devbook/arc42/adr/0003-sqlite-is-the-canonical-local-task-store.md`), so adopting it
   here would mean sharing an adapter rather than introducing a new dependency.
 
+## SkiaSharp
+
+```meta
+status: adopted
+type: library
+version: "4.152.1"
+related: [".devbook/domain/capture/features.md#talk-note", ".devbook/arc42/adr/0014-attachments-travel-through-a-blob-store-beside-the-replica.md"]
+alternatives: ["ImageSharp", "Android Bitmap plus a browser canvas"]
+```
+
+The image codec the phone downscales a talk note's pictures with, before they
+enter the outbox.
+
+- **Used for** — decoding a slide photo, resizing it to a 1600 px longest edge
+  and re-encoding it as JPEG; the EXIF orientation is carried over by hand and
+  everything else in EXIF is dropped.
+- **Why** — MIT-licensed, with the Android and Windows natives in the package,
+  so the MAUI head, the browser harness and the unit tests run the one codec
+  and the downscaler has one implementation a test can hold. ImageSharp's split
+  licence and a per-platform pair (Android `Bitmap` beside a browser canvas)
+  were the alternatives.
+
 ## Android SDK Build Tools
 
 ```meta
diff --git a/.qa-workspacetalk-note-screenpage.html b/.qa-workspacetalk-note-screenpage.html
new file mode 100644
index 000000000..0cfc83780
--- /dev/null
+++ b/.qa-workspacetalk-note-screenpage.html
@@ -0,0 +1 @@
+<html><body>not an attachment</body></html>
diff --git a/.qa-workspacetalk-note-screentool.exe b/.qa-workspacetalk-note-screentool.exe
new file mode 100644
index 000000000..6bee438f1
--- /dev/null
+++ b/.qa-workspacetalk-note-screentool.exe
@@ -0,0 +1 @@
+fake exe content
diff --git a/Directory.Packages.props b/Directory.Packages.props
index 20520ceb1..cc47f79f5 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -157,6 +157,12 @@
       The version is the one Microsoft.Extensions.Http.Resilience above resolves.
     -->
     <PackageVersion Include="Polly.Core" Version="8.6.6" />
+    <!--
+      The phone's talk note shrinks a slide photo to 1600 px JPEG before it
+      enters the outbox. MIT, with the Android and Windows natives in the box, so
+      the MAUI head, the browser harness and the unit tests run one codec.
+    -->
+    <PackageVersion Include="SkiaSharp" Version="4.152.1" />
     <PackageVersion Include="System.Security.Cryptography.ProtectedData" Version="10.0.11" />
     <PackageVersion Include="xunit.runner.visualstudio" Version="4.0.0" />
     <PackageVersion Include="xunit.v3" Version="4.0.0" />
diff --git a/src/App/Backlog.Mobile.UI/Backlog.Mobile.UI.csproj b/src/App/Backlog.Mobile.UI/Backlog.Mobile.UI.csproj
index d5d0ea16b..e65824947 100644
--- a/src/App/Backlog.Mobile.UI/Backlog.Mobile.UI.csproj
+++ b/src/App/Backlog.Mobile.UI/Backlog.Mobile.UI.csproj
@@ -11,6 +11,8 @@
     <!-- The outbox and the cached inbox: what the phone keeps on itself so a
          capture outlives a dead network and the list outlives a cold replica. -->
     <PackageReference Include="Microsoft.Data.Sqlite" />
+    <!-- A talk note's pictures are downscaled on the phone before they queue. -->
+    <PackageReference Include="SkiaSharp" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/App/Backlog.Mobile.UI/Components/Pages/Inbox.razor b/src/App/Backlog.Mobile.UI/Components/Pages/Inbox.razor
index 6f5f2f840..a51e71194 100644
--- a/src/App/Backlog.Mobile.UI/Components/Pages/Inbox.razor
+++ b/src/App/Backlog.Mobile.UI/Components/Pages/Inbox.razor
@@ -237,12 +237,16 @@
         get
         {
             var pending = Outbox.Entries
-                .Where(entry => entry.Kind == CaptureOutboxKind.Token)
+                .Where(entry => entry.Kind is CaptureOutboxKind.Token or TalkNoteOutboxKind.Token)
                 .Select(entry =>
                 {
-                    var capture = CaptureOutboxKind.Read(entry);
+                    // A talk note is a capture with its uploads in front of it;
+                    // on the list it is the capture it will become.
+                    var capture = entry.Kind == TalkNoteOutboxKind.Token
+                        ? TalkNoteOutboxKind.Read(entry).Capture
+                        : CaptureOutboxKind.Read(entry);
                     return new Row(
-                        new InboxItem(entry.Id, capture.Title, capture.Source, entry.CreatedAt, capture.BodyMd, capture.Tags, capture.Person),
+                        new InboxItem(entry.Id, capture.Title, capture.Source, entry.CreatedAt, capture.BodyMd, capture.Tags, capture.Person, capture.Attachments),
                         entry);
                 })
                 .ToList();
diff --git a/src/App/Backlog.Mobile.UI/Components/Pages/Note.razor b/src/App/Backlog.Mobile.UI/Components/Pages/Note.razor
index aea0be1c4..764f6c18e 100644
--- a/src/App/Backlog.Mobile.UI/Components/Pages/Note.razor
+++ b/src/App/Backlog.Mobile.UI/Components/Pages/Note.razor
@@ -1,12 +1,300 @@
 @page "/note"
+@using Backlog.Mobile.UI.Services
+@using Backlog.Mobile.UI.TalkNotes
+@inject TalkNoteDraft Draft
+@inject TalkNoteFiles Files
+@inject TalkNoteComposer Composer
+@inject DeviceOutbox Outbox
+@inject IAttachmentPicker Picker
+@inject ISpeechTranscriber Speech
+@implements IDisposable
 
 @*
-    A placeholder, so the Note tab has a route to land on. The note screen itself
-    is a later entry of the mobile-inbox-slice plan.
+    A talk note: what was said in a talk, the slide photo and the handout, kept
+    on the phone until cloud sync takes it and delivered to the desktop Inbox as
+    one ordinary capture. Not a "session note" — Sessions is its own bounded
+    context here, and one word for two things is what this name avoids.
 *@
 
-<PageTitle>Note</PageTitle>
+<PageTitle>Talk note</PageTitle>
 
-<h1>Note</h1>
+<h1>Talk note</h1>
 
-<EmptyState Title="Notes are on their way." Description="Writing a note from the phone arrives in a later update." TestId="note-placeholder" />
+<div class="talk-note">
+    <TextField @bind-Value="Draft.Title" Label="Title" Placeholder="Or the first line of the note"
+               CssClass="talk-note__field" TestId="note-title" />
+
+    <div class="talk-note__body">
+        <TextArea @bind-Value="Draft.Body" Label="Note" Placeholder="What was said — Markdown works" Rows="6"
+                  CssClass="talk-note__field" TestId="note-body" />
+        @* Dictation appends to the body, as it does to the Inbox's quick capture:
+           nothing is sent that the person has not read first. *@
+        <ToggleButton Pressed="_listening"
+                      PressedChanged="OnSpeechToggledAsync"
+                      Disabled="@(_speechSupported != true)"
+                      AriaLabel="@(_listening ? "Stop dictating" : "Dictate into the note")"
+                      Title="@(_listening ? "Stop dictating" : "Dictate into the note")"
+                      CssClass="talk-note__mic"
+                      TestId="note-speech-toggle">
+            <svg viewBox="0 0 16 16" width="16" height="16" fill="none" stroke="currentColor"
+                 stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true" focusable="false">
+                <rect x="6" y="1.75" width="4" height="7.5" rx="2" />
+                <path d="M3.75 7.25v.75a4.25 4.25 0 0 0 8.5 0v-.75" />
+                <path d="M8 12.25v2" />
+            </svg>
+        </ToggleButton>
+    </div>
+
+    @if (_speechStatus is not null)
+    {
+        <Alert Message="@_speechStatus" Role="status" BaseClass="capture__status" TestId="note-speech-status" />
+    }
+
+    <TextField @bind-Value="Draft.Speaker" Label="Speaker" Placeholder="@@name"
+               ErrorMessage="@Draft.SpeakerProblem" CssClass="talk-note__field" TestId="note-speaker" />
+
+    <TextField @bind-Value="Draft.Tags" Label="Tags" Placeholder="#conference, #keynote"
+               CssClass="talk-note__field" TestId="note-tags" />
+
+    <div class="talk-note__attach" role="group" aria-label="Attach">
+        @if (_canTakePhoto)
+        {
+            <AppButton Size="ButtonSize.Small" Disabled="_picking" OnClick="() => PickAsync(Picker.TakePhotoAsync)"
+                       TestId="note-take-photo">Take photo</AppButton>
+        }
+        <AppButton Size="ButtonSize.Small" Disabled="_picking" OnClick="() => PickAsync(Picker.PickPicturesAsync)"
+                   TestId="note-choose-pictures">Choose pictures</AppButton>
+        <AppButton Size="ButtonSize.Small" Disabled="_picking" OnClick="() => PickAsync(Picker.PickFilesAsync)"
+                   TestId="note-choose-files">Choose files</AppButton>
+    </div>
+
+    @if (Picker is WebAttachmentPicker web)
+    {
+        <WebAttachmentInputs Picker="web" />
+    }
+
+    @if (_pickError is not null)
+    {
+        <Alert Message="@_pickError" BaseClass="error" TestId="note-pick-error" />
+    }
+
+    <AttachmentStrip Tiles="Tiles" OnRemove="RemoveAsync" AriaLabel="Attached to this note" TestId="note-attachments" />
+
+    @if (Draft.Attachments.Any(attachment => attachment.IsPicture))
+    {
+        <Toggle @bind-Checked="Draft.SendOriginals" Label="Send originals"
+                Description="Keep pictures as taken. Otherwise they go as 1600 px JPEGs, without location or camera details."
+                TestId="note-send-originals" />
+    }
+
+    @if (Draft.HasRefused)
+    {
+        <Alert Message="Remove the files marked above to send the note — they would not go with it." Role="status"
+               BaseClass="capture__notice" TestId="note-refused-notice" />
+    }
+
+    @* Not "Save": the draft already keeps itself (interaction-guidelines.md#auto-save-no-save-buttons).
+       This hands the note to the outbox, the way Capture does on the Inbox. *@
+    <AppButton Variant="ButtonVariant.Primary" Disabled="@(!Draft.CanSave || _saving)" OnClick="SaveAsync"
+               TestId="note-send">Send to Inbox</AppButton>
+
+    @if (_saveError is not null)
+    {
+        <Alert Message="@_saveError" BaseClass="error" TestId="note-save-error" />
+    }
+
+    @if (Draft.LastSaved is { } saved)
+    {
+        var status = TalkNoteOutboxKind.StatusOf(Outbox, saved);
+
+        <p class="talk-note__status" role="status" data-testid="note-status" data-status="@status">
+            <span>Last note: @status</span>
+            @if (status.EndsWith("tap to retry", StringComparison.Ordinal))
+            {
+                <AppButton Size="ButtonSize.Small" OnClick="() => Outbox.RetryAsync(saved)" TestId="note-retry">Retry</AppButton>
+            }
+        </p>
+    }
+</div>
+
+@code {
+    private const string Listening = "Listening…";
+
+    private bool? _speechSupported;
+    private bool _listening;
+    private string? _speechStatus;
+
+    private bool _canTakePhoto;
+    private bool _picking;
+    private string? _pickError;
+
+    private bool _saving;
+    private string? _saveError;
+
+    private IReadOnlyList<AttachmentTile> Tiles =>
+    [
+        .. Draft.Attachments.Select(attachment => new AttachmentTile(
+            attachment.Id.ToString("N"),
+            attachment.Name,
+            AttachmentRules.Describe(attachment.ContentType),
+            AttachmentRules.DescribeSize(attachment.SizeBytes),
+            attachment.IsPicture,
+            attachment.Refusal))
+    ];
+
+    protected override void OnInitialized()
+    {
+        Outbox.Changed += OnOutboxChanged;
+        if (Picker is WebAttachmentPicker web) web.Unrequested += OnUnrequestedAsync;
+    }
+
+    public void Dispose()
+    {
+        Outbox.Changed -= OnOutboxChanged;
+        if (Picker is WebAttachmentPicker web) web.Unrequested -= OnUnrequestedAsync;
+    }
+
+    /// <summary>Asked after the first render, as the Inbox asks: prerendered on
+    /// the server there is no browser to ask, and "no" would be a lie.</summary>
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        if (!firstRender) return;
+
+        _canTakePhoto = await Picker.CanTakePhotoAsync();
+        _speechSupported = await Speech.IsSupportedAsync();
+        StateHasChanged();
+    }
+
+    private void OnOutboxChanged() => _ = InvokeAsync(StateHasChanged);
+
+    private async Task PickAsync(Func<CancellationToken, Task<AttachmentPick>> pick)
+    {
+        _picking = true;
+        _pickError = null;
+
+        try
+        {
+            await AddAsync(await pick(CancellationToken.None));
+        }
+        finally
+        {
+            _picking = false;
+        }
+    }
+
+    /// <summary>Files set on the harness's input without a button press —
+    /// Playwright's way in — are taken like any other pick.</summary>
+    private Task OnUnrequestedAsync(AttachmentPick pick) => InvokeAsync(async () =>
+    {
+        await AddAsync(pick);
+        StateHasChanged();
+    });
+
+    /// <summary>Each file is staged on the device at once: a browser file is
+    /// readable only until the next pick, and a draft has to outlive the page.</summary>
+    private async Task AddAsync(AttachmentPick pick)
+    {
+        if (pick.IsError)
+        {
+            _pickError = pick.Error;
+            return;
+        }
+
+        foreach (var file in pick.Files)
+        {
+            try
+            {
+                Draft.Attachments.Add(await Files.StageAsync(file, Draft.Attachments.Count));
+            }
+            catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+            {
+                _pickError = $"Couldn't attach {file.Name}: {ex.Message}";
+            }
+        }
+    }
+
+    private Task RemoveAsync(AttachmentTile tile)
+    {
+        var attachment = Draft.Attachments.Find(candidate => candidate.Id.ToString("N") == tile.Key);
+        if (attachment is not null)
+        {
+            Draft.Attachments.Remove(attachment);
+            TalkNoteFiles.Discard(attachment);
+        }
+
+        return Task.CompletedTask;
+    }
+
+    /// <summary>
+    /// Queues the note and clears the fields. The outbox takes it from here —
+    /// the uploads, then the capture — and the line under the button follows it.
+    /// </summary>
+    private async Task SaveAsync()
+    {
+        _saving = true;
+        _saveError = null;
+
+        try
+        {
+            await Composer.SaveAsync(Draft);
+            _speechStatus = null;
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            _saveError = $"Couldn't send the note: {ex.Message}";
+        }
+        finally
+        {
+            _saving = false;
+        }
+    }
+
+    private async Task OnSpeechToggledAsync(bool pressed)
+    {
+        if (!pressed)
+        {
+            await Speech.StopAsync();
+            return;
+        }
+
+        _listening = true;
+        _speechStatus = Listening;
+
+        // Not awaited: ListenAsync ends when recognition does, and the pressed
+        // state has to reach the screen before that.
+        _ = ListenAsync();
+    }
+
+    private async Task ListenAsync()
+    {
+        SpeechTranscript result;
+
+        try
+        {
+            result = await Speech.ListenAsync();
+        }
+        catch (Exception ex)
+        {
+            result = SpeechTranscript.Failed(ex.Message);
+        }
+
+        _listening = false;
+
+        if (result.IsError)
+        {
+            _speechStatus = result.Error;
+        }
+        else if (result.Text.Length == 0)
+        {
+            _speechStatus = "Nothing was heard.";
+        }
+        else
+        {
+            _speechStatus = null;
+            var existing = Draft.Body.TrimEnd();
+            Draft.Body = existing.Length == 0 ? result.Text : $"{existing} {result.Text}";
+        }
+
+        await InvokeAsync(StateHasChanged);
+    }
+}
diff --git a/src/App/Backlog.Mobile.UI/Components/WebAttachmentInputs.razor b/src/App/Backlog.Mobile.UI/Components/WebAttachmentInputs.razor
new file mode 100644
index 000000000..f85271753
--- /dev/null
+++ b/src/App/Backlog.Mobile.UI/Components/WebAttachmentInputs.razor
@@ -0,0 +1,34 @@
+@using Backlog.Mobile.UI.Services
+
+@*
+    The three file inputs WebAttachmentPicker clicks, kept out of sight: the
+    buttons a person presses are the Note page's own AppButtons, and these only
+    exist because a browser opens its dialog for an input in the page.
+*@
+
+<div class="web-attachment-inputs" hidden>
+    <InputFile @ref="_camera" OnChange="Picker.OnChanged" accept="image/*" capture="environment"
+               aria-label="Take a photo" data-testid="note-input-camera" />
+    <InputFile @ref="_pictures" OnChange="Picker.OnChanged" multiple accept="image/*"
+               aria-label="Choose pictures" data-testid="note-input-pictures" />
+    <InputFile @ref="_files" OnChange="Picker.OnChanged" multiple accept="@WebAttachmentPicker.FilesAccept"
+               aria-label="Choose files" data-testid="note-input-files" />
+</div>
+
+@code {
+    private InputFile? _camera;
+    private InputFile? _pictures;
+    private InputFile? _files;
+
+    [Parameter, EditorRequired]
+    public WebAttachmentPicker Picker { get; set; } = default!;
+
+    protected override void OnAfterRender(bool firstRender)
+    {
+        if (!firstRender) return;
+
+        if (_camera?.Element is { } camera) Picker.Register(WebAttachmentSource.Camera, camera);
+        if (_pictures?.Element is { } pictures) Picker.Register(WebAttachmentSource.Pictures, pictures);
+        if (_files?.Element is { } files) Picker.Register(WebAttachmentSource.Files, files);
+    }
+}
diff --git a/src/App/Backlog.Mobile.UI/Outbox/DeviceOutbox.cs b/src/App/Backlog.Mobile.UI/Outbox/DeviceOutbox.cs
index 651fda7d4..dbcbd291e 100644
--- a/src/App/Backlog.Mobile.UI/Outbox/DeviceOutbox.cs
+++ b/src/App/Backlog.Mobile.UI/Outbox/DeviceOutbox.cs
@@ -93,6 +93,10 @@ public IReadOnlyList<OutboxEntry> Entries
     /// delivery.</summary>
     public bool Unreachable { get; private set; }
 
+    /// <summary>The entry an attempt is under way for, or null between attempts.
+    /// A screen reads it to say "uploading" rather than "waiting".</summary>
+    public Guid? Sending { get; private set; }
+
     /// <summary>The wait after <paramref name="failedAttempts"/> failures.</summary>
     public static TimeSpan DelayAfter(int failedAttempts) =>
         FirstRetryDelay * Math.Pow(2, Math.Max(0, failedAttempts - 1));
@@ -218,6 +222,10 @@ private async Task FlushDueAsync(CancellationToken cancellationToken)
 
             var delivery = await SendAsync(entry, cancellationToken);
 
+            // A staged kind may have checkpointed while it ran; what follows
+            // builds on the entry as it now stands, not on the copy it was sent.
+            var latest = Find(entry.Id) ?? entry;
+
             switch (delivery.Kind)
             {
                 case OutboxDeliveryKind.Delivered:
@@ -232,12 +240,12 @@ private async Task FlushDueAsync(CancellationToken cancellationToken)
                 case OutboxDeliveryKind.Refused:
                     // Not a network problem, and not one a timer will fix — so it
                     // is set aside rather than holding up the entries behind it.
-                    await ReplaceAsync(entry with { Refused = true, LastError = delivery.Error }, cancellationToken);
+                    await ReplaceAsync(latest with { Refused = true, LastError = delivery.Error }, cancellationToken);
                     Changed?.Invoke();
                     continue;
 
                 default:
-                    var failed = entry with { Attempts = entry.Attempts + 1, LastError = delivery.Error };
+                    var failed = latest with { Attempts = latest.Attempts + 1, LastError = delivery.Error };
                     await ReplaceAsync(failed, cancellationToken);
                     Unreachable = true;
                     Changed?.Invoke();
@@ -272,9 +280,14 @@ private async Task<OutboxDelivery> SendAsync(OutboxEntry entry, CancellationToke
             return OutboxDelivery.Refused($"Nothing on this phone sends a '{entry.Kind}' entry.");
         }
 
+        Sending = entry.Id;
+        Changed?.Invoke();
+
         try
         {
-            return await kind.SendAsync(entry, cancellationToken);
+            return kind is IStagedOutboxKind staged
+                ? await staged.SendAsync(entry, (payload, ct) => CheckpointAsync(entry.Id, payload, ct), cancellationToken)
+                : await kind.SendAsync(entry, cancellationToken);
         }
         catch (Exception ex) when (ex is not OperationCanceledException || !cancellationToken.IsCancellationRequested)
         {
@@ -282,6 +295,25 @@ private async Task<OutboxDelivery> SendAsync(OutboxEntry entry, CancellationToke
             // treated as the network's, which is the case a retry can cure.
             return OutboxDelivery.Transient(ex.Message);
         }
+        finally
+        {
+            Sending = null;
+        }
+    }
+
+    /// <summary>A staged kind's request landed: keep what it has sent, and give
+    /// the entry its attempts back for the next one.</summary>
+    private async Task CheckpointAsync(Guid id, string payloadJson, CancellationToken cancellationToken)
+    {
+        if (Find(id) is not { } current) return;
+
+        await ReplaceAsync(current with { PayloadJson = payloadJson, Attempts = 0, LastError = null }, cancellationToken);
+        Changed?.Invoke();
+    }
+
+    private OutboxEntry? Find(Guid id)
+    {
+        lock (_entriesLock) return _entries.Find(queued => queued.Id == id);
     }
 
     private async Task ReplaceAsync(OutboxEntry entry, CancellationToken cancellationToken)
diff --git a/src/App/Backlog.Mobile.UI/Outbox/IOutboxKind.cs b/src/App/Backlog.Mobile.UI/Outbox/IOutboxKind.cs
index f53d7f7b1..7a2c619eb 100644
--- a/src/App/Backlog.Mobile.UI/Outbox/IOutboxKind.cs
+++ b/src/App/Backlog.Mobile.UI/Outbox/IOutboxKind.cs
@@ -23,6 +23,25 @@ public interface IOutboxKind
     Task<OutboxDelivery> SendAsync(OutboxEntry entry, CancellationToken cancellationToken);
 }
 
+/// <summary>
+/// A kind whose one entry is several requests — a talk note's uploads and then
+/// the capture that names them. Between requests it hands the outbox a new
+/// payload recording what has already gone, and the outbox keeps it, so the
+/// next attempt starts after the last request that landed rather than from the
+/// first. What has been sent is never sent again.
+/// </summary>
+public interface IStagedOutboxKind : IOutboxKind
+{
+    /// <summary>One attempt, calling <paramref name="checkpoint"/> with the
+    /// entry's new payload each time a request lands. The outbox stores it before
+    /// the call returns and gives the entry its attempts back: progress was made,
+    /// so the next request starts with the whole budget.</summary>
+    Task<OutboxDelivery> SendAsync(
+        OutboxEntry entry,
+        Func<string, CancellationToken, Task> checkpoint,
+        CancellationToken cancellationToken);
+}
+
 /// <summary>How one attempt went.</summary>
 public sealed record OutboxDelivery(OutboxDeliveryKind Kind, string? Error = null)
 {
diff --git a/src/App/Backlog.Mobile.UI/Outbox/TalkNoteOutboxKind.cs b/src/App/Backlog.Mobile.UI/Outbox/TalkNoteOutboxKind.cs
new file mode 100644
index 000000000..214ffb913
--- /dev/null
+++ b/src/App/Backlog.Mobile.UI/Outbox/TalkNoteOutboxKind.cs
@@ -0,0 +1,121 @@
+using System.Text.Json;
+
+using Backlog.Mobile.UI.Services;
+using Backlog.Mobile.UI.TalkNotes;
+using Backlog.Modules.Sync.Abstractions.DataTransferObjects;
+
+namespace Backlog.Mobile.UI.Outbox;
+
+/// <summary>
+/// A talk note, as one outbox entry: its attachments uploaded first, each to
+/// <c>PUT /api/sync/attachments/{id}</c>, then the capture naming them posted to
+/// <c>POST /api/sync/inbox</c> — the order local ADR 0014 requires, since the
+/// service refuses a capture naming a file it does not have.
+/// <para>
+/// One entry rather than one per file, so a saved note is queued whole or not at
+/// all. Each upload that lands is checkpointed into the payload, so a retry
+/// starts at the first file still to go and never sends one twice; and each gets
+/// the full attempt budget, since the checkpoint hands the attempts back. A file
+/// the service refuses (409, 413, 415) refuses the entry, naming the file: the
+/// capture would be refused for the missing attachment anyway.
+/// </para>
+/// </summary>
+public sealed class TalkNoteOutboxKind(CloudSyncClient sync, TalkNoteFiles files) : IStagedOutboxKind
+{
+    /// <summary>A stored value — the <c>kind</c> column of every queued talk note.</summary>
+    public const string Token = "talk-note";
+
+    private static readonly JsonSerializerOptions Json = new(JsonSerializerDefaults.Web);
+
+    public string Kind => Token;
+
+    public static string Write(TalkNotePayload payload) => JsonSerializer.Serialize(payload, Json);
+
+    public static TalkNotePayload Read(OutboxEntry entry)
+    {
+        ArgumentNullException.ThrowIfNull(entry);
+
+        return JsonSerializer.Deserialize<TalkNotePayload>(entry.PayloadJson, Json)
+            ?? throw new InvalidOperationException($"Outbox entry {entry.Id} holds no talk note.");
+    }
+
+    public Task<OutboxDelivery> SendAsync(OutboxEntry entry, CancellationToken cancellationToken) =>
+        SendAsync(entry, (_, _) => Task.CompletedTask, cancellationToken);
+
+    public async Task<OutboxDelivery> SendAsync(
+        OutboxEntry entry,
+        Func<string, CancellationToken, Task> checkpoint,
+        CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(checkpoint);
+
+        var payload = Read(entry);
+        var attachments = payload.Capture.Attachments ?? [];
+
+        foreach (var attachment in attachments)
+        {
+            if (payload.Uploaded.Contains(attachment.Id)) continue;
+
+            var path = files.OutboxPath(attachment.Id);
+            if (!File.Exists(path))
+            {
+                return OutboxDelivery.Refused($"{attachment.Name} is no longer on this phone.");
+            }
+
+            var delivery = await OutboxDelivery.AttemptAsync(
+                async () =>
+                {
+                    await using var content = File.OpenRead(path);
+                    return await sync.PutAttachmentAsync(attachment, content, cancellationToken);
+                },
+                cancellationToken);
+
+            if (delivery.Kind != OutboxDeliveryKind.Delivered)
+            {
+                return delivery with { Error = $"{attachment.Name}: {delivery.Error}" };
+            }
+
+            payload = payload with { Uploaded = [.. payload.Uploaded, attachment.Id] };
+            await checkpoint(Write(payload), cancellationToken);
+        }
+
+        // The entry's id wins over the payload's, as for a plain capture: it is
+        // the one every retry repeats and the service de-duplicates on.
+        var capture = payload.Capture with { Id = entry.Id };
+        var posted = await OutboxDelivery.AttemptAsync(() => sync.PostCaptureAsync(capture, cancellationToken), cancellationToken);
+
+        if (posted.Kind == OutboxDeliveryKind.Delivered)
+        {
+            foreach (var attachment in attachments) files.Release(attachment.Id);
+        }
+
+        return posted;
+    }
+
+    /// <summary>
+    /// What the page says about a saved note: "synced" once the outbox has
+    /// let it go, "uploading 2 of 3" while an attempt is sending its files,
+    /// otherwise "waiting" — or "waiting — tap to retry" once it is parked.
+    /// </summary>
+    public static string StatusOf(DeviceOutbox outbox, Guid id)
+    {
+        ArgumentNullException.ThrowIfNull(outbox);
+
+        if (outbox.Entries.FirstOrDefault(entry => entry.Id == id) is not { } entry) return "synced";
+        if (entry.IsParked) return "waiting — tap to retry";
+
+        var payload = Read(entry);
+        var total = payload.Capture.Attachments?.Count ?? 0;
+        var uploaded = payload.Uploaded.Count;
+
+        return outbox.Sending == id && uploaded < total
+            ? $"uploading {uploaded + 1} of {total}"
+            : "waiting";
+    }
+}
+
+/// <summary>
+/// A queued talk note: the capture as it will be posted, attachment metadata
+/// included, and the ids of the attachments already uploaded.
+/// </summary>
+public sealed record TalkNotePayload(CaptureRequest Capture, IReadOnlyList<Guid> Uploaded);
diff --git a/src/App/Backlog.Mobile.UI/Services/CloudSyncClient.cs b/src/App/Backlog.Mobile.UI/Services/CloudSyncClient.cs
index d97b5b52b..7843079e2 100644
--- a/src/App/Backlog.Mobile.UI/Services/CloudSyncClient.cs
+++ b/src/App/Backlog.Mobile.UI/Services/CloudSyncClient.cs
@@ -2,6 +2,7 @@
 using System.Net.Http.Json;
 using System.Text.Json;
 
+using Backlog.Modules.Sync.Abstractions;
 using Backlog.Modules.Sync.Abstractions.DataTransferObjects;
 
 namespace Backlog.Mobile.UI.Services;
@@ -52,6 +53,34 @@ public async Task<IReadOnlyList<InboxItem>> GetInboxAsync(CancellationToken ct =
         return (response.StatusCode, problem.Detail);
     }
 
+    /// <summary>
+    /// One attempt at one attachment's bytes, under its own id, with the digest
+    /// the service checks them against. 201 is a new upload and 200 the same
+    /// bytes already there — both mean the capture may now name it. Throws only
+    /// when there was no answer at all.
+    /// </summary>
+    public async Task<(HttpStatusCode Status, string? Detail)> PutAttachmentAsync(
+        AttachmentMetadata attachment,
+        Stream content,
+        CancellationToken ct = default)
+    {
+        ArgumentNullException.ThrowIfNull(attachment);
+
+        using var body = new StreamContent(content);
+        body.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(attachment.ContentType);
+        body.Headers.ContentLength = attachment.SizeBytes;
+
+        using var request = new HttpRequestMessage(HttpMethod.Put, SyncRoutes.AttachmentFor(attachment.Id)) { Content = body };
+        request.Headers.Add(SyncRoutes.AttachmentSha256Header, attachment.Sha256);
+
+        using var response = await http.SendAsync(request, ct);
+
+        if (response.IsSuccessStatusCode) return (response.StatusCode, null);
+
+        var problem = await SyncProblem.ReadAsync(response, ct);
+        return (response.StatusCode, problem.Detail);
+    }
+
     public async Task AcknowledgeAsync(Guid id, CancellationToken ct = default)
         => (await http.PostAsync($"{InboxRoute}/{id}/ack", null, ct)).EnsureSuccessStatusCode();
 
diff --git a/src/App/Backlog.Mobile.UI/Services/IAttachmentPicker.cs b/src/App/Backlog.Mobile.UI/Services/IAttachmentPicker.cs
new file mode 100644
index 000000000..8ba6e7111
--- /dev/null
+++ b/src/App/Backlog.Mobile.UI/Services/IAttachmentPicker.cs
@@ -0,0 +1,54 @@
+namespace Backlog.Mobile.UI.Services;
+
+/// <summary>
+/// Where a talk note's photos and files come from. Two implementations, one per
+/// host, the way <see cref="ISpeechTranscriber"/> has two: the MAUI head asks
+/// Android's camera and pickers, and the browser harness renders
+/// <c>&lt;InputFile&gt;</c> elements Playwright can hand a fixture to.
+/// <para>
+/// Nothing here throws for the ordinary outcomes. A person who backs out of a
+/// picker gets <see cref="AttachmentPick.None"/>, and a camera the platform
+/// refused gets <see cref="AttachmentPick.Failed"/> with a sentence for the
+/// screen.
+/// </para>
+/// </summary>
+public interface IAttachmentPicker
+{
+    /// <summary>Whether this device has a camera the app may open. The button
+    /// is left out when it does not.</summary>
+    ValueTask<bool> CanTakePhotoAsync(CancellationToken cancellationToken = default);
+
+    /// <summary>Opens the camera; one photo, or none if the person backed out.</summary>
+    Task<AttachmentPick> TakePhotoAsync(CancellationToken cancellationToken = default);
+
+    /// <summary>Opens the picture picker; as many as the person chose.</summary>
+    Task<AttachmentPick> PickPicturesAsync(CancellationToken cancellationToken = default);
+
+    /// <summary>Opens the file picker; as many as the person chose.</summary>
+    Task<AttachmentPick> PickFilesAsync(CancellationToken cancellationToken = default);
+}
+
+/// <summary>
+/// One file the person chose. Read it before the next pick: a browser file is
+/// only readable until the input it came from changes again.
+/// </summary>
+/// <param name="ContentType">What the platform said it is — possibly nothing,
+/// or <c>application/octet-stream</c>; the extension decides then.</param>
+public sealed record PickedFile(
+    string Name,
+    string? ContentType,
+    long SizeBytes,
+    Func<CancellationToken, Task<Stream>> OpenReadAsync);
+
+/// <summary>What one pick produced: the files, or why there are none.</summary>
+public sealed record AttachmentPick(IReadOnlyList<PickedFile> Files, string? Error = null)
+{
+    /// <summary>The person backed out, or chose nothing.</summary>
+    public static AttachmentPick None { get; } = new([]);
+
+    public static AttachmentPick Of(IReadOnlyList<PickedFile> files) => new(files);
+
+    public static AttachmentPick Failed(string error) => new([], error);
+
+    public bool IsError => Error is not null;
+}
diff --git a/src/App/Backlog.Mobile.UI/Services/MobileShellServiceCollectionExtensions.cs b/src/App/Backlog.Mobile.UI/Services/MobileShellServiceCollectionExtensions.cs
index e744b5809..efc20d675 100644
--- a/src/App/Backlog.Mobile.UI/Services/MobileShellServiceCollectionExtensions.cs
+++ b/src/App/Backlog.Mobile.UI/Services/MobileShellServiceCollectionExtensions.cs
@@ -1,4 +1,5 @@
 using Backlog.Mobile.UI.Outbox;
+using Backlog.Mobile.UI.TalkNotes;
 using Backlog.Mobile.UI.Tasks;
 
 using Microsoft.Extensions.DependencyInjection;
@@ -20,6 +21,7 @@ public static IServiceCollection AddMobileShell(this IServiceCollection services
     {
         services.TryAddSingleton(TimeProvider.System);
         services.AddScoped<CaptureDraft>();
+        services.AddScoped<TalkNoteDraft>();
         services.AddScoped<SyncStatusTracker>();
 
         // One instance behind both names: the Inbox records against the tracker,
@@ -51,6 +53,12 @@ public static IServiceCollection AddDeviceOutbox(this IServiceCollection service
         services.AddSingleton<IOutboxKind, CaptureOutboxKind>();
         services.AddSingleton<IOutboxKind, TaskOutboxKind>();
 
+        // A talk note's files wait beside the database until the capture naming
+        // them has arrived; the outbox row holds only where they are.
+        services.AddSingleton(_ => new TalkNoteFiles(Path.Combine(Path.GetDirectoryName(Path.GetFullPath(databasePath))!, "talk-notes")));
+        services.AddSingleton<IOutboxKind, TalkNoteOutboxKind>();
+        services.AddSingleton<TalkNoteComposer>();
+
         // The Tasks tab's fold of the task feed, in the same file: a projection
         // plus the outbox's task kind, never a second task store.
         services.AddSingleton<ITaskViewStore>(_ => new SqliteTaskViewStore(databasePath));
diff --git a/src/App/Backlog.Mobile.UI/Services/WebAttachmentPicker.cs b/src/App/Backlog.Mobile.UI/Services/WebAttachmentPicker.cs
new file mode 100644
index 000000000..7932c923e
--- /dev/null
+++ b/src/App/Backlog.Mobile.UI/Services/WebAttachmentPicker.cs
@@ -0,0 +1,161 @@
+using Backlog.Modules.Sync.Abstractions;
+
+using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Forms;
+using Microsoft.JSInterop;
+
+namespace Backlog.Mobile.UI.Services;
+
+/// <summary>
+/// <see cref="IAttachmentPicker"/> over <c>&lt;InputFile&gt;</c>, for the mobile
+/// web harness.
+/// <para>
+/// A browser only opens its file dialog for an input element in the page, so
+/// the page renders <see cref="Components.WebAttachmentInputs"/> — three hidden
+/// inputs, one per button — and they report to this service. A pick clicks the
+/// matching input from script and waits for its change, or for the browser's
+/// <c>cancel</c> when the person backs out. Playwright skips the dialog and
+/// sets files on the input directly, which lands in the same place.
+/// </para>
+/// <para>
+/// Registered by the harness only. The Android System WebView's file input
+/// works, but the MAUI head has the platform pickers and a real camera, which a
+/// web view's <c>capture</c> attribute only approximates.
+/// </para>
+/// </summary>
+public sealed class WebAttachmentPicker(IJSRuntime js) : IAttachmentPicker, IAsyncDisposable
+{
+    private const string ModulePath = "./_content/Backlog.Mobile.UI/attachments.js";
+
+    private readonly Dictionary<WebAttachmentSource, ElementReference> _inputs = [];
+
+    private IJSObjectReference? _module;
+    private DotNetObjectReference<WebAttachmentPicker>? _self;
+    private TaskCompletionSource<AttachmentPick>? _pending;
+
+    /// <summary>The accept list of the files input: the allowlist's extensions,
+    /// so the dialog offers what the service will take.</summary>
+    public const string FilesAccept = "image/*,.pdf,.txt,.md,.csv,.docx,.xlsx,.pptx";
+
+    /// <summary>A browser always has a file input with a camera hint; a desktop
+    /// browser just opens the dialog.</summary>
+    public ValueTask<bool> CanTakePhotoAsync(CancellationToken cancellationToken = default) => ValueTask.FromResult(true);
+
+    public Task<AttachmentPick> TakePhotoAsync(CancellationToken cancellationToken = default) =>
+        OpenAsync(WebAttachmentSource.Camera, cancellationToken);
+
+    public Task<AttachmentPick> PickPicturesAsync(CancellationToken cancellationToken = default) =>
+        OpenAsync(WebAttachmentSource.Pictures, cancellationToken);
+
+    public Task<AttachmentPick> PickFilesAsync(CancellationToken cancellationToken = default) =>
+        OpenAsync(WebAttachmentSource.Files, cancellationToken);
+
+    /// <summary>An input rendered: it is what <paramref name="source"/> opens.</summary>
+    public void Register(WebAttachmentSource source, ElementReference input) => _inputs[source] = input;
+
+    /// <summary>
+    /// An input changed. Settles the pick that clicked it — or, when Playwright
+    /// set the files with no pick waiting, raises <see cref="Unrequested"/> so
+    /// the page takes them all the same.
+    /// </summary>
+    public void OnChanged(InputFileChangeEventArgs change)
+    {
+        ArgumentNullException.ThrowIfNull(change);
+
+        var files = change.GetMultipleFiles(maximumFileCount: 100)
+            .Select(file => new PickedFile(
+                file.Name,
+                file.ContentType,
+                file.Size,
+                // The cap plus one, so an over-cap file that slipped past the size
+                // check fails its copy rather than being silently truncated.
+                ct => Task.FromResult(file.OpenReadStream(SyncAttachmentLimits.DefaultMaxBytes + 1, ct))))
+            .ToList();
+
+        var pick = AttachmentPick.Of(files);
+
+        if (Interlocked.Exchange(ref _pending, null) is { } pending)
+        {
+            pending.TrySetResult(pick);
+        }
+        else
+        {
+            Unrequested?.Invoke(pick);
+        }
+    }
+
+    /// <summary>Files arrived with no pick waiting for them.</summary>
+    public event Func<AttachmentPick, Task>? Unrequested;
+
+    /// <summary>Called from <c>attachments.js</c> when the dialog closed with
+    /// nothing chosen.</summary>
+    [JSInvokable]
+    public Task OnCancelled()
+    {
+        Interlocked.Exchange(ref _pending, null)?.TrySetResult(AttachmentPick.None);
+        return Task.CompletedTask;
+    }
+
+    public async ValueTask DisposeAsync()
+    {
+        Interlocked.Exchange(ref _pending, null)?.TrySetResult(AttachmentPick.None);
+
+        if (_module is not null)
+        {
+            try
+            {
+                await _module.DisposeAsync();
+            }
+            catch (Exception ex) when (IsBrowserGone(ex))
+            {
+            }
+
+            _module = null;
+        }
+
+        _self?.Dispose();
+        _self = null;
+    }
+
+    private async Task<AttachmentPick> OpenAsync(WebAttachmentSource source, CancellationToken cancellationToken)
+    {
+        if (!_inputs.TryGetValue(source, out var input))
+        {
+            return AttachmentPick.Failed("Choosing files is not available on this screen.");
+        }
+
+        var pending = new TaskCompletionSource<AttachmentPick>(TaskCreationOptions.RunContinuationsAsynchronously);
+        Interlocked.Exchange(ref _pending, pending)?.TrySetResult(AttachmentPick.None);
+
+        try
+        {
+            _module ??= await js.InvokeAsync<IJSObjectReference>("import", cancellationToken, ModulePath);
+            _self ??= DotNetObjectReference.Create(this);
+            await _module.InvokeVoidAsync("open", cancellationToken, input, _self);
+        }
+        catch (JSException ex)
+        {
+            Interlocked.Exchange(ref _pending, null);
+            return AttachmentPick.Failed($"The file dialog did not open: {ex.Message}");
+        }
+        catch (Exception ex) when (IsBrowserGone(ex))
+        {
+            Interlocked.Exchange(ref _pending, null);
+            return AttachmentPick.None;
+        }
+
+        await using var registration = cancellationToken.Register(() => pending.TrySetResult(AttachmentPick.None));
+        return await pending.Task;
+    }
+
+    private static bool IsBrowserGone(Exception ex) =>
+        ex is JSDisconnectedException or InvalidOperationException or OperationCanceledException or ObjectDisposedException;
+}
+
+/// <summary>Which of the three inputs a pick opens.</summary>
+public enum WebAttachmentSource
+{
+    Camera,
+    Pictures,
+    Files
+}
diff --git a/src/App/Backlog.Mobile.UI/TalkNotes/AttachmentRules.cs b/src/App/Backlog.Mobile.UI/TalkNotes/AttachmentRules.cs
new file mode 100644
index 000000000..5ff909d38
--- /dev/null
+++ b/src/App/Backlog.Mobile.UI/TalkNotes/AttachmentRules.cs
@@ -0,0 +1,112 @@
+using System.Globalization;
+
+using Backlog.Modules.Sync.Abstractions;
+
+namespace Backlog.Mobile.UI.TalkNotes;
+
+/// <summary>
+/// What the phone checks about a file before it will queue it: the cap and the
+/// allowlist of local ADR 0014, the same defaults the sync service enforces. A
+/// file the service would answer 413 or 415 to is refused on its tile, with the
+/// reason, rather than parked in the outbox an hour later with an error code.
+/// </summary>
+public static class AttachmentRules
+{
+    /// <summary>The most files one note carries — the service's own bound on a
+    /// capture's attachment list.</summary>
+    public const int MaximumPerNote = 20;
+
+    /// <summary>What a file with no declared type, or the browser's shrug
+    /// <c>application/octet-stream</c>, is taken to be by its extension. Only the
+    /// allowlisted types, so anything else stays unknown and is refused.</summary>
+    private static readonly Dictionary<string, string> ByExtension = new(StringComparer.OrdinalIgnoreCase)
+    {
+        [".jpg"] = "image/jpeg",
+        [".jpeg"] = "image/jpeg",
+        [".png"] = "image/png",
+        [".heic"] = "image/heic",
+        [".heif"] = "image/heif",
+        [".webp"] = "image/webp",
+        [".gif"] = "image/gif",
+        [".pdf"] = "application/pdf",
+        [".txt"] = "text/plain",
+        [".md"] = "text/markdown",
+        [".markdown"] = "text/markdown",
+        [".csv"] = "text/csv",
+        [".docx"] = "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        [".xlsx"] = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        [".pptx"] = "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    };
+
+    private static readonly Dictionary<string, string> Labels = new(StringComparer.OrdinalIgnoreCase)
+    {
+        ["image/jpeg"] = "JPEG image",
+        ["image/png"] = "PNG image",
+        ["image/heic"] = "HEIC image",
+        ["image/heif"] = "HEIF image",
+        ["image/webp"] = "WebP image",
+        ["image/gif"] = "GIF image",
+        ["application/pdf"] = "PDF",
+        ["text/plain"] = "Text",
+        ["text/markdown"] = "Markdown",
+        ["text/csv"] = "CSV",
+        ["application/vnd.openxmlformats-officedocument.wordprocessingml.document"] = "Word document",
+        ["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"] = "Excel workbook",
+        ["application/vnd.openxmlformats-officedocument.presentationml.presentation"] = "PowerPoint deck",
+    };
+
+    /// <summary>The media type a file goes up as: the one it declared, unless it
+    /// declared nothing useful, in which case the one its extension names.</summary>
+    public static string ContentTypeOf(string name, string? declared)
+    {
+        var mediaType = declared?.Split(';')[0].Trim() ?? string.Empty;
+
+        if (mediaType.Length > 0 && !mediaType.Equals("application/octet-stream", StringComparison.OrdinalIgnoreCase))
+        {
+            return mediaType.ToLowerInvariant();
+        }
+
+        return ByExtension.TryGetValue(Path.GetExtension(name), out var byExtension)
+            ? byExtension
+            : "application/octet-stream";
+    }
+
+    /// <summary>Why the service would not take this file, in words for its
+    /// tile — or null when it would.</summary>
+    public static string? RefusalOf(string name, string contentType, long sizeBytes)
+    {
+        if (!SyncAttachmentLimits.AllowsByDefault(contentType))
+        {
+            var extension = Path.GetExtension(name);
+            var what = extension.Length > 0 ? extension.ToLowerInvariant() : contentType;
+
+            return $"Not a type cloud sync takes ({what}). Pictures, PDF, text and Office files only.";
+        }
+
+        if (sizeBytes > SyncAttachmentLimits.DefaultMaxBytes)
+        {
+            return $"Too large: {DescribeSize(sizeBytes)}, and the limit is {DescribeSize(SyncAttachmentLimits.DefaultMaxBytes)}.";
+        }
+
+        return null;
+    }
+
+    /// <summary>The reason on a tile past <see cref="MaximumPerNote"/>.</summary>
+    public static string TooMany => $"A note takes at most {MaximumPerNote} files.";
+
+    /// <summary>A picture, for the "Photo · date" title and the downscaler.</summary>
+    public static bool IsPicture(string contentType) =>
+        contentType.StartsWith("image/", StringComparison.OrdinalIgnoreCase);
+
+    /// <summary>The type as a person reads it: "PDF", "JPEG image".</summary>
+    public static string Describe(string contentType) =>
+        Labels.TryGetValue(contentType, out var label) ? label : contentType;
+
+    /// <summary>"340 KB", "4.2 MB" — binary units, one decimal from a megabyte up.</summary>
+    public static string DescribeSize(long bytes) => bytes switch
+    {
+        < 1024 => $"{bytes} B",
+        < 1024 * 1024 => string.Create(CultureInfo.InvariantCulture, $"{Math.Round(bytes / 1024.0):0} KB"),
+        _ => string.Create(CultureInfo.InvariantCulture, $"{bytes / (1024.0 * 1024):0.#} MB"),
+    };
+}
diff --git a/src/App/Backlog.Mobile.UI/TalkNotes/ExifOrientation.cs b/src/App/Backlog.Mobile.UI/TalkNotes/ExifOrientation.cs
new file mode 100644
index 000000000..a18e95417
--- /dev/null
+++ b/src/App/Backlog.Mobile.UI/TalkNotes/ExifOrientation.cs
@@ -0,0 +1,132 @@
+using System.Buffers.Binary;
+
+namespace Backlog.Mobile.UI.TalkNotes;
+
+/// <summary>
+/// The one EXIF field a downscaled picture keeps: which way up it is.
+/// <para>
+/// A phone camera stores the pixels as the sensor read them and says in EXIF
+/// how to turn them. Drop that and a portrait slide photo arrives on its side;
+/// keep the rest and the GPS position, the device serial and the capture time
+/// go with it. So the re-encoded JPEG gets a minimal APP1 segment holding the
+/// orientation tag and nothing else.
+/// </para>
+/// </summary>
+public static class ExifOrientation
+{
+    /// <summary>The TIFF tag number of Orientation.</summary>
+    public const ushort Tag = 0x0112;
+
+    /// <summary>Upright, which is also what no tag at all means.</summary>
+    public const ushort Upright = 1;
+
+    private static ReadOnlySpan<byte> ExifHeader => "Exif\0\0"u8;
+
+    /// <summary>
+    /// <paramref name="jpeg"/> with an APP1 segment carrying only
+    /// <paramref name="orientation"/> — after the JFIF APP0 when there is one,
+    /// otherwise straight after the start-of-image marker. An upright picture
+    /// needs no tag and is returned as it is.
+    /// </summary>
+    public static byte[] Stamp(byte[] jpeg, ushort orientation)
+    {
+        ArgumentNullException.ThrowIfNull(jpeg);
+        if (orientation is Upright or 0 or > 8) return jpeg;
+        if (jpeg.Length < 4 || jpeg[0] != 0xFF || jpeg[1] != 0xD8) return jpeg;
+
+        var insertAt = 2;
+        if (jpeg.Length >= 6 && jpeg[2] == 0xFF && jpeg[3] == 0xE0)
+        {
+            insertAt = 4 + BinaryPrimitives.ReadUInt16BigEndian(jpeg.AsSpan(4, 2));
+        }
+
+        var segment = Segment(orientation);
+        var stamped = new byte[jpeg.Length + segment.Length];
+        jpeg.AsSpan(0, insertAt).CopyTo(stamped);
+        segment.CopyTo(stamped.AsSpan(insertAt));
+        jpeg.AsSpan(insertAt).CopyTo(stamped.AsSpan(insertAt + segment.Length));
+
+        return stamped;
+    }
+
+    /// <summary>
+    /// The IFD0 tags of the first EXIF APP1 segment in <paramref name="jpeg"/>,
+    /// each with its SHORT value — which is all <see cref="Stamp"/> writes, and
+    /// what a test needs to prove nothing else survived. Empty when there is none.
+    /// </summary>
+    public static IReadOnlyDictionary<ushort, ushort> ReadTags(ReadOnlySpan<byte> jpeg)
+    {
+        var tags = new Dictionary<ushort, ushort>();
+        if (jpeg.Length < 4 || jpeg[0] != 0xFF || jpeg[1] != 0xD8) return tags;
+
+        var position = 2;
+        while (position + 4 <= jpeg.Length && jpeg[position] == 0xFF)
+        {
+            var marker = jpeg[position + 1];
+            if (marker is 0xDA or 0xD9) break;
+
+            var length = BinaryPrimitives.ReadUInt16BigEndian(jpeg.Slice(position + 2, 2));
+            if (position + 2 + length > jpeg.Length) break;
+
+            var body = jpeg.Slice(position + 4, length - 2);
+            if (marker == 0xE1 && body.StartsWith(ExifHeader))
+            {
+                ReadIfd0(body[ExifHeader.Length..], tags);
+                return tags;
+            }
+
+            position += 2 + length;
+        }
+
+        return tags;
+    }
+
+    private static byte[] Segment(ushort orientation)
+    {
+        // FF E1, length, "Exif\0\0", a big-endian TIFF header, one IFD with one
+        // SHORT entry, and no next IFD.
+        const int tiffLength = 8 + 2 + 12 + 4;
+        var segment = new byte[4 + 6 + tiffLength];
+        var span = segment.AsSpan();
+
+        span[0] = 0xFF;
+        span[1] = 0xE1;
+        BinaryPrimitives.WriteUInt16BigEndian(span[2..], (ushort)(segment.Length - 2));
+        ExifHeader.CopyTo(span[4..]);
+
+        var tiff = span[10..];
+        tiff[0] = (byte)'M';
+        tiff[1] = (byte)'M';
+        BinaryPrimitives.WriteUInt16BigEndian(tiff[2..], 42);
+        BinaryPrimitives.WriteUInt32BigEndian(tiff[4..], 8);
+        BinaryPrimitives.WriteUInt16BigEndian(tiff[8..], 1);
+        BinaryPrimitives.WriteUInt16BigEndian(tiff[10..], Tag);
+        BinaryPrimitives.WriteUInt16BigEndian(tiff[12..], 3);
+        BinaryPrimitives.WriteUInt32BigEndian(tiff[14..], 1);
+        BinaryPrimitives.WriteUInt16BigEndian(tiff[18..], orientation);
+        BinaryPrimitives.WriteUInt32BigEndian(tiff[22..], 0);
+
+        return segment;
+    }
+
+    private static void ReadIfd0(ReadOnlySpan<byte> tiff, Dictionary<ushort, ushort> tags)
+    {
+        if (tiff.Length < 8) return;
+
+        var bigEndian = tiff[0] == (byte)'M';
+        ushort U16(ReadOnlySpan<byte> at) => bigEndian ? BinaryPrimitives.ReadUInt16BigEndian(at) : BinaryPrimitives.ReadUInt16LittleEndian(at);
+        uint U32(ReadOnlySpan<byte> at) => bigEndian ? BinaryPrimitives.ReadUInt32BigEndian(at) : BinaryPrimitives.ReadUInt32LittleEndian(at);
+
+        var ifd = (int)U32(tiff[4..]);
+        if (ifd + 2 > tiff.Length) return;
+
+        var count = U16(tiff[ifd..]);
+        for (var index = 0; index < count; index++)
+        {
+            var entry = ifd + 2 + (index * 12);
+            if (entry + 12 > tiff.Length) return;
+
+            tags[U16(tiff[entry..])] = U16(tiff[(entry + 8)..]);
+        }
+    }
+}
diff --git a/src/App/Backlog.Mobile.UI/TalkNotes/PictureDownscaler.cs b/src/App/Backlog.Mobile.UI/TalkNotes/PictureDownscaler.cs
new file mode 100644
index 000000000..aa6a7fbbe
--- /dev/null
+++ b/src/App/Backlog.Mobile.UI/TalkNotes/PictureDownscaler.cs
@@ -0,0 +1,101 @@
+using SkiaSharp;
+
+namespace Backlog.Mobile.UI.TalkNotes;
+
+/// <summary>
+/// Makes a slide photo small enough to send from a conference hall: the longest
+/// edge at most <see cref="LongestEdge"/> pixels, re-encoded as JPEG, every EXIF
+/// field dropped but the orientation.
+/// <para>
+/// A twelve-megapixel photo is four or five megabytes and says nothing more
+/// about a slide than a 1600-pixel one does; the uploads it would cost are the
+/// ones a hall's shared Wi-Fi drops. The person can keep a note's pictures as
+/// taken with its "send originals" switch, which skips this entirely.
+/// </para>
+/// </summary>
+public static class PictureDownscaler
+{
+    /// <summary>The longest edge a downscaled picture has.</summary>
+    public const int LongestEdge = 1600;
+
+    /// <summary>The JPEG quality it is written at.</summary>
+    public const int JpegQuality = 85;
+
+    /// <summary>The type every downscaled picture has.</summary>
+    public const string ContentType = "image/jpeg";
+
+    private static readonly string[] Downscalable = ["image/jpeg", "image/png", "image/webp", "image/heic", "image/heif"];
+
+    /// <summary>Whether a picture of this type is downscaled. A GIF is not: it may
+    /// be animated, and a JPEG of its first frame is not the same picture.</summary>
+    public static bool Handles(string contentType) =>
+        Downscalable.Contains(contentType.Split(';')[0].Trim(), StringComparer.OrdinalIgnoreCase);
+
+    /// <summary>
+    /// The downscaled JPEG, or null when the bytes are not a picture this device
+    /// can decode — a HEIC on a platform without the codec, say — in which case
+    /// the caller sends the original.
+    /// </summary>
+    public static byte[]? Downscale(Stream source)
+    {
+        ArgumentNullException.ThrowIfNull(source);
+
+        using var data = SKData.Create(source);
+        if (data is null) return null;
+
+        using var codec = SKCodec.Create(data);
+        if (codec is null) return null;
+
+        var (width, height) = (codec.Info.Width, codec.Info.Height);
+        if (width <= 0 || height <= 0) return null;
+
+        var scale = Math.Min(1.0, LongestEdge / (double)Math.Max(width, height));
+        var target = new SKSizeI(
+            Math.Max(1, (int)Math.Round(width * scale)),
+            Math.Max(1, (int)Math.Round(height * scale)));
+
+        using var decoded = Decode(codec, target);
+        if (decoded is null) return null;
+
+        // Onto white, because a JPEG has no alpha: a transparent PNG screenshot
+        // would otherwise come out with a black background.
+        using var surface = SKSurface.Create(new SKImageInfo(target.Width, target.Height, SKColorType.Rgba8888, SKAlphaType.Premul));
+        var canvas = surface.Canvas;
+        canvas.Clear(SKColors.White);
+
+        using (var image = SKImage.FromBitmap(decoded))
+        {
+            canvas.DrawImage(image, SKRect.Create(target.Width, target.Height), new SKSamplingOptions(SKCubicResampler.Mitchell));
+        }
+
+        using var snapshot = surface.Snapshot();
+        using var jpeg = snapshot.Encode(SKEncodedImageFormat.Jpeg, JpegQuality);
+        if (jpeg is null) return null;
+
+        // The pixels stay as the sensor read them, so the tag that says how to
+        // turn them has to travel with them.
+        return ExifOrientation.Stamp(jpeg.ToArray(), (ushort)codec.EncodedOrigin);
+    }
+
+    /// <summary>
+    /// Decodes at the smallest size the codec can produce that is still at least
+    /// <paramref name="target"/> — a JPEG decoder can skip most of the work of a
+    /// twelve-megapixel photo — and at full size otherwise.
+    /// </summary>
+    private static SKBitmap? Decode(SKCodec codec, SKSizeI target)
+    {
+        var info = codec.Info;
+        var scaled = codec.GetScaledDimensions(target.Width / (float)info.Width);
+
+        var size = scaled.Width >= target.Width && scaled.Height >= target.Height ? scaled : info.Size;
+        var decodeInfo = new SKImageInfo(size.Width, size.Height, SKColorType.Rgba8888, SKAlphaType.Premul);
+
+        var bitmap = new SKBitmap(decodeInfo);
+        var result = codec.GetPixels(decodeInfo, bitmap.GetPixels());
+
+        if (result is SKCodecResult.Success or SKCodecResult.IncompleteInput) return bitmap;
+
+        bitmap.Dispose();
+        return null;
+    }
+}
diff --git a/src/App/Backlog.Mobile.UI/TalkNotes/TalkNoteComposer.cs b/src/App/Backlog.Mobile.UI/TalkNotes/TalkNoteComposer.cs
new file mode 100644
index 000000000..412c89144
--- /dev/null
+++ b/src/App/Backlog.Mobile.UI/TalkNotes/TalkNoteComposer.cs
@@ -0,0 +1,88 @@
+using System.Security.Cryptography;
+
+using Backlog.Mobile.UI.Outbox;
+using Backlog.Modules.Sync.Abstractions.DataTransferObjects;
+
+namespace Backlog.Mobile.UI.TalkNotes;
+
+/// <summary>
+/// Turns the draft into the one outbox entry a saved talk note is: each
+/// picture downscaled unless the note keeps originals, each file moved from the
+/// strip's folder to the outbox's, the metadata the service checks — size and
+/// SHA-256 of the bytes that will actually go — and a title when the note had
+/// none.
+/// </summary>
+public sealed class TalkNoteComposer(TalkNoteFiles files, DeviceOutbox outbox, TimeProvider clock)
+{
+    /// <summary>Queues the note and returns its entry id, or null when the draft
+    /// cannot be saved as it stands.</summary>
+    public async Task<Guid?> SaveAsync(TalkNoteDraft draft, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(draft);
+        if (!draft.CanSave) return null;
+
+        Directory.CreateDirectory(files.OutboxFolder);
+
+        var attachments = new List<AttachmentMetadata>();
+        foreach (var picked in draft.Accepted)
+        {
+            attachments.Add(await PrepareAsync(picked, draft.SendOriginals, cancellationToken));
+        }
+
+        var today = DateOnly.FromDateTime(clock.GetLocalNow().DateTime);
+        var title = TalkNoteTitle.For(draft.Title, draft.Body, [.. attachments.Select(a => (a.Name, a.ContentType))], today);
+        var body = draft.Body.Trim();
+        var tags = draft.TagList;
+
+        var id = Guid.CreateVersion7();
+        var capture = new CaptureRequest(
+            title,
+            CaptureOutboxKind.Source,
+            id,
+            body.Length > 0 ? body : null,
+            tags.Count > 0 ? tags : null,
+            draft.Person,
+            attachments.Count > 0 ? attachments : null);
+
+        await outbox.EnqueueAsync(TalkNoteOutboxKind.Token, id, TalkNoteOutboxKind.Write(new TalkNotePayload(capture, [])), cancellationToken);
+
+        draft.LastSaved = id;
+        draft.Clear();
+
+        return id;
+    }
+
+    private async Task<AttachmentMetadata> PrepareAsync(DraftAttachment picked, bool sendOriginals, CancellationToken cancellationToken)
+    {
+        var target = files.OutboxPath(picked.Id);
+        var name = picked.Name;
+        var contentType = picked.ContentType;
+
+        byte[]? downscaled = null;
+        if (!sendOriginals && PictureDownscaler.Handles(contentType))
+        {
+            await using var source = File.OpenRead(picked.StagedPath);
+            downscaled = PictureDownscaler.Downscale(source);
+        }
+
+        if (downscaled is not null)
+        {
+            await File.WriteAllBytesAsync(target, downscaled, cancellationToken);
+            TalkNoteFiles.Discard(picked);
+
+            name = Path.ChangeExtension(name, ".jpg");
+            contentType = PictureDownscaler.ContentType;
+        }
+        else
+        {
+            // As taken: a file, a GIF, a picture kept original, or one this
+            // device cannot decode.
+            File.Move(picked.StagedPath, target, overwrite: true);
+        }
+
+        await using var stream = File.OpenRead(target);
+        var sha256 = Convert.ToHexStringLower(await SHA256.HashDataAsync(stream, cancellationToken));
+
+        return new AttachmentMetadata(picked.Id, name, contentType, stream.Length, sha256);
+    }
+}
diff --git a/src/App/Backlog.Mobile.UI/TalkNotes/TalkNoteDraft.cs b/src/App/Backlog.Mobile.UI/TalkNotes/TalkNoteDraft.cs
new file mode 100644
index 000000000..8b29cd2ab
--- /dev/null
+++ b/src/App/Backlog.Mobile.UI/TalkNotes/TalkNoteDraft.cs
@@ -0,0 +1,96 @@
+namespace Backlog.Mobile.UI.TalkNotes;
+
+/// <summary>
+/// The talk note being written, held outside the page.
+/// <para>
+/// The Router remounts a page on every navigation, so a note kept in the Note
+/// page's own fields would be gone after a glance at the Inbox — and a talk does
+/// not pause while someone looks something up. Scoped, like the Inbox's
+/// <see cref="Services.CaptureDraft"/>: it lives as long as the app's circuit or
+/// web view, which on a phone includes time spent in the background. The picked
+/// files themselves are staged on disk by <see cref="TalkNoteFiles"/>; this holds
+/// where they are.
+/// </para>
+/// </summary>
+public sealed class TalkNoteDraft
+{
+    public string Title { get; set; } = string.Empty;
+
+    /// <summary>Markdown. Dictation appends here.</summary>
+    public string Body { get; set; } = string.Empty;
+
+    /// <summary>The speaker as typed — <c>@name</c>, the @ optional.</summary>
+    public string Speaker { get; set; } = string.Empty;
+
+    /// <summary>Tags as typed, separated by commas or spaces, # optional.</summary>
+    public string Tags { get; set; } = string.Empty;
+
+    /// <summary>Keep this note's pictures as taken rather than downscaled.</summary>
+    public bool SendOriginals { get; set; }
+
+    public List<DraftAttachment> Attachments { get; } = [];
+
+    /// <summary>The outbox entry of the note saved last, which the page keeps
+    /// reporting on — waiting, uploading, synced — after the fields clear.</summary>
+    public Guid? LastSaved { get; set; }
+
+    /// <summary>The speaker as the capture carries it: one name without its @,
+    /// or null.</summary>
+    public string? Person => Speaker.Trim().TrimStart('@') is { Length: > 0 } name ? name : null;
+
+    /// <summary>Why the speaker cannot be sent, or null. The desktop reads a
+    /// person back as one <c>@name</c> token, so it is one word.</summary>
+    public string? SpeakerProblem => Person is { } name && name.Any(char.IsWhiteSpace)
+        ? "A speaker is one name with no spaces, like @ada."
+        : null;
+
+    /// <summary>The tags, bare and each once, in the order typed.</summary>
+    public IReadOnlyList<string> TagList =>
+        [.. Tags.Split([',', ' ', ';', '\t', '\n'], StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
+            .Select(tag => tag.TrimStart('#'))
+            .Where(tag => tag.Length > 0)
+            .Distinct(StringComparer.OrdinalIgnoreCase)];
+
+    /// <summary>The files that will go, in the order they were picked.</summary>
+    public IReadOnlyList<DraftAttachment> Accepted => [.. Attachments.Where(attachment => attachment.Refusal is null)];
+
+    public bool HasRefused => Attachments.Any(attachment => attachment.Refusal is not null);
+
+    /// <summary>Anything worth saving.</summary>
+    public bool HasContent =>
+        Title.Trim().Length > 0 || Body.Trim().Length > 0 || Accepted.Count > 0;
+
+    /// <summary>Saving is withheld while a refused file is still on the strip:
+    /// the person thinks it is attached, and it would not go.</summary>
+    public bool CanSave => HasContent && !HasRefused && SpeakerProblem is null;
+
+    /// <summary>Empties the fields for the next note. <see cref="LastSaved"/>
+    /// stays; so does the originals switch, which is a habit rather than content.</summary>
+    public void Clear()
+    {
+        Title = string.Empty;
+        Body = string.Empty;
+        Speaker = string.Empty;
+        Tags = string.Empty;
+        Attachments.Clear();
+    }
+}
+
+/// <summary>
+/// One picked file on the strip.
+/// </summary>
+/// <param name="Id">The attachment's id — minted at the pick, sent as the
+/// upload's id and named by the capture.</param>
+/// <param name="StagedPath">Where its bytes wait on the device, or empty for a
+/// refused file, which is never copied.</param>
+/// <param name="Refusal">Why it will not be sent, or null.</param>
+public sealed record DraftAttachment(
+    Guid Id,
+    string Name,
+    string ContentType,
+    long SizeBytes,
+    string StagedPath,
+    string? Refusal = null)
+{
+    public bool IsPicture => AttachmentRules.IsPicture(ContentType);
+}
diff --git a/src/App/Backlog.Mobile.UI/TalkNotes/TalkNoteFiles.cs b/src/App/Backlog.Mobile.UI/TalkNotes/TalkNoteFiles.cs
new file mode 100644
index 000000000..6b3c52884
--- /dev/null
+++ b/src/App/Backlog.Mobile.UI/TalkNotes/TalkNoteFiles.cs
@@ -0,0 +1,92 @@
+using Backlog.Mobile.UI.Services;
+
+namespace Backlog.Mobile.UI.TalkNotes;
+
+/// <summary>
+/// Where a talk note's files wait on the device. The outbox row holds JSON, not
+/// bytes, so the bytes live beside the database in two folders: <c>drafts</c>
+/// for what is on the strip, and <c>outbox</c> for what has been saved and not
+/// yet delivered. A file leaves <c>outbox</c> when the capture naming it has
+/// reached the service — never before, since until then a retry may need it.
+/// </summary>
+public sealed class TalkNoteFiles
+{
+    public TalkNoteFiles(string root)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(root);
+
+        DraftsFolder = Path.Combine(root, "drafts");
+        OutboxFolder = Path.Combine(root, "outbox");
+    }
+
+    public string DraftsFolder { get; }
+
+    public string OutboxFolder { get; }
+
+    /// <summary>
+    /// A picked file on the strip. A file the service would refuse is described
+    /// and not copied — there is no reason to read 400 MB of video to say no to
+    /// it — and so is one past the per-note limit.
+    /// </summary>
+    public async Task<DraftAttachment> StageAsync(PickedFile file, int alreadyOnStrip, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(file);
+
+        var id = Guid.CreateVersion7();
+        var contentType = AttachmentRules.ContentTypeOf(file.Name, file.ContentType);
+        var refusal = alreadyOnStrip >= AttachmentRules.MaximumPerNote
+            ? AttachmentRules.TooMany
+            : AttachmentRules.RefusalOf(file.Name, contentType, file.SizeBytes);
+
+        if (refusal is not null)
+        {
+            return new DraftAttachment(id, file.Name, contentType, file.SizeBytes, string.Empty, refusal);
+        }
+
+        Directory.CreateDirectory(DraftsFolder);
+        var path = Path.Combine(DraftsFolder, id.ToString("N"));
+
+        long written;
+        await using (var source = await file.OpenReadAsync(cancellationToken))
+        await using (var target = File.Create(path))
+        {
+            await source.CopyToAsync(target, cancellationToken);
+            written = target.Length;
+        }
+
+        // The size the platform reported is a claim; the bytes on disk are what
+        // will be uploaded, so the cap is checked again against them.
+        return new DraftAttachment(id, file.Name, contentType, written, path, AttachmentRules.RefusalOf(file.Name, contentType, written));
+    }
+
+    /// <summary>Where a saved note's attachment waits for its upload.</summary>
+    public string OutboxPath(Guid attachmentId) => Path.Combine(OutboxFolder, attachmentId.ToString("N"));
+
+    /// <summary>Takes a file off the strip.</summary>
+    public static void Discard(DraftAttachment attachment)
+    {
+        ArgumentNullException.ThrowIfNull(attachment);
+        TryDelete(attachment.StagedPath);
+    }
+
+    /// <summary>The capture that named it has arrived; the file is the
+    /// service's now.</summary>
+    public void Release(Guid attachmentId) => TryDelete(OutboxPath(attachmentId));
+
+    private static void TryDelete(string path)
+    {
+        if (string.IsNullOrEmpty(path)) return;
+
+        try
+        {
+            File.Delete(path);
+        }
+        catch (IOException)
+        {
+            // Left for the next start; a stray file costs space, not correctness.
+        }
+        catch (UnauthorizedAccessException)
+        {
+        }
+    }
+}
diff --git a/src/App/Backlog.Mobile.UI/TalkNotes/TalkNoteTitle.cs b/src/App/Backlog.Mobile.UI/TalkNotes/TalkNoteTitle.cs
new file mode 100644
index 000000000..8f54f0082
--- /dev/null
+++ b/src/App/Backlog.Mobile.UI/TalkNotes/TalkNoteTitle.cs
@@ -0,0 +1,51 @@
+using System.Globalization;
+
+namespace Backlog.Mobile.UI.TalkNotes;
+
+/// <summary>
+/// The title a talk note arrives in the Inbox under. A note written with one
+/// thumb during a talk rarely has one, and a capture needs one — so it falls
+/// back, in order, to the first line of the body, then to "Photo · date" when a
+/// picture is attached, then to the first file's name.
+/// </summary>
+public static class TalkNoteTitle
+{
+    /// <summary>How much of a body line a title borrows. The rest stays in the
+    /// body, which still carries the whole line.</summary>
+    public const int MaximumFromBody = 200;
+
+    /// <summary>The title, or empty when the note has nothing to be called —
+    /// which is also a note with nothing in it, and so nothing to save.</summary>
+    public static string For(string? title, string? body, IReadOnlyList<(string Name, string ContentType)> attachments, DateOnly today)
+    {
+        ArgumentNullException.ThrowIfNull(attachments);
+
+        if (title?.Trim() is { Length: > 0 } typed) return typed;
+
+        if (FirstLine(body) is { } line) return line;
+
+        if (attachments.Any(attachment => AttachmentRules.IsPicture(attachment.ContentType)))
+        {
+            return string.Create(CultureInfo.InvariantCulture, $"Photo · {today:d MMM yyyy}");
+        }
+
+        return attachments.Count > 0 ? attachments[0].Name : string.Empty;
+    }
+
+    /// <summary>The body's first line with words on it, without the Markdown
+    /// that starts it — a heading's hashes, a list's bullet, a quote's bar.</summary>
+    private static string? FirstLine(string? body)
+    {
+        if (string.IsNullOrWhiteSpace(body)) return null;
+
+        foreach (var raw in body.Split('\n'))
+        {
+            var line = raw.Trim().TrimStart('#', '>', '-', '*', '+').Trim();
+            if (line.Length == 0) continue;
+
+            return line.Length <= MaximumFromBody ? line : $"{line[..(MaximumFromBody - 1)].TrimEnd()}…";
+        }
+
+        return null;
+    }
+}
diff --git a/src/App/Backlog.Mobile.UI/wwwroot/app.css b/src/App/Backlog.Mobile.UI/wwwroot/app.css
index 5dca3e734..98f79df7f 100644
--- a/src/App/Backlog.Mobile.UI/wwwroot/app.css
+++ b/src/App/Backlog.Mobile.UI/wwwroot/app.css
@@ -243,3 +243,27 @@ html, body { background-color: var(--color-background); color: var(--color-text-
 /* The status line carries the recognised words, which can run long. Wrapping is
    the point: truncating would hide the very thing the person asked to see. */
 .capture__status { overflow-wrap: anywhere; }
+
+/*
+  The talk note. One column at phone width: the fields stack, the mic sits beside
+  the body it fills, and the attach buttons wrap rather than shrink below a
+  thumb. Colours are the library's tokens, as above.
+*/
+.talk-note { display: grid; gap: .75rem; }
+
+.talk-note__body { display: flex; align-items: flex-start; gap: .5rem; }
+
+.talk-note__body .talk-note__field { flex: 1; min-width: 0; }
+
+.talk-note__mic { flex: 0 0 auto; margin-top: 1.5rem; }
+
+.talk-note__attach { display: flex; flex-wrap: wrap; gap: .5rem; }
+
+.talk-note__status {
+    display: flex;
+    align-items: center;
+    gap: .5rem;
+    margin: 0;
+    color: var(--color-text-secondary);
+    font-size: .85rem;
+}
diff --git a/src/App/Backlog.Mobile.UI/wwwroot/attachments.js b/src/App/Backlog.Mobile.UI/wwwroot/attachments.js
new file mode 100644
index 000000000..648c58c20
--- /dev/null
+++ b/src/App/Backlog.Mobile.UI/wwwroot/attachments.js
@@ -0,0 +1,14 @@
+// Opens one of the talk note's hidden file inputs and reports back when the
+// dialog closes with nothing chosen. A choice arrives through the input's own
+// change event, which Blazor's InputFile already listens to.
+export function open(input, picker) {
+    if (!input) {
+        throw new Error("The file input is not on the page.");
+    }
+
+    input.addEventListener("cancel", () => picker.invokeMethodAsync("OnCancelled"), { once: true });
+
+    // A fresh pick of the same file still counts as a change.
+    input.value = "";
+    input.click();
+}
diff --git a/src/App/Backlog.Mobile/MauiProgram.cs b/src/App/Backlog.Mobile/MauiProgram.cs
index f22259974..ec7811ba4 100644
--- a/src/App/Backlog.Mobile/MauiProgram.cs
+++ b/src/App/Backlog.Mobile/MauiProgram.cs
@@ -62,6 +62,10 @@ public static MauiApp CreateMauiApp()
 		// harness registers WebSpeechTranscriber against the same abstraction.
 		builder.Services.AddScoped<ISpeechTranscriber, AndroidSpeechTranscriber>();
 
+		// The camera and the platform pickers for a talk note's attachments. The
+		// browser harness registers WebAttachmentPicker, over <InputFile>, instead.
+		builder.Services.AddScoped<IAttachmentPicker, AndroidAttachmentPicker>();
+
 		// The Android share target, not the harness's query-string reader: an
 		// ACTION_SEND intent cannot reach a browser and a WebView URL is not how a
 		// share reaches a MAUI app, which is why there are two registrations rather
diff --git a/src/App/Backlog.Mobile/Platforms/Android/AndroidManifest.xml b/src/App/Backlog.Mobile/Platforms/Android/AndroidManifest.xml
index 519f83b80..ade373abd 100644
--- a/src/App/Backlog.Mobile/Platforms/Android/AndroidManifest.xml
+++ b/src/App/Backlog.Mobile/Platforms/Android/AndroidManifest.xml
@@ -6,6 +6,9 @@
     <!-- Speech capture on the Inbox screen. The runtime prompt is raised by
          Permissions.RequestAsync<Permissions.Microphone>; this only declares it. -->
     <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <!-- A talk note's slide photo. MediaPicker.CapturePhotoAsync raises the
+         runtime prompt; this only declares it. -->
+    <uses-permission android:name="android.permission.CAMERA" />
     <!-- Android 11 package visibility: without this the recognition service is
          invisible to us and SpeechRecognizer.IsRecognitionAvailable reports
          false on a device that has one installed. -->
@@ -13,5 +16,10 @@
         <intent>
             <action android:name="android.speech.RecognitionService" />
         </intent>
+        <!-- The camera app MediaPicker hands the capture to, which Android 11
+             package visibility would otherwise hide. -->
+        <intent>
+            <action android:name="android.media.action.IMAGE_CAPTURE" />
+        </intent>
     </queries>
 </manifest>
\ No newline at end of file
diff --git a/src/App/Backlog.Mobile/Services/AndroidAttachmentPicker.cs b/src/App/Backlog.Mobile/Services/AndroidAttachmentPicker.cs
new file mode 100644
index 000000000..982161a12
--- /dev/null
+++ b/src/App/Backlog.Mobile/Services/AndroidAttachmentPicker.cs
@@ -0,0 +1,87 @@
+using Backlog.Mobile.UI.Services;
+
+namespace Backlog.Mobile.Services;
+
+/// <summary>
+/// <see cref="IAttachmentPicker"/> over the platform's own camera and pickers,
+/// through MAUI Essentials: <see cref="MediaPicker"/> for the camera and the
+/// photo picker, <see cref="FilePicker"/> for everything else.
+/// </summary>
+/// <remarks>
+/// <para>
+/// The pickers are activities, started and answered on the main thread, so
+/// every call goes through <see cref="MainThread"/>. <c>CAMERA</c> is declared
+/// in <c>AndroidManifest.xml</c>; MAUI raises the runtime prompt when the camera
+/// is first asked for, and a refusal arrives as <see cref="PermissionException"/>.
+/// </para>
+/// <para>
+/// Essentials hands back a <see cref="FileResult"/> without a size. On Android
+/// a picked item is copied into the app's cache first, so its path is a real
+/// file whose length can be read; when it is not, the stream is measured.
+/// </para>
+/// </remarks>
+public sealed class AndroidAttachmentPicker : IAttachmentPicker
+{
+    private const string CameraDenied =
+        "Camera access was denied. Allow it in Android settings and try again.";
+
+    public ValueTask<bool> CanTakePhotoAsync(CancellationToken cancellationToken = default) =>
+        ValueTask.FromResult(MediaPicker.Default.IsCaptureSupported);
+
+    public Task<AttachmentPick> TakePhotoAsync(CancellationToken cancellationToken = default) =>
+        PickAsync(async () => MediaPicker.Default.CapturePhotoAsync() is { } photo ? [await photo] : []);
+
+    public Task<AttachmentPick> PickPicturesAsync(CancellationToken cancellationToken = default) =>
+        PickAsync(async () => await MediaPicker.Default.PickPhotosAsync(new MediaPickerOptions { Title = "Attach pictures", SelectionLimit = 0 }));
+
+    public Task<AttachmentPick> PickFilesAsync(CancellationToken cancellationToken = default) =>
+        PickAsync(async () => await FilePicker.Default.PickMultipleAsync(new PickOptions { PickerTitle = "Attach files" }));
+
+    private static async Task<AttachmentPick> PickAsync(Func<Task<IEnumerable<FileResult?>?>> pick)
+    {
+        try
+        {
+            var results = await MainThread.InvokeOnMainThreadAsync(pick);
+            if (results is null) return AttachmentPick.None;
+
+            var files = new List<PickedFile>();
+            foreach (var result in results)
+            {
+                if (result is null) continue;
+                files.Add(new PickedFile(result.FileName, result.ContentType, await SizeOfAsync(result), _ => result.OpenReadAsync()));
+            }
+
+            return AttachmentPick.Of(files);
+        }
+        catch (PermissionException)
+        {
+            return AttachmentPick.Failed(CameraDenied);
+        }
+        catch (FeatureNotSupportedException ex)
+        {
+            return AttachmentPick.Failed(ex.Message);
+        }
+        catch (OperationCanceledException)
+        {
+            return AttachmentPick.None;
+        }
+    }
+
+    private static async Task<long> SizeOfAsync(FileResult result)
+    {
+        if (!string.IsNullOrEmpty(result.FullPath) && File.Exists(result.FullPath))
+        {
+            return new FileInfo(result.FullPath).Length;
+        }
+
+        await using var stream = await result.OpenReadAsync();
+        if (stream.CanSeek) return stream.Length;
+
+        long length = 0;
+        var buffer = new byte[81920];
+        int read;
+        while ((read = await stream.ReadAsync(buffer)) > 0) length += read;
+
+        return length;
+    }
+}
diff --git a/src/Core/Backlog.UI.Components/Inputs/AttachmentStrip.razor b/src/Core/Backlog.UI.Components/Inputs/AttachmentStrip.razor
new file mode 100644
index 000000000..3d0b70b66
--- /dev/null
+++ b/src/Core/Backlog.UI.Components/Inputs/AttachmentStrip.razor
@@ -0,0 +1,79 @@
+@*
+    The files attached to something being written — a talk note's slide photos
+    and handouts. One tile per file with its name, type and size; a tile the
+    caller refused says why on the tile itself, so the person sees the reason
+    beside the file rather than in a message that has scrolled away.
+*@
+
+@if (Tiles.Count > 0)
+{
+    <ul class="@ClassValue" aria-label="@AriaLabel" data-testid="@TestId" @attributes="AdditionalAttributes">
+        @foreach (var tile in Tiles)
+        {
+            <li class="@TileClass(tile)" data-testid="attachment-tile" data-refused="@(tile.Refusal is null ? "false" : "true")" @key="tile.Key">
+                <span class="attachment-tile__glyph" aria-hidden="true">
+                    @if (tile.IsPicture)
+                    {
+                        <svg viewBox="0 0 16 16" width="16" height="16" fill="none" stroke="currentColor"
+                             stroke-width="1.4" stroke-linecap="round" stroke-linejoin="round" focusable="false">
+                            <rect x="1.75" y="2.75" width="12.5" height="10.5" rx="1.5" />
+                            <circle cx="5.5" cy="6.25" r="1.25" />
+                            <path d="M14.25 10.5 10.5 7l-6 6.25" />
+                        </svg>
+                    }
+                    else
+                    {
+                        <svg viewBox="0 0 16 16" width="16" height="16" fill="none" stroke="currentColor"
+                             stroke-width="1.4" stroke-linecap="round" stroke-linejoin="round" focusable="false">
+                            <path d="M9.25 1.75h-5a1.5 1.5 0 0 0-1.5 1.5v9.5a1.5 1.5 0 0 0 1.5 1.5h7.5a1.5 1.5 0 0 0 1.5-1.5v-7.25z" />
+                            <path d="M9.25 1.75V5.5h3.75" />
+                        </svg>
+                    }
+                </span>
+                <span class="attachment-tile__text">
+                    <span class="attachment-tile__name" title="@tile.Name" data-testid="attachment-tile-name">@tile.Name</span>
+                    <span class="attachment-tile__facts" data-testid="attachment-tile-facts">@tile.TypeLabel · @tile.SizeLabel</span>
+                    @if (tile.Refusal is not null)
+                    {
+                        <span class="attachment-tile__refusal" data-testid="attachment-tile-refusal">@tile.Refusal</span>
+                    }
+                </span>
+                @if (OnRemove.HasDelegate)
+                {
+                    <IconButton AriaLabel="@($"Remove {tile.Name}")" Title="@($"Remove {tile.Name}")"
+                                Disabled="Disabled" CssClass="attachment-tile__remove"
+                                OnClick="() => OnRemove.InvokeAsync(tile)" TestId="attachment-tile-remove">&#215;</IconButton>
+                }
+            </li>
+        }
+    </ul>
+}
+
+@code {
+    [Parameter]
+    public IReadOnlyList<AttachmentTile> Tiles { get; set; } = [];
+
+    /// <summary>Takes a tile off. Without a handler the strip only shows.</summary>
+    [Parameter]
+    public EventCallback<AttachmentTile> OnRemove { get; set; }
+
+    [Parameter]
+    public bool Disabled { get; set; }
+
+    [Parameter]
+    public string AriaLabel { get; set; } = "Attachments";
+
+    [Parameter]
+    public string? CssClass { get; set; }
+
+    [Parameter]
+    public string? TestId { get; set; }
+
+    [Parameter(CaptureUnmatchedValues = true)]
+    public IReadOnlyDictionary<string, object>? AdditionalAttributes { get; set; }
+
+    private string ClassValue => string.IsNullOrWhiteSpace(CssClass) ? "attachment-strip" : $"attachment-strip {CssClass}";
+
+    private static string TileClass(AttachmentTile tile) =>
+        tile.Refusal is null ? "attachment-tile" : "attachment-tile attachment-tile--refused";
+}
diff --git a/src/Core/Backlog.UI.Components/Inputs/AttachmentTile.cs b/src/Core/Backlog.UI.Components/Inputs/AttachmentTile.cs
new file mode 100644
index 000000000..a2fdecb2f
--- /dev/null
+++ b/src/Core/Backlog.UI.Components/Inputs/AttachmentTile.cs
@@ -0,0 +1,20 @@
+namespace Backlog.UI.Components.Inputs;
+
+/// <summary>
+/// One file on an <see cref="AttachmentStrip"/>, already described: the strip
+/// draws what it is handed and knows nothing of caps, allowlists or where the
+/// bytes are.
+/// </summary>
+/// <param name="Key">Stable across renders — the attachment's id.</param>
+/// <param name="TypeLabel">What it is, as a person reads it: "PDF", "JPEG image".</param>
+/// <param name="SizeLabel">How big: "2.4 MB".</param>
+/// <param name="IsPicture">Drawn with a picture glyph rather than a page.</param>
+/// <param name="Refusal">Why it will not be sent, or null. A refused tile says
+/// so in words, not only in colour.</param>
+public sealed record AttachmentTile(
+    string Key,
+    string Name,
+    string TypeLabel,
+    string SizeLabel,
+    bool IsPicture = false,
+    string? Refusal = null);
diff --git a/src/Core/Backlog.UI.Components/wwwroot/components.css b/src/Core/Backlog.UI.Components/wwwroot/components.css
index d3da494f3..10febb857 100644
--- a/src/Core/Backlog.UI.Components/wwwroot/components.css
+++ b/src/Core/Backlog.UI.Components/wwwroot/components.css
@@ -14508,3 +14508,72 @@ select.field__input {
     background: var(--color-text-secondary);
     box-shadow: 0 0 0 2px var(--color-info);
 }
+
+/* --- Attachment strip ---------------------------------------------------- */
+/*
+  The files on something being written, one tile per file. A tile is a full row
+  at phone width, so a long file name has the room to be read, and it keeps the
+  44px touch minimum of accessibility.md#target-sizes-and-text for its remove
+  control. A refused tile carries its reason in words; the red edge only repeats
+  what the sentence says (color-scheme.md: a colour is never the sole carrier).
+*/
+
+.attachment-strip {
+    display: grid;
+    gap: var(--spacing-xs);
+    margin: 0;
+    padding: 0;
+    list-style: none;
+}
+
+.attachment-tile {
+    display: flex;
+    align-items: center;
+    gap: var(--spacing-sm);
+    min-width: 0;
+    min-height: 2.75rem;
+    padding: var(--spacing-xs) var(--spacing-sm);
+    border: var(--border-width) solid var(--color-border);
+    border-radius: var(--border-radius-md);
+    background: var(--color-background-raised);
+}
+
+.attachment-tile--refused {
+    border-color: color-mix(in srgb, var(--color-error-text) 55%, transparent);
+}
+
+.attachment-tile__glyph {
+    display: inline-flex;
+    flex: none;
+    color: var(--color-text-secondary);
+}
+
+.attachment-tile__text {
+    display: grid;
+    flex: 1;
+    min-width: 0;
+}
+
+.attachment-tile__name {
+    overflow: hidden;
+    color: var(--color-text-primary);
+    font-size: var(--font-size-sm);
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.attachment-tile__facts {
+    color: var(--color-text-secondary);
+    font-size: var(--font-size-xs);
+}
+
+.attachment-tile__refusal {
+    color: var(--color-error-text);
+    font-size: var(--font-size-xs);
+}
+
+.attachment-tile__remove {
+    flex: none;
+    min-width: 2.75rem;
+    min-height: 2.75rem;
+}
diff --git a/src/Harness/Backlog.Mobile.WebHarness/Program.cs b/src/Harness/Backlog.Mobile.WebHarness/Program.cs
index ff1936f3b..69bbfef95 100644
--- a/src/Harness/Backlog.Mobile.WebHarness/Program.cs
+++ b/src/Harness/Backlog.Mobile.WebHarness/Program.cs
@@ -44,6 +44,11 @@
 // other's host, which is why there are two registrations rather than one.
 builder.Services.AddScoped<ISpeechTranscriber, WebSpeechTranscriber>();
 
+// The browser half of IAttachmentPicker: hidden <InputFile> elements on the
+// Note page, which Playwright can hand a fixture to. The MAUI head registers the
+// Android camera and pickers against the same abstraction.
+builder.Services.AddScoped<IAttachmentPicker, WebAttachmentPicker>();
+
 // The browser half of ISharedContentReceiver: a share arrives as ?shared=&subject=
 // because a browser cannot be given an Android intent. The MAUI head registers the
 // share target against the same abstraction; neither implementation runs in the
diff --git a/src/Harness/Backlog.UI.Storybook/Components/Pages/AttachmentStripPage.razor b/src/Harness/Backlog.UI.Storybook/Components/Pages/AttachmentStripPage.razor
new file mode 100644
index 000000000..142274adf
--- /dev/null
+++ b/src/Harness/Backlog.UI.Storybook/Components/Pages/AttachmentStripPage.razor
@@ -0,0 +1,102 @@
+@page "/attachment-strip"
+
+<PageTitle>Attachment strip — Backlog UI Storybook</PageTitle>
+
+<StoryPage Title="Attachment strip"
+           Summary="AttachmentStrip: the files attached to something being written, one tile each with its name, type and size — and, on a tile the host refused, the reason. The phone's talk note is its first host."
+           Guidelines="@Rules">
+
+    <Story Name="Picked files"
+           Description="A slide photo and a handout, as the host described them. The strip draws what it is handed: the type and size labels are the host's words, and it knows nothing of caps, allowlists or where the bytes are. With OnRemove set, every tile carries a remove control."
+           Code="@PickedCode">
+        <div class="sb-phone">
+            <AttachmentStrip Tiles="_picked" OnRemove="Remove" AriaLabel="Attached to this note" TestId="attachment-strip-picked" />
+            @if (_picked.Count == 0)
+            {
+                <p class="sb-state" data-testid="attachment-strip-emptied">Every tile was removed; the strip draws nothing.</p>
+            }
+        </div>
+    </Story>
+
+    <Story Name="Refused on its tile"
+           Description="A file the host will not send stays on the strip and says why in words, under its name — the red edge repeats the sentence and never replaces it. Taking it off is the person's call, so the remove control stays."
+           Code="@RefusedCode">
+        <div class="sb-phone">
+            <AttachmentStrip Tiles="Refused" OnRemove="_ => Task.CompletedTask" TestId="attachment-strip-refused" />
+        </div>
+    </Story>
+
+    <Story Name="Read only"
+           Description="Without OnRemove the strip only shows — a note that has left the phone, say, whose files are no longer the person's to take back. A long name ends in an ellipsis and keeps its full text as the tooltip."
+           Code="@ReadOnlyCode">
+        <div class="sb-phone">
+            <AttachmentStrip Tiles="ReadOnly" TestId="attachment-strip-read-only" />
+        </div>
+    </Story>
+
+</StoryPage>
+
+@code {
+    private static readonly DesignGuideline[] Rules =
+    [
+        new("accessibility.md#target-sizes-and-text", "Why each tile and its remove control keep the 44 px touch minimum."),
+        new("accessibility.md#iconography-accessibility", "Why the picture and page glyphs are hidden from a screen reader and the remove control is named for its file."),
+        new("interaction-guidelines.md#error-states", "Why a refusal sits on the tile it is about, in words.")
+    ];
+
+    private List<AttachmentTile> _picked =
+    [
+        new("slide", "IMG_0042.jpg", "JPEG image", "412 KB", IsPicture: true),
+        new("handout", "offline-first-handout.pdf", "PDF", "1.8 MB")
+    ];
+
+    private static readonly IReadOnlyList<AttachmentTile> Refused =
+    [
+        new("slide", "IMG_0042.jpg", "JPEG image", "412 KB", IsPicture: true),
+        new("installer", "demo-setup.exe", "application/x-msdownload", "48.2 MB",
+            Refusal: "Not a type cloud sync takes (.exe). Pictures, PDF, text and Office files only."),
+        new("recording", "keynote-recording.pdf", "PDF", "31.4 MB",
+            Refusal: "Too large: 31.4 MB, and the limit is 25 MB.")
+    ];
+
+    private static readonly IReadOnlyList<AttachmentTile> ReadOnly =
+    [
+        new("deck", "building-offline-first-apps-that-survive-a-conference-hall-wifi.pptx", "PowerPoint deck", "6.3 MB"),
+        new("slide", "IMG_0042.jpg", "JPEG image", "412 KB", IsPicture: true)
+    ];
+
+    private void Remove(AttachmentTile tile) => _picked = [.. _picked.Where(candidate => candidate.Key != tile.Key)];
+
+    private const string PickedCode = """
+        <AttachmentStrip Tiles="_picked" OnRemove="Remove" AriaLabel="Attached to this note" />
+
+        @code {
+            private List<AttachmentTile> _picked =
+            [
+                new("slide", "IMG_0042.jpg", "JPEG image", "412 KB", IsPicture: true),
+                new("handout", "offline-first-handout.pdf", "PDF", "1.8 MB")
+            ];
+
+            private void Remove(AttachmentTile tile) =>
+                _picked = [.. _picked.Where(candidate => candidate.Key != tile.Key)];
+        }
+        """;
+
+    private const string RefusedCode = """
+        <AttachmentStrip Tiles="Refused" OnRemove="Remove" />
+
+        @code {
+            private static readonly IReadOnlyList<AttachmentTile> Refused =
+            [
+                new("installer", "demo-setup.exe", "application/x-msdownload", "48.2 MB",
+                    Refusal: "Not a type cloud sync takes (.exe). Pictures, PDF, text and Office files only."),
+                new("recording", "keynote-recording.pdf", "PDF", "31.4 MB",
+                    Refusal: "Too large: 31.4 MB, and the limit is 25 MB.")
+            ];
+        }
+        """;
+
+    private const string ReadOnlyCode = """
+        <AttachmentStrip Tiles="Tiles" />
+        """;
+}
diff --git a/src/Harness/Backlog.UI.Storybook/Components/Shared/StorybookIndex.cs b/src/Harness/Backlog.UI.Storybook/Components/Shared/StorybookIndex.cs
index ec83f52a5..0de55c990 100644
--- a/src/Harness/Backlog.UI.Storybook/Components/Shared/StorybookIndex.cs
+++ b/src/Harness/Backlog.UI.Storybook/Components/Shared/StorybookIndex.cs
@@ -96,6 +96,12 @@ internal sealed record Group(string Title, IReadOnlyList<Page> Pages);
             // bargain with the host and the only reason the component exists.
             new("file-field", "File field", "FileField: a picked file, read here and handed to the host as text."),
 
+            // After File field, and its own page for the same reason: it is what
+            // a host shows once files are picked, and a refusal it draws on a
+            // tile is a convention of its own. It draws only an IconButton, which
+            // Buttons introduced above.
+            new("attachment-strip", "Attachment strip", "AttachmentStrip: the files on something being written, with their name, type and size — and why, on a tile the host refused."),
+
             // Badges before Selects, and by the rule: BadgeSelect draws its
             // options as a Badge, and the ready-made selectors show the
             // StatusBadge a picked value renders as. A badge is a value with a
diff --git a/src/Modules/Sync/Backlog.Modules.Sync.Abstractions/SyncAttachmentLimits.cs b/src/Modules/Sync/Backlog.Modules.Sync.Abstractions/SyncAttachmentLimits.cs
new file mode 100644
index 000000000..3c702a01c
--- /dev/null
+++ b/src/Modules/Sync/Backlog.Modules.Sync.Abstractions/SyncAttachmentLimits.cs
@@ -0,0 +1,43 @@
+namespace Backlog.Modules.Sync.Abstractions;
+
+/// <summary>
+/// The defaults local ADR 0014 puts on an upload: the per-file cap and the
+/// content-type allowlist. Written down here, beside the routes, because both
+/// ends read them — the service enforces them (as the defaults of its
+/// <c>SyncAttachmentOptions</c> setting) and the phone refuses a file on its
+/// tile before it ever queues one the service would answer 413 or 415 to.
+/// </summary>
+public static class SyncAttachmentLimits
+{
+    /// <summary>The most one attachment may weigh by default: 25 MB.</summary>
+    public const long DefaultMaxBytes = 25L * 1024 * 1024;
+
+    /// <summary>
+    /// The allowlist when the setting names none: images, PDF, plain text,
+    /// Markdown and CSV, and the Office Open XML document, spreadsheet and
+    /// presentation types. It exists to refuse executables, scripts and HTML,
+    /// not to enumerate every useful format.
+    /// </summary>
+    public static readonly IReadOnlyList<string> DefaultContentTypes =
+    [
+        "image/jpeg",
+        "image/png",
+        "image/heic",
+        "image/heif",
+        "image/webp",
+        "image/gif",
+        "application/pdf",
+        "text/plain",
+        "text/markdown",
+        "text/csv",
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ];
+
+    /// <summary>Whether <paramref name="mediaType"/> — without its parameters —
+    /// is on <see cref="DefaultContentTypes"/>, ignoring case.</summary>
+    public static bool AllowsByDefault(string? mediaType) =>
+        !string.IsNullOrWhiteSpace(mediaType)
+        && DefaultContentTypes.Contains(mediaType.Split(';')[0].Trim(), StringComparer.OrdinalIgnoreCase);
+}
diff --git a/src/Modules/Sync/Backlog.Modules.Sync.Api/Options/SyncAttachmentOptions.cs b/src/Modules/Sync/Backlog.Modules.Sync.Api/Options/SyncAttachmentOptions.cs
index 0732a5d0c..bfbc15414 100644
--- a/src/Modules/Sync/Backlog.Modules.Sync.Api/Options/SyncAttachmentOptions.cs
+++ b/src/Modules/Sync/Backlog.Modules.Sync.Api/Options/SyncAttachmentOptions.cs
@@ -1,5 +1,7 @@
 using System.ComponentModel.DataAnnotations;
 
+using Backlog.Modules.Sync.Abstractions;
+
 namespace Backlog.Modules.Sync.Api.Options;
 
 /// <summary>
@@ -14,34 +16,16 @@ public sealed class SyncAttachmentOptions
     /// it.</summary>
     public const string SectionName = "Modules:Sync:Attachments";
 
-    /// <summary>
-    /// The allowlist when the setting names none: images, PDF, plain text,
-    /// Markdown and CSV, and the Office Open XML document, spreadsheet and
-    /// presentation types. It exists to refuse executables, scripts and HTML,
-    /// not to enumerate every useful format.
-    /// </summary>
-    public static readonly IReadOnlyList<string> DefaultContentTypes =
-    [
-        "image/jpeg",
-        "image/png",
-        "image/heic",
-        "image/heif",
-        "image/webp",
-        "image/gif",
-        "application/pdf",
-        "text/plain",
-        "text/markdown",
-        "text/csv",
-        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-        "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-    ];
+    /// <summary>The allowlist when the setting names none —
+    /// <see cref="SyncAttachmentLimits.DefaultContentTypes"/>, which the phone
+    /// reads too.</summary>
+    public static IReadOnlyList<string> DefaultContentTypes => SyncAttachmentLimits.DefaultContentTypes;
 
     /// <summary>The most one attachment may weigh: 25 MB by default. Bounded
     /// above so a typo cannot open the service to uploads the container app
     /// would hold a connection open for minutes to receive.</summary>
     [Range(1, 256L * 1024 * 1024)]
-    public long MaxBytes { get; set; } = 25L * 1024 * 1024;
+    public long MaxBytes { get; set; } = SyncAttachmentLimits.DefaultMaxBytes;
 
     /// <summary>
     /// The media types an upload may declare, compared without their
diff --git a/tests/Backlog.ArchitectureTests/StorybookOrderTests.cs b/tests/Backlog.ArchitectureTests/StorybookOrderTests.cs
index 36ee02864..64991a0f1 100644
--- a/tests/Backlog.ArchitectureTests/StorybookOrderTests.cs
+++ b/tests/Backlog.ArchitectureTests/StorybookOrderTests.cs
@@ -53,7 +53,7 @@ public class StorybookOrderTests
         ["Diagrams"] = ["diagrams", "graph-explorer", "graph-atlas"],
         ["Feedback"] = ["feedback"],
         ["Icons"] = ["foundations"],
-        ["Inputs"] = ["inputs", "file-field"],
+        ["Inputs"] = ["inputs", "file-field", "attachment-strip"],
         ["Integrations"] = ["integrations"],
         ["Devbook"] = ["devbook", "markdown/references"],
         ["Layout"] = ["layout", "file-view", "folder-view"],
diff --git a/tests/Backlog.Mobile.UI.UnitTests/Backlog.Mobile.UI.UnitTests.csproj b/tests/Backlog.Mobile.UI.UnitTests/Backlog.Mobile.UI.UnitTests.csproj
index 715ab4f5b..d7c018a76 100644
--- a/tests/Backlog.Mobile.UI.UnitTests/Backlog.Mobile.UI.UnitTests.csproj
+++ b/tests/Backlog.Mobile.UI.UnitTests/Backlog.Mobile.UI.UnitTests.csproj
@@ -16,6 +16,12 @@
     <Using Include="Backlog.Mobile.UI.Services" />
   </ItemGroup>
 
+  <ItemGroup>
+    <!-- A slide photo with a phone's EXIF (orientation 6, camera, GPS) and a
+         one-page handout: the downscaler's input, and the files QA uploads. -->
+    <None Include="Fixtures\**" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+
   <ItemGroup>
     <!-- Only the mobile UI: these tests drive the screen, and the MAUI head and
          the browser harness are the two hosts it has to run in unchanged. -->
diff --git a/tests/Backlog.Mobile.UI.UnitTests/Fixtures/handout.pdf b/tests/Backlog.Mobile.UI.UnitTests/Fixtures/handout.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..28434116301b7a1f7d3c3a2b09d48749d044671d
GIT binary patch
literal 597
zcmZWn&riZI7`^wecoz~qVApNsM?!W$Atq`xup9AESO>$onyxeGUvJxiOzEk8-}}Dz
z`r6*h-Mr6kV!{wWt@mUy0ZqR?B<QU$qEuVZ7qOK!LQ7a6Nr<d6M|9`E4K0s86j_Z`
z<mj(<ifSqY)@gK=%SI=orKPqy^hsugn5qL-f#vft$0!c{yvkTwjo1l*E@Z75y|D(J
z^SQDU{Dy&hLXueNj=F0*sXxkUYj)s~tJg+L@lK|xox%{tNOKHB3<m+y3|FZr->?(*
z?u|hod2uj}me)x4n58b0WB)N7Cw`J?<Mh_(vRNCSt^*n9RMfJq+{^M)nqnh5W)E8C
zB*1_KzY7D-BaR$rYz$vTb;kJU0%Od2a;w7&WBcs?uqd_>oiL+CQA+K9#j^O87}&&>
Wau0g^4Yd*4c%LzgNv}71o|7N?cAa(r

literal 0
HcmV?d00001

diff --git a/tests/Backlog.Mobile.UI.UnitTests/Fixtures/slide-photo.jpg b/tests/Backlog.Mobile.UI.UnitTests/Fixtures/slide-photo.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..a47ffc6aba252b1b1535c4433e15e829ab5d28fc
GIT binary patch
literal 79450
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

literal 0
HcmV?d00001

diff --git a/tests/Backlog.Mobile.UI.UnitTests/InMemoryDeviceStore.cs b/tests/Backlog.Mobile.UI.UnitTests/InMemoryDeviceStore.cs
index 9e6cc7330..790229768 100644
--- a/tests/Backlog.Mobile.UI.UnitTests/InMemoryDeviceStore.cs
+++ b/tests/Backlog.Mobile.UI.UnitTests/InMemoryDeviceStore.cs
@@ -1,7 +1,9 @@
 using Backlog.Mobile.UI.Outbox;
+using Backlog.Mobile.UI.TalkNotes;
 using Backlog.Mobile.UI.Tasks;
 
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
 
 namespace Backlog.Mobile.UI.UnitTests;
 
@@ -61,6 +63,9 @@ public static IServiceCollection AddTestDeviceOutbox(this IServiceCollection ser
         services.AddSingleton(store ?? new InMemoryDeviceStore());
         services.AddSingleton<IOutboxKind, CaptureOutboxKind>();
         services.AddSingleton<IOutboxKind, TaskOutboxKind>();
+        services.TryAddSingleton(_ => new TalkNoteFiles(TestFolders.Create()));
+        services.AddSingleton<IOutboxKind, TalkNoteOutboxKind>();
+        services.AddSingleton<TalkNoteComposer>();
         services.AddSingleton<DeviceOutbox>();
         services.AddSingleton(taskView ?? new InMemoryTaskViewStore());
         services.AddSingleton<TaskViewProjection>();
diff --git a/tests/Backlog.Mobile.UI.UnitTests/PictureDownscalerTests.cs b/tests/Backlog.Mobile.UI.UnitTests/PictureDownscalerTests.cs
new file mode 100644
index 000000000..87fabf58f
--- /dev/null
+++ b/tests/Backlog.Mobile.UI.UnitTests/PictureDownscalerTests.cs
@@ -0,0 +1,91 @@
+using Backlog.Mobile.UI.TalkNotes;
+
+using SkiaSharp;
+
+namespace Backlog.Mobile.UI.UnitTests;
+
+/// <summary>
+/// The fixture is a 3200 × 2400 slide photo carrying what a phone writes into
+/// EXIF: the orientation (6, turn 90° clockwise to view), the camera make, the
+/// capture time and a GPS block. Downscaled, it is a 1600 × 1200 JPEG with the
+/// orientation and nothing else.
+/// </summary>
+public sealed class PictureDownscalerTests
+{
+    private static byte[] Fixture => File.ReadAllBytes(TestFolders.Fixture("slide-photo.jpg"));
+
+    [Fact]
+    public void The_fixture_carries_a_phone_s_exif_to_begin_with()
+    {
+        var tags = ExifOrientation.ReadTags(Fixture);
+
+        Assert.Equal(6, tags[ExifOrientation.Tag]);
+        Assert.True(tags.Count > 1, "The fixture should carry more than the orientation, or the test proves nothing.");
+    }
+
+    [Fact]
+    public void The_longest_edge_becomes_1600_and_the_aspect_holds()
+    {
+        using var source = new MemoryStream(Fixture);
+        var output = PictureDownscaler.Downscale(source);
+
+        Assert.NotNull(output);
+        using var codec = SKCodec.Create(new MemoryStream(output));
+        Assert.Equal(SKEncodedImageFormat.Jpeg, codec.EncodedFormat);
+        Assert.Equal(1600, codec.Info.Width);
+        Assert.Equal(1200, codec.Info.Height);
+        Assert.True(output.Length < Fixture.Length * 2, "A downscaled photo is not larger than it started by much.");
+    }
+
+    [Fact]
+    public void Every_exif_field_but_the_orientation_is_gone()
+    {
+        using var source = new MemoryStream(Fixture);
+        var output = PictureDownscaler.Downscale(source)!;
+
+        var tags = ExifOrientation.ReadTags(output);
+        Assert.Equal([ExifOrientation.Tag], tags.Keys);
+        Assert.Equal(6, tags[ExifOrientation.Tag]);
+
+        // A decoder reads it the same way the camera meant it.
+        using var codec = SKCodec.Create(new MemoryStream(output));
+        Assert.Equal(SKEncodedOrigin.RightTop, codec.EncodedOrigin);
+
+        // No trace of the camera or the GPS block in the bytes either.
+        Assert.DoesNotContain("FixtureCam", System.Text.Encoding.ASCII.GetString(output), StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void A_small_upright_png_is_re_encoded_as_jpeg_at_its_own_size_with_no_exif()
+    {
+        using var bitmap = new SKBitmap(new SKImageInfo(400, 300, SKColorType.Rgba8888, SKAlphaType.Premul));
+        bitmap.Erase(SKColors.Transparent);
+        using var png = bitmap.Encode(SKEncodedImageFormat.Png, 100);
+
+        var output = PictureDownscaler.Downscale(new MemoryStream(png.ToArray()))!;
+
+        using var codec = SKCodec.Create(new MemoryStream(output));
+        Assert.Equal(SKEncodedImageFormat.Jpeg, codec.EncodedFormat);
+        Assert.Equal((400, 300), (codec.Info.Width, codec.Info.Height));
+        Assert.Empty(ExifOrientation.ReadTags(output));
+    }
+
+    [Fact]
+    public void Bytes_that_are_not_a_picture_are_left_to_go_as_they_are()
+    {
+        var pdf = File.ReadAllBytes(TestFolders.Fixture("handout.pdf"));
+
+        Assert.Null(PictureDownscaler.Downscale(new MemoryStream(pdf)));
+    }
+
+    [Theory]
+    [InlineData("image/jpeg", true)]
+    [InlineData("image/PNG", true)]
+    [InlineData("image/heic", true)]
+    [InlineData("image/gif", false)]
+    [InlineData("application/pdf", false)]
+    public void Which_types_are_downscaled(string contentType, bool handled)
+    {
+        Assert.Equal(handled, PictureDownscaler.Handles(contentType));
+    }
+}
diff --git a/tests/Backlog.Mobile.UI.UnitTests/ScriptedInboxService.cs b/tests/Backlog.Mobile.UI.UnitTests/ScriptedInboxService.cs
index 6a5deddd9..843330e54 100644
--- a/tests/Backlog.Mobile.UI.UnitTests/ScriptedInboxService.cs
+++ b/tests/Backlog.Mobile.UI.UnitTests/ScriptedInboxService.cs
@@ -18,6 +18,7 @@ internal sealed class ScriptedInboxService
     private readonly Lock _lock = new();
     private readonly List<InboxItem> _items = [];
     private readonly List<CaptureRequest> _received = [];
+    private readonly List<(Guid Id, long Bytes)> _uploads = [];
 
     public ScriptedInboxService(params InboxItem[] items) => _items.AddRange(items);
 
@@ -35,6 +36,16 @@ public IReadOnlyList<CaptureRequest> Received
         }
     }
 
+    /// <summary>Every attachment upload that reached the service, in order: its
+    /// id and how many bytes came.</summary>
+    public IReadOnlyList<(Guid Id, long Bytes)> Uploads
+    {
+        get
+        {
+            lock (_lock) return [.. _uploads];
+        }
+    }
+
     /// <summary>Only the posts answered 201 — the ones that wrote something.</summary>
     public int Created { get; private set; }
 
@@ -42,6 +53,12 @@ public async Task<HttpResponseMessage> AnswerAsync(HttpRequestMessage request, C
     {
         Requests++;
 
+        byte[]? upload = null;
+        if (request.Method == HttpMethod.Put && request.Content is not null)
+        {
+            upload = await request.Content.ReadAsByteArrayAsync(cancellationToken);
+        }
+
         CaptureRequest? capture = null;
         if (request.Method == HttpMethod.Post && request.Content is not null)
         {
@@ -70,6 +87,13 @@ public async Task<HttpResponseMessage> AnswerAsync(HttpRequestMessage request, C
                     };
             }
 
+            if (upload is not null)
+            {
+                var uploaded = Guid.Parse(request.RequestUri!.Segments[^1]);
+                _uploads.Add((uploaded, upload.LongLength));
+                return new HttpResponseMessage(HttpStatusCode.Created);
+            }
+
             if (request.Method == HttpMethod.Get)
             {
                 return JsonAnswer(HttpStatusCode.OK, _items.ToList());
@@ -83,7 +107,7 @@ public async Task<HttpResponseMessage> AnswerAsync(HttpRequestMessage request, C
                 return JsonAnswer(HttpStatusCode.OK, existing);
             }
 
-            var stored = new InboxItem(id, capture.Title, capture.Source, DateTimeOffset.UtcNow, capture.BodyMd, capture.Tags ?? [], capture.Person);
+            var stored = new InboxItem(id, capture.Title, capture.Source, DateTimeOffset.UtcNow, capture.BodyMd, capture.Tags ?? [], capture.Person, capture.Attachments);
             _items.Add(stored);
             Created++;
 
diff --git a/tests/Backlog.Mobile.UI.UnitTests/ShellHost.cs b/tests/Backlog.Mobile.UI.UnitTests/ShellHost.cs
index 09af1c2ac..e275dc04e 100644
--- a/tests/Backlog.Mobile.UI.UnitTests/ShellHost.cs
+++ b/tests/Backlog.Mobile.UI.UnitTests/ShellHost.cs
@@ -38,6 +38,7 @@ private ShellHost(
         if (clock is not null) _context.Services.AddSingleton(clock);
         _context.Services.AddSingleton<ISharedContentReceiver>(new TestSharedContentReceiver());
         _context.Services.AddSingleton<ISpeechTranscriber>(new SilentSpeechTranscriber());
+        _context.Services.AddSingleton<IAttachmentPicker>(Picker);
         _context.Services.AddSingleton(credentials);
         _context.Services.AddSingleton(new CloudSyncClient(
             new HttpClient(_handler) { BaseAddress = new Uri("https://sync.test") }));
@@ -48,6 +49,9 @@ private ShellHost(
         _context.Services.AddTestDeviceOutbox(store, taskView);
     }
 
+    /// <summary>What the Note page's attach buttons hand back.</summary>
+    public TestAttachmentPicker Picker { get; } = new();
+
     public IDeviceCredentialStore Credentials { get; }
 
     /// <summary>The service's side of the inbox: what it holds, whether it
@@ -63,6 +67,8 @@ private ShellHost(
 
     public DeviceOutbox Outbox => _context.Services.GetRequiredService<DeviceOutbox>();
 
+    public T Service<T>() where T : notnull => _context.Services.GetRequiredService<T>();
+
     public static ShellHost Unpaired(Func<HttpRequestMessage, int, HttpResponseMessage>? pair = null) =>
         new(TestDevices.Unpaired(), pair, inbox: null, store: null, clock: null);
 
diff --git a/tests/Backlog.Mobile.UI.UnitTests/ShellNavigationTests.cs b/tests/Backlog.Mobile.UI.UnitTests/ShellNavigationTests.cs
index 3913825a1..ddc4cc021 100644
--- a/tests/Backlog.Mobile.UI.UnitTests/ShellNavigationTests.cs
+++ b/tests/Backlog.Mobile.UI.UnitTests/ShellNavigationTests.cs
@@ -30,7 +30,7 @@ public void A_paired_phone_shows_three_tabs_with_the_current_one_lit()
     }
 
     [Theory]
-    [InlineData("note", "Note", "note-placeholder")]
+    [InlineData("note", "Talk note", "note-send")]
     [InlineData("tasks", "My Day", "tasks-empty")]
     public void Each_tab_resolves_to_its_own_page(string route, string heading, string placeholder)
     {
diff --git a/tests/Backlog.Mobile.UI.UnitTests/TalkNoteOutboxTests.cs b/tests/Backlog.Mobile.UI.UnitTests/TalkNoteOutboxTests.cs
new file mode 100644
index 000000000..74ed41d9f
--- /dev/null
+++ b/tests/Backlog.Mobile.UI.UnitTests/TalkNoteOutboxTests.cs
@@ -0,0 +1,319 @@
+using System.Net;
+using System.Net.Http.Json;
+using System.Security.Cryptography;
+
+using Backlog.Mobile.UI.Outbox;
+using Backlog.Mobile.UI.TalkNotes;
+using Backlog.Modules.Sync.Abstractions;
+using Backlog.Modules.Sync.Abstractions.DataTransferObjects;
+
+using Microsoft.Extensions.Time.Testing;
+
+namespace Backlog.Mobile.UI.UnitTests;
+
+/// <summary>
+/// A saved talk note is one outbox entry that is several requests: every
+/// attachment's upload, then the capture naming them. These tests hold the
+/// order, the retry of only what has not landed, and what the page says while
+/// it goes.
+/// </summary>
+public sealed class TalkNoteOutboxTests : IDisposable
+{
+    private static readonly DateTimeOffset Start = new(2026, 9, 26, 14, 0, 0, TimeSpan.Zero);
+
+    private readonly FakeTimeProvider _clock = new(Start);
+    private readonly AttachmentService _service = new();
+    private readonly TalkNoteFiles _files = new(TestFolders.Create());
+    private readonly TestAttachmentPicker _picker = new();
+    private readonly DeviceOutbox _outbox;
+    private readonly TalkNoteComposer _composer;
+
+    public TalkNoteOutboxTests()
+    {
+        var sync = new CloudSyncClient(new HttpClient(_service) { BaseAddress = new Uri("https://sync.test") });
+        _outbox = new DeviceOutbox(new InMemoryDeviceStore(), [new TalkNoteOutboxKind(sync, _files)], _clock);
+        _composer = new TalkNoteComposer(_files, _outbox, _clock);
+    }
+
+    private static CancellationToken Cancellation => TestContext.Current.CancellationToken;
+
+    public void Dispose() => _outbox.Dispose();
+
+    [Fact]
+    public async Task Every_attachment_is_uploaded_before_the_capture_that_names_them()
+    {
+        var id = await SaveAsync("Handout", ("handout.pdf", "application/pdf"), ("notes.md", "text/markdown"));
+        await _outbox.WhenIdleAsync();
+
+        var draftless = _service.Posted!;
+        Assert.Equal(["PUT handout.pdf", "PUT notes.md", "POST"], _service.Calls);
+        Assert.Equal(id, draftless.Id);
+        Assert.Equal(["handout.pdf", "notes.md"], draftless.Attachments!.Select(attachment => attachment.Name));
+
+        // What the capture names is exactly what went up, digest and all.
+        foreach (var attachment in draftless.Attachments!)
+        {
+            Assert.Equal(attachment.Sha256, _service.Digests[attachment.Id]);
+            Assert.Equal(attachment.SizeBytes, _service.Sizes[attachment.Id]);
+        }
+
+        Assert.Empty(_outbox.Entries);
+        Assert.Equal("synced", TalkNoteOutboxKind.StatusOf(_outbox, id));
+    }
+
+    [Fact]
+    public async Task A_failed_upload_is_retried_on_its_own_and_one_already_sent_is_not_sent_again()
+    {
+        _service.Answer = (call, attempt) => call == "PUT b.pdf" && attempt == 1 ? HttpStatusCode.ServiceUnavailable : null;
+
+        await SaveAsync("Two files", ("a.pdf", "application/pdf"), ("b.pdf", "application/pdf"));
+        await _outbox.WhenIdleAsync();
+
+        Assert.Equal(["PUT a.pdf", "PUT b.pdf"], _service.Calls);
+        var waiting = Assert.Single(_outbox.Entries);
+        Assert.Equal(1, waiting.Attempts);
+        Assert.Contains("b.pdf", waiting.LastError, StringComparison.Ordinal);
+
+        _clock.Advance(DeviceOutbox.FirstRetryDelay);
+        await _outbox.WhenIdleAsync();
+
+        Assert.Equal(["PUT a.pdf", "PUT b.pdf", "PUT b.pdf", "POST"], _service.Calls);
+        Assert.Empty(_outbox.Entries);
+    }
+
+    /// <summary>
+    /// Four failures on each of two files is eight in all — past the five the
+    /// outbox allows an entry — and yet it is not parked: each upload that lands
+    /// gives the attempts back, so each file has the whole budget of its own.
+    /// </summary>
+    [Fact]
+    public async Task Each_upload_has_its_own_attempt_budget()
+    {
+        _service.Answer = (call, attempt) => call.StartsWith("PUT", StringComparison.Ordinal) && attempt <= 4
+            ? HttpStatusCode.BadGateway
+            : null;
+
+        await SaveAsync("Budget", ("a.pdf", "application/pdf"), ("b.pdf", "application/pdf"));
+
+        for (var round = 0; round < 12 && _outbox.Entries.Count > 0; round++)
+        {
+            await _outbox.WhenIdleAsync();
+            _clock.Advance(TimeSpan.FromSeconds(16));
+        }
+
+        await _outbox.WhenIdleAsync();
+
+        Assert.Empty(_outbox.Entries);
+        Assert.Equal(5, _service.Calls.Count(call => call == "PUT a.pdf"));
+        Assert.Equal(5, _service.Calls.Count(call => call == "PUT b.pdf"));
+        Assert.Equal("POST", _service.Calls[^1]);
+    }
+
+    [Fact]
+    public async Task A_file_the_service_refuses_refuses_the_note_by_name_and_the_capture_is_never_posted()
+    {
+        _service.Answer = (call, _) => call == "PUT b.pdf" ? HttpStatusCode.UnsupportedMediaType : null;
+
+        var id = await SaveAsync("Refused", ("a.pdf", "application/pdf"), ("b.pdf", "application/pdf"));
+        await _outbox.WhenIdleAsync();
+
+        var parked = Assert.Single(_outbox.Entries);
+        Assert.True(parked.Refused);
+        Assert.StartsWith("b.pdf:", parked.LastError, StringComparison.Ordinal);
+        Assert.DoesNotContain("POST", _service.Calls);
+        Assert.Equal("waiting — tap to retry", TalkNoteOutboxKind.StatusOf(_outbox, id));
+    }
+
+    [Fact]
+    public async Task While_the_second_of_three_goes_up_the_note_says_uploading_2_of_3()
+    {
+        var held = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var reached = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        _service.Hold = call => call == "PUT b.pdf" ? (reached, held.Task) : null;
+
+        var id = await SaveAsync("Three", ("a.pdf", "application/pdf"), ("b.pdf", "application/pdf"), ("c.pdf", "application/pdf"));
+        await reached.Task.WaitAsync(TimeSpan.FromSeconds(10), Cancellation);
+
+        Assert.Equal("uploading 2 of 3", TalkNoteOutboxKind.StatusOf(_outbox, id));
+
+        held.SetResult();
+        await _outbox.WhenIdleAsync();
+
+        Assert.Equal("synced", TalkNoteOutboxKind.StatusOf(_outbox, id));
+    }
+
+    [Fact]
+    public async Task Offline_the_note_is_waiting_and_its_files_stay_until_the_capture_lands()
+    {
+        _service.Offline = true;
+
+        var id = await SaveAsync("Offline", ("a.pdf", "application/pdf"));
+        await _outbox.WhenIdleAsync();
+
+        Assert.Equal("waiting", TalkNoteOutboxKind.StatusOf(_outbox, id));
+        var attachment = TalkNoteOutboxKind.Read(_outbox.Entries[0]).Capture.Attachments!.Single();
+        Assert.True(File.Exists(_files.OutboxPath(attachment.Id)));
+
+        _service.Offline = false;
+        await _outbox.ResumeAsync(Cancellation);
+
+        Assert.Equal("synced", TalkNoteOutboxKind.StatusOf(_outbox, id));
+        Assert.False(File.Exists(_files.OutboxPath(attachment.Id)), "A delivered note's files are released.");
+    }
+
+    [Fact]
+    public async Task A_picture_is_downscaled_unless_the_note_keeps_originals()
+    {
+        var photo = await File.ReadAllBytesAsync(TestFolders.Fixture("slide-photo.jpg"), Cancellation);
+
+        var draft = new TalkNoteDraft { Title = "Slides" };
+        draft.Attachments.Add(await _files.StageAsync(_picker.File("IMG_0042.JPG", "image/jpeg", photo), 0, Cancellation));
+        await _composer.SaveAsync(draft, Cancellation);
+
+        var original = new TalkNoteDraft { Title = "Slides, as taken", SendOriginals = true };
+        original.Attachments.Add(await _files.StageAsync(_picker.File("IMG_0043.png", "image/png", photo), 0, Cancellation));
+        await _composer.SaveAsync(original, Cancellation);
+
+        await _outbox.WhenIdleAsync();
+
+        var downscaled = _service.Captures[0].Attachments!.Single();
+        Assert.Equal("IMG_0042.jpg", downscaled.Name);
+        Assert.Equal("image/jpeg", downscaled.ContentType);
+        Assert.True(downscaled.SizeBytes < photo.Length, "The downscaled photo is the smaller one.");
+
+        var kept = _service.Captures[1].Attachments!.Single();
+        Assert.Equal("IMG_0043.png", kept.Name);
+        Assert.Equal(photo.Length, kept.SizeBytes);
+        Assert.Equal(Convert.ToHexStringLower(SHA256.HashData(photo)), kept.Sha256);
+    }
+
+    [Fact]
+    public async Task The_capture_carries_the_body_tags_and_speaker()
+    {
+        var draft = new TalkNoteDraft
+        {
+            Body = "Outbox before network.\n\nThe hall has no signal.",
+            Tags = "#conference, offline  #conference",
+            Speaker = "@ada",
+        };
+
+        await _composer.SaveAsync(draft, Cancellation);
+        await _outbox.WhenIdleAsync();
+
+        var capture = Assert.Single(_service.Captures);
+        Assert.Equal("Outbox before network.", capture.Title);
+        Assert.Equal("Outbox before network.\n\nThe hall has no signal.", capture.BodyMd);
+        Assert.Equal(["conference", "offline"], capture.Tags);
+        Assert.Equal("ada", capture.Person);
+        Assert.Null(capture.Attachments);
+        Assert.Equal(CaptureOutboxKind.Source, capture.Source);
+    }
+
+    private async Task<Guid> SaveAsync(string title, params (string Name, string Type)[] attachments)
+    {
+        var draft = new TalkNoteDraft { Title = title };
+        foreach (var (name, type) in attachments)
+        {
+            draft.Attachments.Add(await _files.StageAsync(_picker.Text(name, type, $"contents of {name}"), draft.Attachments.Count, Cancellation));
+        }
+
+        return (await _composer.SaveAsync(draft, Cancellation))!.Value;
+    }
+
+    /// <summary>
+    /// The two sync routes a talk note uses, recording every call as
+    /// "PUT name" or "POST" in arrival order. <see cref="Answer"/> overrides the
+    /// status of a call's nth attempt; <see cref="Hold"/> parks one until the
+    /// test lets it go.
+    /// </summary>
+    private sealed class AttachmentService : HttpMessageHandler
+    {
+        private readonly Lock _lock = new();
+        private readonly Dictionary<Guid, string> _names = [];
+        private readonly Dictionary<string, int> _attempts = [];
+
+        public List<string> Calls { get; } = [];
+
+        public Dictionary<Guid, string> Digests { get; } = [];
+
+        public Dictionary<Guid, long> Sizes { get; } = [];
+
+        public List<CaptureRequest> Captures { get; } = [];
+
+        public CaptureRequest? Posted => Captures.LastOrDefault();
+
+        public bool Offline { get; set; }
+
+        public Func<string, int, HttpStatusCode?>? Answer { get; set; }
+
+        public Func<string, (TaskCompletionSource Reached, Task Release)?>? Hold { get; set; }
+
+        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            if (Offline) throw new HttpRequestException("No such host is known. (sync.test:443)");
+
+            string call;
+            if (request.Method == HttpMethod.Put)
+            {
+                var id = Guid.Parse(request.RequestUri!.Segments[^1]);
+                var bytes = await request.Content!.ReadAsByteArrayAsync(cancellationToken);
+
+                // The name is not on the wire; it is matched back through the
+                // capture's metadata once the POST arrives, so record by id here.
+                call = $"PUT {NameOf(id, bytes)}";
+
+                lock (_lock)
+                {
+                    Digests[id] = request.Headers.GetValues(SyncRoutes.AttachmentSha256Header).Single();
+                    Sizes[id] = bytes.LongLength;
+                }
+            }
+            else
+            {
+                call = "POST";
+            }
+
+            int attempt;
+            lock (_lock)
+            {
+                Calls.Add(call);
+                attempt = _attempts[call] = _attempts.GetValueOrDefault(call) + 1;
+            }
+
+            if (Hold?.Invoke(call) is { } hold)
+            {
+                hold.Reached.TrySetResult();
+                await hold.Release;
+            }
+
+            if (Answer?.Invoke(call, attempt) is { } status)
+            {
+                return new HttpResponseMessage(status) { Content = JsonContent.Create(new { detail = $"answered {(int)status}" }) };
+            }
+
+            if (call == "POST")
+            {
+                var capture = (await request.Content!.ReadFromJsonAsync<CaptureRequest>(cancellationToken))!;
+                lock (_lock) Captures.Add(capture);
+                return new HttpResponseMessage(HttpStatusCode.Created);
+            }
+
+            return new HttpResponseMessage(HttpStatusCode.Created);
+        }
+
+        /// <summary>The test files' bytes are "contents of {name}", which is
+        /// how a PUT is told apart without a name on the wire.</summary>
+        private string NameOf(Guid id, byte[] bytes)
+        {
+            lock (_lock)
+            {
+                if (_names.TryGetValue(id, out var known)) return known;
+
+                var text = System.Text.Encoding.UTF8.GetString(bytes);
+                var name = text.StartsWith("contents of ", StringComparison.Ordinal) ? text["contents of ".Length..] : id.ToString("N");
+                _names[id] = name;
+                return name;
+            }
+        }
+    }
+}
diff --git a/tests/Backlog.Mobile.UI.UnitTests/TalkNoteScreenTests.cs b/tests/Backlog.Mobile.UI.UnitTests/TalkNoteScreenTests.cs
new file mode 100644
index 000000000..7e45ca4b5
--- /dev/null
+++ b/tests/Backlog.Mobile.UI.UnitTests/TalkNoteScreenTests.cs
@@ -0,0 +1,153 @@
+using Backlog.Mobile.UI.Outbox;
+
+namespace Backlog.Mobile.UI.UnitTests;
+
+/// <summary>
+/// The Note tab as a person meets it: what outlives a look at another tab, what
+/// a refused file says, and what saving does.
+/// </summary>
+public sealed class TalkNoteScreenTests
+{
+    /// <summary>
+    /// The Router remounts the Note page on every navigation. A talk does not
+    /// pause for a glance at the Inbox, so everything typed and attached has to
+    /// be there on the way back.
+    /// </summary>
+    [Fact]
+    public void A_draft_with_an_attachment_survives_a_trip_to_the_inbox_and_back()
+    {
+        using var host = ShellHost.Paired();
+        host.Picker.Next = AttachmentPick.Of([host.Picker.Text("handout.pdf", "application/pdf", "%PDF-1.4 handout")]);
+
+        var app = host.Open("note");
+        app.WaitForAssertion(() => Assert.NotNull(app.Find("[data-testid='note-send']")));
+
+        app.Find("[data-testid='note-title'] input").Input("Offline-first keynote");
+        app.Find("[data-testid='note-body'] textarea").Input("Outbox before network.");
+        app.Find("[data-testid='note-speaker'] input").Input("@ada");
+        app.Find("[data-testid='note-tags'] input").Input("#conference");
+        app.Find("[data-testid='note-choose-files']").Click();
+        app.WaitForAssertion(() => Assert.Single(app.FindAll("[data-testid='attachment-tile']")));
+
+        host.Navigation.NavigateTo("");
+        app.WaitForAssertion(() => Assert.NotNull(app.Find("[data-testid='capture-field'] input")));
+        host.Navigation.NavigateTo("note");
+        app.WaitForAssertion(() => Assert.NotNull(app.Find("[data-testid='note-send']")));
+
+        Assert.Equal("Offline-first keynote", app.Find("[data-testid='note-title'] input").GetAttribute("value"));
+        Assert.Equal("Outbox before network.", app.Find("[data-testid='note-body'] textarea").GetAttribute("value"));
+        Assert.Equal("@ada", app.Find("[data-testid='note-speaker'] input").GetAttribute("value"));
+        Assert.Equal("#conference", app.Find("[data-testid='note-tags'] input").GetAttribute("value"));
+
+        var tile = app.Find("[data-testid='attachment-tile']");
+        Assert.Equal("handout.pdf", tile.QuerySelector("[data-testid='attachment-tile-name']")!.TextContent);
+        Assert.Equal("PDF · 16 B", tile.QuerySelector("[data-testid='attachment-tile-facts']")!.TextContent);
+    }
+
+    [Fact]
+    public void A_file_outside_the_allowlist_is_refused_on_its_tile_naming_why_and_is_never_read()
+    {
+        using var host = ShellHost.Paired();
+        host.Picker.Next = AttachmentPick.Of([host.Picker.Text("setup.exe", "application/x-msdownload", "MZ")]);
+
+        var app = OpenNote(host);
+        app.Find("[data-testid='note-title'] input").Input("Tools from the talk");
+        app.Find("[data-testid='note-choose-files']").Click();
+
+        app.WaitForAssertion(() =>
+        {
+            var refusal = app.Find("[data-testid='attachment-tile-refusal']").TextContent;
+            Assert.Contains(".exe", refusal, StringComparison.Ordinal);
+            Assert.Contains("Pictures, PDF, text and Office files only", refusal, StringComparison.Ordinal);
+        });
+
+        Assert.Equal(0, host.Picker.Reads);
+        Assert.True(app.Find("[data-testid='note-send']").HasAttribute("disabled"));
+        Assert.NotNull(app.Find("[data-testid='note-refused-notice']"));
+
+        // Taking it off the strip is what lets the note go.
+        app.Find("[data-testid='attachment-tile-remove']").Click();
+        app.WaitForAssertion(() => Assert.False(app.Find("[data-testid='note-send']").HasAttribute("disabled")));
+    }
+
+    [Fact]
+    public void A_file_over_the_cap_is_refused_with_its_size_and_the_limit()
+    {
+        using var host = ShellHost.Paired();
+        host.Picker.Next = AttachmentPick.Of([host.Picker.File("recording.pdf", "application/pdf", [], claimedSize: 30L * 1024 * 1024)]);
+
+        var app = OpenNote(host);
+        app.Find("[data-testid='note-choose-files']").Click();
+
+        app.WaitForAssertion(() => Assert.Equal(
+            "Too large: 30 MB, and the limit is 25 MB.",
+            app.Find("[data-testid='attachment-tile-refusal']").TextContent));
+        Assert.Equal(0, host.Picker.Reads);
+    }
+
+    [Fact]
+    public void A_speaker_with_a_space_is_asked_for_as_one_name()
+    {
+        using var host = ShellHost.Paired();
+
+        var app = OpenNote(host);
+        app.Find("[data-testid='note-title'] input").Input("Keynote");
+        app.Find("[data-testid='note-speaker'] input").Input("@Ada Lovelace");
+
+        app.WaitForAssertion(() => Assert.Contains("one name with no spaces", app.Markup, StringComparison.Ordinal));
+        Assert.True(app.Find("[data-testid='note-send']").HasAttribute("disabled"));
+    }
+
+    [Fact]
+    public void Saving_uploads_the_file_posts_the_capture_clears_the_fields_and_says_synced()
+    {
+        using var host = ShellHost.Paired();
+        host.Picker.Next = AttachmentPick.Of([host.Picker.Text("handout.pdf", "application/pdf", "%PDF-1.4 handout")]);
+
+        var app = OpenNote(host);
+        app.Find("[data-testid='note-choose-files']").Click();
+        app.WaitForAssertion(() => Assert.Single(app.FindAll("[data-testid='attachment-tile']")));
+
+        app.Find("[data-testid='note-send']").Click();
+
+        app.WaitForAssertion(() => Assert.Equal("synced", app.Find("[data-testid='note-status']").GetAttribute("data-status")));
+
+        var upload = Assert.Single(host.Inbox.Uploads);
+        var capture = Assert.Single(host.Inbox.Received);
+        Assert.Equal("handout.pdf", capture.Title);
+        Assert.Equal(upload.Id, Assert.Single(capture.Attachments!).Id);
+
+        Assert.Empty(app.FindAll("[data-testid='attachment-tile']"));
+        Assert.Equal(string.Empty, app.Find("[data-testid='note-title'] input").GetAttribute("value") ?? string.Empty);
+    }
+
+    [Fact]
+    public void A_note_saved_offline_is_in_the_inbox_list_marked_waiting()
+    {
+        var inbox = new ScriptedInboxService { State = InboxServiceState.Unreachable };
+        using var host = ShellHost.Paired(inbox);
+
+        var app = OpenNote(host);
+        app.Find("[data-testid='note-body'] textarea").Input("# Keynote\nOutbox before network.");
+        app.Find("[data-testid='note-send']").Click();
+
+        app.WaitForAssertion(() => Assert.Equal("waiting", app.Find("[data-testid='note-status']").GetAttribute("data-status")));
+        Assert.Equal(TalkNoteOutboxKind.Token, Assert.Single(host.Outbox.Entries).Kind);
+
+        host.Navigation.NavigateTo("");
+
+        app.WaitForAssertion(() =>
+        {
+            var row = app.Find("[data-testid='inbox-row']");
+            Assert.Equal("true", row.GetAttribute("data-waiting"));
+            Assert.Contains("Keynote", row.TextContent, StringComparison.Ordinal);
+        });
+    }
+
+    private static IRenderedComponent<Backlog.Mobile.UI.Components.Routes> OpenNote(ShellHost host)
+    {
+        var app = host.Open("note");
+        app.WaitForAssertion(() => Assert.NotNull(app.Find("[data-testid='note-send']")));
+        return app;
+    }
+}
diff --git a/tests/Backlog.Mobile.UI.UnitTests/TalkNoteTitleTests.cs b/tests/Backlog.Mobile.UI.UnitTests/TalkNoteTitleTests.cs
new file mode 100644
index 000000000..3f53393ee
--- /dev/null
+++ b/tests/Backlog.Mobile.UI.UnitTests/TalkNoteTitleTests.cs
@@ -0,0 +1,59 @@
+using Backlog.Mobile.UI.TalkNotes;
+
+namespace Backlog.Mobile.UI.UnitTests;
+
+/// <summary>
+/// The title a talk note arrives under when nobody typed one — the first body
+/// line, then "Photo · date", then the first file's name.
+/// </summary>
+public sealed class TalkNoteTitleTests
+{
+    private static readonly DateOnly Today = new(2026, 9, 26);
+
+    private static readonly (string, string)[] NoFiles = [];
+
+    [Fact]
+    public void A_typed_title_is_the_title()
+    {
+        Assert.Equal("Keynote", TalkNoteTitle.For("  Keynote ", "# Something else", NoFiles, Today));
+    }
+
+    [Fact]
+    public void Without_one_the_first_body_line_is_the_title_without_its_markdown()
+    {
+        var body = "\n\n## Offline-first sync is a UX decision\n- outbox before network";
+
+        Assert.Equal("Offline-first sync is a UX decision", TalkNoteTitle.For("", body, NoFiles, Today));
+    }
+
+    [Fact]
+    public void A_long_first_line_is_cut_with_an_ellipsis()
+    {
+        var title = TalkNoteTitle.For(null, new string('a', 500), NoFiles, Today);
+
+        Assert.Equal(TalkNoteTitle.MaximumFromBody, title.Length);
+        Assert.EndsWith("…", title, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void A_note_with_only_a_picture_is_a_photo_of_today()
+    {
+        var title = TalkNoteTitle.For(" ", " ", [("handout.pdf", "application/pdf"), ("IMG_0042.jpg", "image/jpeg")], Today);
+
+        Assert.Equal("Photo · 26 Sep 2026", title);
+    }
+
+    [Fact]
+    public void A_note_with_only_files_is_named_for_the_first()
+    {
+        var title = TalkNoteTitle.For(null, null, [("handout.pdf", "application/pdf"), ("slides.pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation")], Today);
+
+        Assert.Equal("handout.pdf", title);
+    }
+
+    [Fact]
+    public void An_empty_note_has_no_title()
+    {
+        Assert.Equal(string.Empty, TalkNoteTitle.For("", "  \n ", NoFiles, Today));
+    }
+}
diff --git a/tests/Backlog.Mobile.UI.UnitTests/TestAttachmentPicker.cs b/tests/Backlog.Mobile.UI.UnitTests/TestAttachmentPicker.cs
new file mode 100644
index 000000000..87ab07b4a
--- /dev/null
+++ b/tests/Backlog.Mobile.UI.UnitTests/TestAttachmentPicker.cs
@@ -0,0 +1,46 @@
+using System.Text;
+
+namespace Backlog.Mobile.UI.UnitTests;
+
+/// <summary>
+/// A picker whose next answer the test sets, counting the reads a file gets —
+/// which is how a test proves a refused file was never copied.
+/// </summary>
+internal sealed class TestAttachmentPicker : IAttachmentPicker
+{
+    public AttachmentPick Next { get; set; } = AttachmentPick.None;
+
+    public int Reads { get; private set; }
+
+    public ValueTask<bool> CanTakePhotoAsync(CancellationToken cancellationToken = default) => ValueTask.FromResult(true);
+
+    public Task<AttachmentPick> TakePhotoAsync(CancellationToken cancellationToken = default) => Task.FromResult(Next);
+
+    public Task<AttachmentPick> PickPicturesAsync(CancellationToken cancellationToken = default) => Task.FromResult(Next);
+
+    public Task<AttachmentPick> PickFilesAsync(CancellationToken cancellationToken = default) => Task.FromResult(Next);
+
+    /// <summary>A file with these bytes, as a picker would report it.</summary>
+    public PickedFile File(string name, string? contentType, byte[] bytes, long? claimedSize = null) =>
+        new(name, contentType, claimedSize ?? bytes.Length, _ =>
+        {
+            Reads++;
+            return Task.FromResult<Stream>(new MemoryStream(bytes));
+        });
+
+    public PickedFile Text(string name, string contentType, string text) =>
+        File(name, contentType, Encoding.UTF8.GetBytes(text));
+}
+
+/// <summary>A folder of its own under the temp directory, for one test's files.</summary>
+internal static class TestFolders
+{
+    public static string Create()
+    {
+        var path = Path.Combine(Path.GetTempPath(), "backlog-mobile-ui-tests", Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(path);
+        return path;
+    }
+
+    public static string Fixture(string name) => Path.Combine(AppContext.BaseDirectory, "Fixtures", name);
+}
diff --git a/tests/Backlog.UI.Components.UnitTests/AttachmentStripTests.cs b/tests/Backlog.UI.Components.UnitTests/AttachmentStripTests.cs
new file mode 100644
index 000000000..32f4c320b
--- /dev/null
+++ b/tests/Backlog.UI.Components.UnitTests/AttachmentStripTests.cs
@@ -0,0 +1,71 @@
+namespace Backlog.UI.Components.UnitTests;
+
+/// <summary>
+/// What a host is promised about the attachment strip: a tile per file with its
+/// name, type and size; a refusal drawn in words on its own tile; and a remove
+/// control only when the host can take a file back.
+/// </summary>
+public sealed class AttachmentStripTests
+{
+    private static readonly AttachmentTile Photo = new("photo", "IMG_0042.jpg", "JPEG image", "412 KB", IsPicture: true);
+
+    private static readonly AttachmentTile Refused = new("exe", "setup.exe", "application/x-msdownload", "2 MB",
+        Refusal: "Not a type cloud sync takes (.exe).");
+
+    [Fact]
+    public void Each_tile_shows_its_name_type_and_size()
+    {
+        using var context = new BunitContext();
+
+        var strip = context.Render<AttachmentStrip>(parameters => parameters.Add(s => s.Tiles, [Photo]));
+
+        var tile = strip.Find("[data-testid='attachment-tile']");
+        Assert.Equal("IMG_0042.jpg", tile.QuerySelector("[data-testid='attachment-tile-name']")!.TextContent);
+        Assert.Equal("JPEG image · 412 KB", tile.QuerySelector("[data-testid='attachment-tile-facts']")!.TextContent);
+        Assert.Equal("false", tile.GetAttribute("data-refused"));
+    }
+
+    [Fact]
+    public void A_refused_tile_says_why_in_words()
+    {
+        using var context = new BunitContext();
+
+        var strip = context.Render<AttachmentStrip>(parameters => parameters.Add(s => s.Tiles, [Photo, Refused]));
+
+        var tiles = strip.FindAll("[data-testid='attachment-tile']");
+        Assert.Equal("true", tiles[1].GetAttribute("data-refused"));
+        Assert.Contains("attachment-tile--refused", tiles[1].ClassList);
+        Assert.Equal("Not a type cloud sync takes (.exe).", tiles[1].QuerySelector("[data-testid='attachment-tile-refusal']")!.TextContent);
+        Assert.Null(tiles[0].QuerySelector("[data-testid='attachment-tile-refusal']"));
+    }
+
+    [Fact]
+    public void The_remove_control_is_named_for_its_file_and_hands_the_tile_back()
+    {
+        using var context = new BunitContext();
+        AttachmentTile? removed = null;
+
+        var strip = context.Render<AttachmentStrip>(parameters => parameters
+            .Add(s => s.Tiles, [Photo])
+            .Add(s => s.OnRemove, tile => removed = tile));
+
+        var remove = strip.Find("[data-testid='attachment-tile-remove']");
+        Assert.Equal("Remove IMG_0042.jpg", remove.GetAttribute("aria-label"));
+
+        remove.Click();
+
+        Assert.Equal(Photo, removed);
+    }
+
+    [Fact]
+    public void Without_a_remove_handler_the_strip_only_shows_and_empty_it_draws_nothing()
+    {
+        using var context = new BunitContext();
+
+        var readOnly = context.Render<AttachmentStrip>(parameters => parameters.Add(s => s.Tiles, [Photo]));
+        Assert.Empty(readOnly.FindAll("[data-testid='attachment-tile-remove']"));
+
+        var empty = context.Render<AttachmentStrip>(parameters => parameters.Add(s => s.Tiles, []));
+        Assert.Empty(empty.FindAll("ul"));
+    }
+}

From ad25a4770d974acfdfa949a79156733300b98308 Mon Sep 17 00:00:00 2001
From: JSdotNet <Job.Schepers@gmail.com>
Date: Sun, 27 Sep 2026 00:33:09 +0200
Subject: [PATCH 2/2] Drop two stray QA files and keep test fixtures byte-exact

The QA run wrote two scratch files at the repository root (a path that lost
its separators), and they rode along in the previous commit. The fixture PDF
and JPEG are byte-exact inputs, so they are marked binary: a Windows
checkout's line-ending conversion would otherwise move the PDF's xref offsets.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .gitattributes                         | 4 ++++
 .qa-workspacetalk-note-screenpage.html | 1 -
 .qa-workspacetalk-note-screentool.exe  | 1 -
 3 files changed, 4 insertions(+), 2 deletions(-)
 delete mode 100644 .qa-workspacetalk-note-screenpage.html
 delete mode 100644 .qa-workspacetalk-note-screentool.exe

diff --git a/.gitattributes b/.gitattributes
index 3f4d8b25c..753d113c9 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -19,3 +19,7 @@
 # instead of fixing a generator's phantom diff. The same goes for each knowledge
 # folder's authored `_reading-order.json`, which no generator writes.
 **/_archify/index.json text eol=lf
+
+# Test fixtures are byte-exact inputs: a PDF's xref offsets and a JPEG's EXIF
+# would break under line-ending conversion.
+tests/**/Fixtures/** binary
diff --git a/.qa-workspacetalk-note-screenpage.html b/.qa-workspacetalk-note-screenpage.html
deleted file mode 100644
index 0cfc83780..000000000
--- a/.qa-workspacetalk-note-screenpage.html
+++ /dev/null
@@ -1 +0,0 @@
-<html><body>not an attachment</body></html>
diff --git a/.qa-workspacetalk-note-screentool.exe b/.qa-workspacetalk-note-screentool.exe
deleted file mode 100644
index 6bee438f1..000000000
--- a/.qa-workspacetalk-note-screentool.exe
+++ /dev/null
@@ -1 +0,0 @@
-fake exe content