@micha.bigler/ui-core-micha 2.22.0 → 2.24.0

package/tests/messagingMsg6h.test.jsx

@@ -0,0 +1,136 @@
+// @vitest-environment jsdom
+import React from 'react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
+
+vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key, options) => options && Object.keys(options).length ? `${key}:${JSON.stringify(options)}` : key }) }));
+vi.mock('../src/notifications/realtime', () => ({ useRealtime: () => ({ subscribe: () => () => {}, onReconnect: () => () => {} }) }));
+
+import { AttachmentList } from '../src/messaging/AttachmentList';
+import { AuthContext } from '../src/auth/AuthContext';
+import { MessageBubble } from '../src/messaging/MessageBubble';
+import { MessagingProvider } from '../src/messaging/MessagingProvider';
+
+const imageAttachment = { id: 'att-1', filename: 'vacation-photo.jpg', content_type: 'image/jpeg' };
+const fileAttachment = { id: 'att-2', filename: 'Report.pdf', content_type: 'application/pdf' };
+const fallbackAttachment = { id: 'att-3', content_type: 'application/pdf' }; // no filename -- pre-MSG-12 dcm pin
+
+function makeApi(overrides = {}) {
+  return {
+    listConversations: vi.fn().mockResolvedValue({ results: [] }), listMessages: vi.fn().mockResolvedValue({ results: [] }),
+    getUnreadCount: vi.fn().mockResolvedValue({ unread_count: 0, by_conversation: {} }),
+    getAttachment: vi.fn().mockResolvedValue(new Blob(['full-bytes'], { type: 'image/jpeg' })),
+    getAttachmentThumbnail: vi.fn().mockResolvedValue(new Blob(['thumb-bytes'], { type: 'image/jpeg' })),
+    ...overrides,
+  };
+}
+
+afterEach(cleanup);
+
+describe('MSG-6h: attachment gallery (thumbnail/lightbox/right-click download)', () => {
+  it('1. an image attachment renders a thumbnail; clicking it opens a lightbox showing the full image', async () => {
+    const api = makeApi();
+    render(<MessagingProvider api={api} active={false}><AttachmentList attachments={[imageAttachment]} /></MessagingProvider>);
+    const thumbnail = await screen.findByLabelText(/MessagingAttachments\.PREVIEW/);
+    await waitFor(() => expect(api.getAttachmentThumbnail).toHaveBeenCalledWith('att-1'));
+
+    fireEvent.click(thumbnail);
+    await waitFor(() => expect(api.getAttachment).toHaveBeenCalledWith('att-1'));
+    const lightboxImage = await screen.findByAltText('vacation-photo.jpg');
+    expect(lightboxImage.tagName).toBe('IMG');
+  });
+
+  it('2. right-clicking an image attachment opens a context menu with Download; selecting it downloads', async () => {
+    const api = makeApi();
+    const clickSpy = vi.spyOn(HTMLAnchorElement.prototype, 'click').mockImplementation(() => {});
+    render(<MessagingProvider api={api} active={false}><AttachmentList attachments={[imageAttachment]} /></MessagingProvider>);
+    const thumbnail = await screen.findByLabelText(/MessagingAttachments\.PREVIEW/);
+
+    fireEvent.contextMenu(thumbnail);
+    const downloadItem = await screen.findByText('MessagingAttachments.DOWNLOAD_ACTION');
+    fireEvent.click(downloadItem);
+    await waitFor(() => expect(api.getAttachment).toHaveBeenCalledWith('att-1'));
+    expect(clickSpy).toHaveBeenCalled();
+    clickSpy.mockRestore();
+  });
+
+  it('3. a non-image attachment renders a file indicator, not a broken image; clicking it downloads directly', async () => {
+    const api = makeApi();
+    const clickSpy = vi.spyOn(HTMLAnchorElement.prototype, 'click').mockImplementation(() => {});
+    render(<MessagingProvider api={api} active={false}><AttachmentList attachments={[fileAttachment]} /></MessagingProvider>);
+    const target = screen.getByLabelText('MessagingAttachments.DOWNLOAD:{"name":"Report.pdf"}');
+    expect(target.querySelector('img')).toBeNull();
+    expect(screen.getByText('Report.pdf')).toBeTruthy();
+
+    fireEvent.click(target);
+    await waitFor(() => expect(api.getAttachment).toHaveBeenCalledWith('att-2'));
+    expect(clickSpy).toHaveBeenCalled();
+    clickSpy.mockRestore();
+    // No lightbox for a non-image -- nothing to preview.
+    expect(screen.queryByRole('dialog')).toBeNull();
+  });
+
+  it('4. nameOf prefers attachment.filename when present, falls back to attachment.id when absent (pre-MSG-12 dcm interop)', () => {
+    render(<MessagingProvider api={makeApi()} active={false}><AttachmentList attachments={[fileAttachment, fallbackAttachment]} /></MessagingProvider>);
+    expect(screen.getByText('Report.pdf')).toBeTruthy();
+    expect(screen.getByText('att-3')).toBeTruthy();
+  });
+
+  it('6. the lightbox itself has a Download action -- reachable without a right-click, closing an accessibility regression (touch/keyboard users could not download an image otherwise)', async () => {
+    const api = makeApi();
+    const clickSpy = vi.spyOn(HTMLAnchorElement.prototype, 'click').mockImplementation(() => {});
+    render(<MessagingProvider api={api} active={false}><AttachmentList attachments={[imageAttachment]} /></MessagingProvider>);
+    const thumbnail = await screen.findByLabelText(/MessagingAttachments\.PREVIEW/);
+    fireEvent.click(thumbnail);
+    await screen.findByAltText('vacation-photo.jpg');
+    api.getAttachment.mockClear();
+
+    const downloadButton = screen.getByLabelText('MessagingAttachments.DOWNLOAD_ACTION');
+    fireEvent.click(downloadButton);
+    await waitFor(() => expect(api.getAttachment).toHaveBeenCalledWith('att-1'));
+    expect(clickSpy).toHaveBeenCalled();
+    clickSpy.mockRestore();
+  });
+
+  it('7. the lightbox shows a loading state while the full image fetches, and an error state if the fetch fails', async () => {
+    let resolveFetch;
+    const api = makeApi({ getAttachment: vi.fn(() => new Promise((resolve) => { resolveFetch = resolve; })) });
+    render(<MessagingProvider api={api} active={false}><AttachmentList attachments={[imageAttachment]} /></MessagingProvider>);
+    const thumbnail = await screen.findByLabelText(/MessagingAttachments\.PREVIEW/);
+
+    fireEvent.click(thumbnail);
+    await screen.findByLabelText('MessagingAttachments.LOADING_PREVIEW');
+    expect(screen.queryByAltText('vacation-photo.jpg')).toBeNull();
+
+    resolveFetch(new Blob(['bytes'], { type: 'image/jpeg' }));
+    await screen.findByAltText('vacation-photo.jpg');
+    expect(screen.queryByLabelText('MessagingAttachments.LOADING_PREVIEW')).toBeNull();
+  });
+
+  it('8. a failed full-image fetch shows a visible error, not a silent no-op', async () => {
+    const api = makeApi({ getAttachment: vi.fn().mockRejectedValue(new Error('network error')) });
+    render(<MessagingProvider api={api} active={false}><AttachmentList attachments={[imageAttachment]} /></MessagingProvider>);
+    const thumbnail = await screen.findByLabelText(/MessagingAttachments\.PREVIEW/);
+
+    fireEvent.click(thumbnail);
+    await screen.findByRole('alert');
+    expect(screen.getByRole('alert').textContent).toBe('MessagingAttachments.PREVIEW_ERROR');
+  });
+
+  it('5. the attachment context menu does not also trigger the message-level action menu', async () => {
+    const api = makeApi();
+    render(
+      <AuthContext.Provider value={{ user: { id: 1 } }}>
+        <MessagingProvider api={api} active={false}>
+          <MessageBubble message={{ id: 'm1', body: 'see attached', sender: { id: 1 }, attachments: [imageAttachment] }} conversation={{ kind: 'group' }} canModerateMessages />
+        </MessagingProvider>
+      </AuthContext.Provider>,
+    );
+    const thumbnail = await screen.findByLabelText(/MessagingAttachments\.PREVIEW/);
+
+    fireEvent.contextMenu(thumbnail);
+    await screen.findByText('MessagingAttachments.DOWNLOAD_ACTION');
+    // The message-level menu's own items (e.g. Reply) must not also be open.
+    expect(screen.queryByText('MessagingThread.REPLY')).toBeNull();
+  });
+});

package/tests/messagingPollRendering.test.jsx

@@ -3,7 +3,7 @@ import React from 'react';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
 
-vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key, options) => options?.message ? `${key}:${options.message}` : key }) }));
+vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key, options) => options && Object.keys(options).length ? `${key}:${JSON.stringify(options)}` : key }) }));
 
 const realtimeSubscribers = new Map();
 vi.mock('../src/notifications/realtime', () => ({
@@ -55,20 +55,29 @@ function ConnectedPollCard({ messageId }) {
 afterEach(() => { cleanup(); realtimeSubscribers.clear(); });
 
 describe('poll rendering against the real server contract', () => {
-  it('renders question, options, vote counts and per-option voters from a server-shaped payload', () => {
+  it('renders question, options and proportional vote counts from a server-shaped payload', () => {
+    // totalVotes = 2 + 1 = 3 -> Library 67%, Cafe 33%.
     render(<MessagingProvider api={baseApi()} active={false}><PollCard message={{ id: 'msg-1', poll: serverPoll() }} /></MessagingProvider>);
     expect(screen.getByText('Where should we meet?')).toBeTruthy();
-    expect(screen.getByText(/Library \(2\)/)).toBeTruthy();
-    expect(screen.getByText(/Cafe \(1\)/)).toBeTruthy();
+    expect(screen.getByText('Library')).toBeTruthy();
+    expect(screen.getByText(/MessagingPoll\.OPTION_RESULT.*"count":2.*"percent":67/)).toBeTruthy();
+    expect(screen.getByText('Cafe')).toBeTruthy();
+    expect(screen.getByText(/MessagingPoll\.OPTION_RESULT.*"count":1.*"percent":33/)).toBeTruthy();
   });
 
   it('derives selection from voted_option_ids (REST-only) and marks the viewer\'s own vote', () => {
+    // Single-choice (allow_multiple: false) renders radios, not checkboxes --
+    // native radio semantics match the WO's "tapping a different option moves
+    // the vote, tapping the same one is a no-op" design directly.
     const poll = serverPoll({ voted_option_ids: ['opt-a'] });
     render(<MessagingProvider api={baseApi()} active={false}><PollCard message={{ id: 'msg-1', poll }} /></MessagingProvider>);
-    const checkboxes = screen.getAllByRole('checkbox');
-    expect(checkboxes[0].checked).toBe(true);
-    expect(checkboxes[1].checked).toBe(false);
-    expect(screen.getByText(/Library.*MessagingPoll\.YOU_VOTED/)).toBeTruthy();
+    const radios = screen.getAllByRole('radio');
+    expect(radios[0].checked).toBe(true);
+    expect(radios[1].checked).toBe(false);
+    // Count/percent and the viewer's own vote both live in the accessible
+    // name, not conveyed by the bar's width alone (WO accessibility risk).
+    expect(radios[0].getAttribute('aria-label')).toMatch(/Library.*MessagingPoll\.OPTION_RESULT.*MessagingPoll\.YOU_VOTED/);
+    expect(radios[1].getAttribute('aria-label')).not.toMatch(/YOU_VOTED/);
   });
 
   it('does not clear or invert the viewer\'s own vote when a poll_updated frame carries no voted_option_ids', async () => {
@@ -80,7 +89,7 @@ describe('poll rendering against the real server contract', () => {
     // own castPollVote reconciliation would leave it — not a static prop the
     // component can never observe a later frame update against.
     dispatchMessagingFrame({ envelope: 'messaging', type: 'message', event_id: 'seed', conversation_id: 'conv-1', message: { id: 'msg-1', conversation_id: 'conv-1', kind: 'poll', poll: votedPoll } });
-    await waitFor(() => expect(screen.getAllByRole('checkbox')[0].checked).toBe(true));
+    await waitFor(() => expect(screen.getAllByRole('radio')[0].checked).toBe(true));
     // The real poll_updated frame shape: payload.poll is a bare serialize_poll
     // result (verified against services.py's _poll_updated_payload) — never
     // carries voted_option_ids. A vote_count bump from another viewer must
@@ -89,10 +98,10 @@ describe('poll rendering against the real server contract', () => {
       envelope: 'messaging', type: 'poll_updated', event_id: 'evt-1', conversation_id: 'conv-1', message_id: 'msg-1', poll_id: 'poll-1',
       poll: { ...serverPoll(), options: [{ id: 'opt-a', text: 'Library', order: 0, vote_count: 3, voters: ['user-1', 'user-2', 'user-4'] }, { id: 'opt-b', text: 'Cafe', order: 1, vote_count: 1, voters: ['user-3'] }] },
     });
-    await waitFor(() => expect(screen.getByText(/Library \(3\)/)).toBeTruthy());
+    await waitFor(() => expect(screen.getByText(/MessagingPoll\.OPTION_RESULT.*"count":3/)).toBeTruthy());
     // The frame carries no voted_option_ids at all — the viewer's REST-known
     // vote must be carried forward, not wiped, by this update.
-    expect(screen.getAllByRole('checkbox')[0].checked).toBe(true);
+    expect(screen.getAllByRole('radio')[0].checked).toBe(true);
   });
 
   it('grants close only to the poll creator (created_by_id) or a host override, never a guess from an object shape', () => {
@@ -105,11 +114,12 @@ describe('poll rendering against the real server contract', () => {
     expect(screen.getByRole('button', { name: 'MessagingPoll.CLOSE' })).toBeTruthy();
   });
 
-  it('disables voting once the poll is closed', () => {
+  it('disables voting once the poll is closed and shows a closed indicator, not merely a missing button', () => {
+    // With no separate submit button (MSG-6g), "closed" can no longer be
+    // inferred from its absence -- must be an explicit, visible indicator.
     const poll = serverPoll({ closed_at: '2026-07-31T10:00:00Z' });
     render(<MessagingProvider api={baseApi()} active={false}><PollCard message={{ id: 'msg-1', poll }} /></MessagingProvider>);
-    screen.getAllByRole('checkbox').forEach((checkbox) => expect(checkbox.disabled).toBe(true));
-    expect(screen.getByRole('button', { name: 'MessagingPoll.VOTE' }).disabled).toBe(true);
+    screen.getAllByRole('radio').forEach((radio) => expect(radio.disabled).toBe(true));
     expect(screen.getByText('MessagingPoll.CLOSED')).toBeTruthy();
   });
 });

package/work-orders/MSG-6g.md

@@ -0,0 +1,244 @@
+# WORK ORDER MSG-6g (ui-core-micha) — poll UI: tap-to-vote with result bars, no separate vote button
+
+**EXECUTION DIRECTIVE.** If you are the implementer reading this as your own spec, this section is not
+addressed to you — it tells the Orchestrator how to invoke you; you ARE that invocation, do not shell
+out to `codex exec`. Orchestrator: implement through `codex exec` in the background, invoked **directly
+via Bash** (never the `debugger`/`*_coder` Agent wrappers) with **both** flags `--skip-git-repo-check`
+and `--dangerously-bypass-approvals-and-sandbox`, prompt passed as a positional argument from this
+file. Fall back to direct Claude implementation only on Codex quota / rate-limit / non-zero exit.
+
+Feature-level WO (Expertenchat envelope). Operator request 2026-08-03: *"bei der Abstimmung wäre es
+schön, wenn es ähnlicher wie WhatsApp mit dem Balken sowie ohne Abstimmungsbutton möglich wäre."*
+
+This is a **UX improvement, not a defect** — the current poll works. It is scoped separately so it never
+blocks the messaging defect WOs.
+
+## TIER
+Tier 2 — shared-core UI consumed by every app. Independent `reviewer` + `ui_reviewer` mandatory.
+
+## CURRENT STATE
+
+`PollCard.jsx` renders each option as a MUI `FormControlLabel` with a `Checkbox` (multi-select) or radio,
+labelled `"<text> (<vote_count>)"`, plus a separate **"Abstimmen"** submit button and a
+**"Umfrage schliessen"** action for the owner. Voting is therefore a two-step interaction — select, then
+submit — and the result is a bare number in parentheses.
+
+## GOAL
+
+Voting is one tap on the option itself, and the distribution is readable at a glance from proportional
+bars rather than parenthesised counts.
+
+## SCOPE
+
+**A. Tap-to-vote — remove the separate submit button.**
+
+- **Single-choice poll** (`allow_multiple: false`): tapping an option casts the vote immediately.
+  Tapping a different option moves the vote. The "Abstimmen" button goes away entirely.
+- **Multi-select poll** (`allow_multiple: true`): tapping an option toggles that option immediately —
+  each tap is its own vote update, not a batched submit. **Confirm dcm's vote endpoint accepts the full
+  option-id set per call** (it takes `option_ids`, so a toggle sends the new complete set, not a delta);
+  if it does not, stop and report rather than inventing a delta protocol.
+- Every tap is an optimistic UI update reconciled against the server response, following the pattern
+  `MessagingProvider` already uses for sends. **A failed vote must visibly revert** — a silently
+  swallowed failure that leaves the bar showing a vote nobody recorded is worse than the current
+  two-step flow.
+- Keep "Umfrage schliessen" — that is an owner action, not part of voting.
+
+**B. Result bars.**
+
+- Each option shows a horizontal proportional bar plus its count and percentage, in place of the
+  `(<n>)` suffix.
+- The viewer's own choice(s) are visually marked. `voted_option_ids` already exists for this and is
+  carried in the REST vote/create/close response — note the standing constraint documented in
+  `MessagingProvider.jsx`: it is **viewer-specific and never present on a `poll_updated` frame**, so
+  frame handling must not wipe a locally-known selection. Do not regress that; it was a deliberate fix.
+- Denominator: total votes cast, not participant count. A poll's turnout relative to group size is a
+  different question and is **not** in scope.
+- Percentages must not mislead at zero votes — define and implement the zero-vote rendering explicitly
+  rather than letting a division produce `NaN`.
+
+**C. Closed polls.** A closed poll shows final bars and is not interactive. Verify the closed state is
+visually unmistakable — with the submit button gone, "closed" can no longer be inferred from a missing
+button.
+
+## NON-GOALS / DO NOT TOUCH
+- No backend change. If a scope-A requirement appears to need one, stop and report — that is a dcm WO.
+- Do not change `voted_option_ids` handling in `applyFrame` beyond what B needs to read it (see the
+  merge-trap note above).
+- Do not add a "who voted for what" disclosure. Per-voter visibility is a privacy decision nobody has
+  taken, and the existing `voters` data in `serialize_poll` is not licence to surface it.
+- Do not change poll creation (`Composer`'s dialog) — this WO is the display and voting surface only.
+- Do not touch `ReadTicks`, conversation titles, or anything in the MSG-6f scope.
+
+## RISKS
+- **Tap-to-vote removes the "are you sure" step.** On a phone a mis-tap now votes. Mitigate by making
+  the vote reversible (tap again / tap another) and by ensuring the optimistic state is obviously
+  distinct from the confirmed state; do not add a confirmation dialog, which would reinstate the
+  two-step flow this WO removes.
+- Rapid successive taps race. The last write must win deterministically — state how (request ordering,
+  or discard stale responses by comparing against the latest local intent).
+- Accessibility: an option becomes an interactive control with a name, a pressed/checked state and
+  keyboard operability. Bars are decorative; the count and percentage must be in the accessible name or
+  adjacent text, not conveyed by width alone. `ui_reviewer` should check this specifically.
+- Every host app inherits the new interaction — a visible behaviour change beyond jg-ferien.
+
+## REQUIRED TESTS TO WRITE
+Narrow and behavioural. Do NOT run the full suite.
+
+1. Single-choice: tapping an option votes without any further interaction; tapping a second option
+   moves the vote (the first is no longer selected, the counts reflect it).
+2. Multi-select: tapping toggles one option on and off, and each tap sends the complete option-id set.
+3. A rejected vote reverts the optimistic state and surfaces an error — assert the bar returns to its
+   prior value, not merely that an error appeared.
+4. Bars render proportionally, including the **zero-vote** case, with no `NaN` and no division error.
+5. The viewer's own selection survives a `poll_updated` frame that does not carry `voted_option_ids`
+   (the documented merge trap — this must not regress).
+6. A closed poll is non-interactive: tapping an option does nothing and issues no request.
+
+**Non-vacuity:** test 5 must fail if the merge-trap guard is removed. Test 3 must assert the reverted
+value, not the presence of an error message.
+
+## TEST SCOPE FOR THE GATE (orchestrator)
+`PollCard` and its neighbours in the messaging test files. Not the full suite.
+
+## TARGET REPO
+`C:\Users\biglmi\Documents\webapps\ui-core-micha`. Branch `main` (or `develop` if present). Publish per
+the repo's release flow; the consuming pin bump is a separate step.
+
+## MINI-HANDOVER (pastable)
+
+> Repo: `C:\Users\biglmi\Documents\webapps\ui-core-micha` (branch `main`, or `develop` if present).
+> Work order: `work-orders/MSG-6g.md` — read it fully, then follow the `orchestrate-codex` skill.
+>
+> **UX improvement, not a defect — this blocks nothing and is blocked by nothing.** Do not let it hold
+> up the messaging defect WOs (dcm MSG-10, ucm MSG-6f).
+>
+> Frontend only: no backend change is in scope. If tap-to-vote appears to need one, stop and report.
+> Two things that are easy to break and are called out in the WO: a failed vote must visibly revert
+> (not fail silently), and the viewer's `voted_option_ids` must survive a `poll_updated` frame that
+> does not carry it — that merge-trap guard was a deliberate earlier fix and test 5 pins it.
+
+## PROGRESS CONTRACT
+Emit `PLAN: <steps>` up front, then a single-line `PROGRESS: [<n>/<total>] <action>` before every
+relevant action and `PROGRESS: [<n>/<total>] done` on completion, spaced so no gap exceeds ~2 min,
+stdout unbuffered, and exactly one final `RESULT: DONE|BLOCKED <reason>`.
+
+---
+
+## Part B — Implementation map (Orchestrator) / as-built record
+
+**Codex was unavailable (out of credits) — implemented directly by the Orchestrator.**
+
+### Blocker found and resolved before implementation
+
+Line 38-40's own contingency ("confirm dcm's vote endpoint accepts the full option-id set
+per call... if it does not, stop and report") fired for real: `vote_poll` (dcm
+`services.py:247-259`) only cleared prior votes for single-choice polls; multi-select only
+ever `bulk_create`d, so a smaller `option_ids` set never retracted an omitted vote —
+untoggling was silently a no-op. Reported to the operator, who confirmed fixing it
+directly in dcm rather than working around it client-side. Fixed and published as dcm
+`2.40.1` — see dcm `work-orders/MSG-11.md`. `option_ids` is now authoritative (delete
+anything no longer in the set, then re-create the requested set) for both poll kinds.
+
+### Files changed
+
+- `src/messaging/MessagingProvider.jsx`:
+  - New module-level `applyOptimisticVote(poll, previousSelectedIds, nextSelectedIds, userId)`
+    — adjusts only the options whose membership in the vote actually changed (count +/-1,
+    `voters` array +/- the acting user), leaves everything else untouched.
+  - New `pollVoteTokensRef` (per-poll "latest tap wins" token) alongside the existing
+    `activeIdRef`/`seenEventsRef`/`filtersRef`.
+  - `castPollVote(messageId, poll, optionIds)` rewritten: captures `previousPoll` from
+    `cache.messages[messageId].poll` (falling back to the `poll` param), patches the
+    optimistic projection into the cache immediately (same `patchMessage` shape
+    `toggleReaction` already uses), then on success reconciles with the server's poll, on
+    failure reverts to `previousPoll` — both guarded by the token so a stale response from
+    a since-superseded tap can't stomp a newer one.
+- `src/messaging/PollCard.jsx`: full rewrite.
+  - Single-choice (`allow_multiple: false`) → `Radio` per option (native "tap a different
+    option moves the vote, tap the same one is a no-op" semantics — matches the WO's
+    stated design directly, no extra toggle-off logic needed).
+  - Multi-select → `Checkbox` per option (existing toggle semantics preserved).
+  - Whole-option-row tap target (`Box onClick`, `stopPropagation` on the control's own
+    `onClick` to avoid a double-fire) — WhatsApp-style, matches the operator's own framing.
+  - `LinearProgress` bar + `{{count}} ({{percent}}%)` (`MessagingPoll.OPTION_RESULT`, new
+    key) next to each option; `percent = totalVotes > 0 ? round(count/totalVotes*100) : 0`
+    — never `NaN`.
+  - Accessible name (`aria-label` on the control) carries option text + result text +
+    "you voted" — never width-only.
+  - Closed state: `Chip` with a lock icon + `MessagingPoll.CLOSED`, replacing the old
+    caption-only text (now the *only* closed signal, since the submit button is gone).
+  - Local `selected` state + a `voteTokenRef` mirror the provider's own token guard, since
+    `PollCard` is a "dumb" prop-driven component (documented in
+    `tests/messagingPollRendering.test.jsx`) — a rejected vote must revert visibly even
+    when the host never re-passes a fresh `message` prop from its own cache.
+  - Removed: the "Abstimmen" submit button and its `SELECT_OPTION` validation entirely.
+- `src/i18n/messagingTranslations.ts`: removed now-orphaned `MessagingPoll.VOTE` and
+  `MessagingPoll.SELECT_OPTION`; added `MessagingPoll.OPTION_RESULT`.
+
+### Tests
+
+- `tests/messagingMsg6g.test.jsx` (new) — the 6 WO-required cases verbatim.
+- `tests/messagingPollRendering.test.jsx` — updated for radio (not checkbox) on
+  single-choice, the new label/aria-label shape, and the closed-chip instead of a
+  disabled button; its `t` mock upgraded to interpolate `{{count}}`/`{{percent}}` (was
+  bare-key-only, insufficient to assert rendered numbers).
+  `tests/messagingInteractions.test.jsx`'s poll test rewritten for tap-to-vote (no submit
+  click). `tests/messagingCompactBubble.test.jsx`'s poll smoke test needed no change
+  (empty `options: []`, no control interaction).
+
+### Verification
+Full suite 234 → 240, `tsc` clean (pre-review).
+
+### Independent review: `reviewer` + `ui_reviewer`, both mandatory (author = Orchestrator, not Codex)
+
+**`reviewer` — 3 findings, all fixed:**
+- **R1 (P1, real bug):** `castPollVote`'s optimistic count projection was built from the
+  caller-supplied `poll` argument, not from `previousPoll` (the value already freshly read
+  from `cache.messages[messageId].poll` two lines above, and correctly used as the revert
+  target on failure). For a second rapid tap (e.g. switching a single-choice vote A→B)
+  where the caller's `poll` reference hadn't yet been refreshed — exactly how `PollCard`
+  is documented to behave, a "dumb" prop-driven component — the count math computed
+  against the stale pre-first-tap baseline, landing a silently wrong transient
+  `vote_count` in the **shared cache** (not just local render state) until the server's
+  response eventually reconciled it away. Fixed: project from `previousPoll`. Verified
+  non-vacuous: reverted the fix, confirmed the new regression test below fails with the
+  exact predicted wrong number (4 instead of 5), then restored it.
+- **R2 (P2, coverage gap):** no test asserted vote-count values across a multi-tap
+  sequence with non-zero starting counts — the zero-vote fixtures used elsewhere
+  happened to mask R1 via the `Math.max(0, ...)` clamp. Closed by a new
+  `messagingMsg6g.test.jsx` case using non-zero seed counts (5/2) and a genuinely
+  cache-connected reader alongside a *statically-propped* `PollCard` (the scenario that
+  actually reproduces the staleness, per R1's own trace — a cache-connected `PollCard`
+  re-renders with a fresh `poll` prop between taps and would not have caught this).
+- **R3 (P3):** `applyOptimisticVote` could push a literal `undefined` into an option's
+  `voters` array when `user?.id` is momentarily unset (`AuthContext` not yet populated).
+  Fixed with a `userId != null` guard.
+
+**`ui_reviewer` — 2 findings, both fixed:**
+- **U1 (P2):** no visual distinction between an in-flight optimistic vote and a
+  server-confirmed one, contradicting the WO's own risk-mitigation requirement. Fixed by
+  reusing `ReactionBar.jsx`'s established `pending` Set convention — dims the tapped
+  option's bar/text while its request is in flight, but (unlike `ReactionBar`) does
+  **not** disable the control, since the WO explicitly requires rapid re-taps to remain
+  possible and race deterministically (last-write-wins via the token guard), not be
+  blocked.
+- **U2 (P2):** single-choice rendered bare, ungrouped `Radio` controls — no `RadioGroup`,
+  no shared `name`. Diverged from this repo's own established radio idiom
+  (`AuthFactorRequirementCard.jsx`'s `RadioGroup` + `FormControlLabel`) and lost native
+  arrow-key navigation between options plus the screen-reader group announcement. Fixed
+  by wrapping single-choice options in a real `RadioGroup`; multi-select's `Checkbox`
+  options are unaffected (no equivalent ARIA grouping concept applies). Switching to
+  `FormControlLabel` for both control types also let the manual `Box onClick` +
+  `stopPropagation()` whole-row-tap hack be removed entirely — `FormControlLabel`'s own
+  `<label>` wrapping already makes the whole row natively clickable.
+- Found and fixed while addressing U2, not itself a reviewer finding: `RadioGroup`'s own
+  `onChange` only ever hands back `event.target.value`, a DOM string, which would coerce
+  a non-string option id (dcm's are UUID strings today, but the type isn't a guaranteed
+  contract) — caught by `tests/messagingInteractions.test.jsx`'s existing numeric-id
+  fixture failing after the `RadioGroup` change. Fixed by keeping each `Radio`'s own
+  `onChange` (closure-typed, matching the `Checkbox` branch) instead of relying on the
+  group-level handler.
+
+Re-verified after all fixes: full suite 234 → **241** (7 new: 6 WO-required cases +
+1 R1/R2 regression), `tsc` clean.