@micha.bigler/ui-core-micha 2.17.0 → 2.18.0

package/WORK_ORDERS.md

@@ -30,4 +30,5 @@ prefixed ID; never reuse a bare flat number across workstreams.
 | NOTIF-12 | Popup channel via the wizard renderer | Make `popup` a real delivery channel: extract the presentational dialog shell out of `OnboardingWizard`, render popup-eligible notifications through it, and record seen/dismissed on `NotificationRecipient` (design D-F7: renderer reuse only, NOT the onboarding progress store); dcm `PopupDispatcher` stops being a logging stub. Full spec: [work-orders/NOTIF-12.md](work-orders/NOTIF-12.md). | 2026-07-29 | done | ucm: c8e222f, d7bdcbe; dcm: django-core-micha 1612429, 82fd89f | Tier 2 (extracts a renderer cockpit+jg run in production; the roadmap label "uncritical" is about urgency, not blast radius). **HARD GATE: starts only after NOTIF-13 landed + published** — consumes its envelope contract and `subscribe()`, and edits the same ucm files (AGENTS.md overlap rule). **SHIPS WITH ZERO PRODUCERS, deliberately** (operator decision 2026-07-29, made with the evidence): no notification type declares `popup` in `eligible_channels` anywhere in dcm/jg/cockpit/hram/spesix/survey_app, so the channel is wired but inactive until an app opts a type in. WO therefore requires (a) CHANGELOG wording that does not overclaim (NOTIF-4 R1 precedent) and (b) a test-local producer type proving the path end-to-end, so it is not untested dead code. Was NOTIF-11 (renumbered 2026-07-29 for the jg cutover/drop split). **Gate satisfied 2026-07-30** (ucm 2.13.0 / dcm 2.33.0); WO re-verified against the landed NOTIF-13 code and corrected in `345631d`: NOTIF-13 shipped the envelope as a **domain**-level discriminator, so a popup payload built the same way as a chip payload would be indistinguishable from it - the WO now mandates a `channel` field inside the envelope (never a second envelope value) plus feed de-duplication by `notification_id`, without which chip+popup double-counts the unread badge. **Codex failed twice with the same genuine CLI/model-version error as NOTIF-13** (`gpt-5.6-terra requires a newer version of Codex`) — orchestrator implemented directly in Claude per the Codex→Claude fallback rule, both scopes. Independent `reviewer` (background agent, `fork_context=false`, full diff of both repos): found R1 (P1, real bug — the WS payload only carried `notification_id`, but `feed/mark/` resolves ids against `NotificationRecipient.pk`; every `markSeen`/`markDismissed` from a session-live-only popup would either no-op or corrupt an unrelated recipient row once a producer opts in — fixed by adding `recipient_id` to both `ChipDispatcher` and `PopupDispatcher` payloads, dcm-side, with regression tests), R2 (P2 — the reused dialog shell always showed the onboarding "Setup"/step-counter header even for a popup, a real mislabeling once any producer exists — fixed via an optional `title` override on `WizardDialogShell`, defaulting to the prior exact text so `OnboardingWizard` stays bit-for-bit unchanged; popup now shows its own notification title), R3 (P2 — coexistence only gated on a *blocking* onboarding step, so a non-blocking step (e.g. `browser_push`) and a popup could stack two simultaneous MUI dialogs — fixed by broadening the gate to any active onboarding step, with a new regression test). All three fixed and re-verified: ucm 88/88 vitest + `pnpm`/tsc build clean, dcm 95/95 pytest (notifications package). Published (once pushed): ucm 2.14.0 (npm, CI-gated on push to `main`), dcm 2.34.0 (PyPI, same). No app pin bumps in this WO per spec. Own orchestrator security/exposure pass in parallel with the reviewer: no findings (content rendering follows the existing `NotificationBell` i18n-interpolation pattern, no new WS consumer, `prefs.py`/`router.py`/`resolve_channels` untouched). |
 | DX-1 | Minimal Vite dev harness for ucm components | Give ucm a way to **render** its components during development: a `dev` script starting a Vite dev page that mounts surfaces with the repo's MUI theme, i18n and router context, driven by fixtures through an injectable mock API/realtime adapter, with light/dark and viewport switching. Harness code stays out of the published package (not exported, excluded from the build, zero runtime deps). | 2026-07-31 | done | 7ea7b26 | New `DX-*` prefix (ucm-local). Envelope: [work-orders/DX-1.md](work-orders/DX-1.md). Tier 1, but **adds devDependencies → approval-gated**; operator approval granted 2026-07-31 as part of the MSG-3 scoping decision. Gap found while scoping MSG-3: `package.json` had only `build` (tsc) and `test` (vitest) — no Storybook, no demo, no dev page, so every ucm surface ever shipped (auth, onboarding, notifications, charts) was verified only in jsdom or after a consuming app pinned it. Storybook deliberately not chosen (config surface vs. a repo with no story-writing habit). **Runs before MSG-3**, which is ~3700 LOC of UI with no consumer until MSG-5 and an operator-granted redesign licence that is only iterable if the result can be looked at. No version bump, no publish (dev-only). **Implemented (Codex, one pass):** `pnpm dev` (`vite`) boots a harness (`dev/main.jsx`) with MUI theme/i18n/router, light/dark + mobile/tablet/desktop switching, entries for a notifications surface (`NotificationBell`) and a standalone chart (`BarChart`, proving single-component mounting), plus a dedicated realtime-adapter demo entry. Mock transport (`dev/mockTransport.jsx`) overrides `apiClient`'s axios adapter for REST and provides a `RealtimeContext.Provider` for context-consuming components. Independent `reviewer`: one P2 — `NotificationsProvider` opens its own WebSocket internally rather than reading one from context, so the notifications entry opened a real, always-failing socket; fixed by the orchestrator with a `MockWebSocket` class registered as `window.WebSocket` while the harness is mounted, covering both consumption paths. Verified in the browser (both entries, dispatch button, no console errors/WS connection attempts). Build clean, `dist/` unaffected, `dependencies`/`peerDependencies` untouched (only `devDependencies` + `scripts.dev`), 104/104 tests green. |
 | MSG-3 | ucm messaging surfaces (full parity) | `MessagingProvider` + API adapter + normalized cache, `ConversationList`/`Thread`/`Composer`/`ReadTicks`/`ReactionBar`/`PollCard`/`AttachmentList` + config/preferences and launchers, on the Layer-1 transport (`subscribe('messaging', …)`, `event_id` dedup, reconnect refetch); opaque-cursor pagination with reverse infinite scroll and optimistic send from day one; de/en/fr. Host apps supply routing/display/scope pickers, not a forked state machine. | 2026-07-31 | done | affa5ac, 5e87315, a12c9c6, c7100b1, 95b69d4, 974e24c, 4369400 | ucm-side mirror of the canonical dcm `MSG-3` row. Envelope: [work-orders/MSG-3.md](work-orders/MSG-3.md). Tier 2, 5 proposed chunks (register's "3-5" treated as a floor — jg's parity target is ~3700 LOC excluding tests, `Thread.jsx` alone 2470). Two operator decisions 2026-07-31: (1) **redesign permitted** for layout/composition/interaction, but the design's "No jg feature is lost" stays binding and the WO must ship a written **deviation list** — consequence: MSG-5 becomes a visible change for jg users and needs its own UX review; (2) validation runs through the **DX-1** harness, which is therefore a precondition. Carries `ui_reviewer` at WO end in addition to the per-chunk independent `reviewer`. **Decomposition is a binding requirement, not a preference:** jg's UI is one 2470-LOC component with a 2173-LOC test file, and reproducing that shape is a scope violation even with every feature present — each named component is separately exported, independently mountable and independently testable, state lives in the provider rather than being prop-drilled through `Thread`, every component gets its own DX-1 harness entry (the forcing function — a monolith cannot be mounted piecewise), and any component file above ~400 LOC must be justified in that chunk's review. Depends on dcm 2.36.1 (MSG-2 + MSG-2b). **All 5 chunks implemented, independently reviewed and committed** (chunk 1: additive Layer-1 `onReconnect` extension per operator decision, provider/cache/transport; chunk 2: conversation list + launchers, R1 menu-anchor fix, R2 per-kind icon, R3 broadcast-launcher visibility; chunk 3: Thread/MessageBubble/ReadTicks, R1 N+1 ReadTicks gating fix; chunk 4: Composer/attachments, R1 `extractApiErrorMessage` for dcm's `{files:[...]}` shape, R2 optimistic sender, R3 own-message pending-ReadTicks fix, R4 i18n diacritics; chunk 5: reactions/polls/scope-config/announcements, R1-R4 + a follow-up verification pass V1-V3 including building jg's previously-missing `AnnouncementDialog` parity per explicit operator decision). **WO-end `ui_reviewer`** (independent, full assembled feature not one chunk's diff): found U1-U5, all P2/P3, none blocking — raw-`<button>` reply action instead of MUI `Button` (U1), PollCard packed into the same wrapping flex row as reaction chips instead of its own full-width row (U2), MessagingScopeConfig's text-only loading state instead of the package's `CircularProgress` convention (U3), a raw inline-style attachment thumbnail instead of theme spacing (U4), and `MessageBubble`/`ConversationLaunchers` missing their required DX-1 harness entries (U5). All five fixed by the orchestrator (`974e24c`), re-verified 139/139 tests + clean build. Translation coverage, dark-mode tokens, deviation-doc accuracy and primitive reuse checked clean, no findings. Published: **ucm 2.16.0** (npm, CI-gated on push to `main`, `4369400`). No CHANGELOG.md in this repo (same as noted in NOTIF-13/NOTIF-12) — documented via commit messages + this register entry only. No app pin bumps in this WO. |
-| MSG-3b | Close the MSG-3 parity and contract gaps | Capability-checklist WO closing what MSG-3 missed: the entire unread lifecycle (mark-read never called — badges once raised never clear), message edit/delete + action menu, the DM launcher (`createDirectConversation` had no caller — the case MSG-2b unblocked in the backend), broken reply grouping (`serialize_message` emits `reply_to_id`, `Thread.jsx:40,62` reads `reply_to`, so every server-loaded reply renders as a root), quoted reply previews + jump-to-original, copy, client-side image compression, staged-image previews, upload progress, composer emoji insertion, relative timestamps, active-row highlight, announcement deep-link rendering. Plus a contract-conformance test and a corrected deviation list. | 2026-07-31 | in-review | c164db3, db8cd92, 61ed3b8, 7253172, fadb60a, 646fd01 | Extends the landed MSG-3 (2.16.0), convention as MSG-2b/NOTIF-8b. Envelope: [work-orders/MSG-3b.md](work-orders/MSG-3b.md). Tier 2. **Origin: a three-way audit** (jg capability baseline / ucm wired-vs-adapter-only inventory / dcm contract-coverage sweep) run after MSG-3 was marked done. MSG-3 had 139/139 green, five per-chunk reviews and a clean `ui_reviewer`, and still missed all of it — **because both sides were tested against themselves**: dcm against its services, ucm against a mock whose surface mirrors the provider rather than the contract, so an endpoint with no caller is structurally invisible. Second cause: "no jg feature is lost" was made binding without anyone writing the feature list first, and the deviation list meant to prove parity was authored by the party doing the work; its "Final parity confirmation" section claims completeness and is demonstrably false. This WO's checklist IS the spec (59 rows, each OK/DEV/MISSING/BROKEN/PARTIAL/BLOCKED; the review corrected one false OK — row 5, unread never live-updates at all); the contract-conformance test is the systemic fix. **Rows 38, 51-53, 56-58 are BLOCKED on dcm** (`MSG-2c`, not yet cut): no `serialize_poll` exists at all so `PollCard` reads fields no endpoint returns — and the design specifies no poll read path either, so `messaging-platform.md` must be amended first; `services.py` has 3 `_publish` call sites for 12 designed frames, so reaction/poll live sync cannot work; `serialize_conversation` omits `last_message`, so the list preview is permanently empty. Carries `ui_reviewer` at WO end, which must check the corrected deviation list against the checklist row by row. **All 6 chunks implemented, independently reviewed and committed** (chunk 1: unread lifecycle end-to-end + contract-conformance test, own-fix for a markThreadRead failure silently blocking thread-open; chunk 2: `reply_to`/`reply_to_id` fix + quoting/jump-to-original, row 27 found and recorded BLOCKED (no dcm thread-receipt read path) after an independent-review P1 caught it being silently dropped first time; chunk 3: message action menu/edit/delete/copy with a host-supplied moderator capability prop (dcm exposes no server-side capability field), fixed an undefined-vs-undefined author-match bug; chunk 4: `DirectMessageLauncher` wiring `createDirectConversation`, fixed jest-dom-matcher and MUI-dialog-transition-timing test issues after Codex's own verification pass died without a `RESULT:` line; chunk 5: composer shortcuts/previews/compression/emoji, fixed Codex settling for indeterminate-only upload progress by threading real `onUploadProgress` through the adapter as the WO asked, fixed missing diacritics in new translations (same bug class caught once before in MSG-3), corrected an unverified poll/attachment-mutual-exclusivity claim before it could land in the deviation doc; chunk 6: list/timeline polish (relative timestamps, auto-scroll, announcement links, DM sender-suppression, read-receipt popover) plus the full deviation-doc rewrite against all 59 checklist rows — fixed a repeat of an already-once-fixed raw-interactive-element pattern, corrected an overclaiming doc line, fixed a stale-ref edge case in auto-scroll). Row 42 (managed all-vs-team) also verified genuinely BLOCKED — dcm has `external_key` but never serializes it. Status `in-review`, not yet `done`: WO-end `ui_reviewer` pass and the version-bump/publish step are still outstanding. |
+| MSG-3b | Close the MSG-3 parity and contract gaps | Capability-checklist WO closing what MSG-3 missed: the entire unread lifecycle (mark-read never called — badges once raised never clear), message edit/delete + action menu, the DM launcher (`createDirectConversation` had no caller — the case MSG-2b unblocked in the backend), broken reply grouping (`serialize_message` emits `reply_to_id`, `Thread.jsx:40,62` reads `reply_to`, so every server-loaded reply renders as a root), quoted reply previews + jump-to-original, copy, client-side image compression, staged-image previews, upload progress, composer emoji insertion, relative timestamps, active-row highlight, announcement deep-link rendering. Plus a contract-conformance test and a corrected deviation list. | 2026-07-31 | done | c164db3, db8cd92, 61ed3b8, 7253172, fadb60a, 646fd01, 9748aca | Extends the landed MSG-3 (2.16.0), convention as MSG-2b/NOTIF-8b. Envelope: [work-orders/MSG-3b.md](work-orders/MSG-3b.md). Tier 2. **Origin: a three-way audit** (jg capability baseline / ucm wired-vs-adapter-only inventory / dcm contract-coverage sweep) run after MSG-3 was marked done. MSG-3 had 139/139 green, five per-chunk reviews and a clean `ui_reviewer`, and still missed all of it — **because both sides were tested against themselves**: dcm against its services, ucm against a mock whose surface mirrors the provider rather than the contract, so an endpoint with no caller is structurally invisible. Second cause: "no jg feature is lost" was made binding without anyone writing the feature list first, and the deviation list meant to prove parity was authored by the party doing the work; its "Final parity confirmation" section claims completeness and is demonstrably false. This WO's checklist IS the spec (59 rows, each OK/DEV/MISSING/BROKEN/PARTIAL/BLOCKED; the review corrected one false OK — row 5, unread never live-updates at all); the contract-conformance test is the systemic fix. **Rows 38, 51-53, 56-58 are BLOCKED on dcm** (`MSG-2c`, not yet cut): no `serialize_poll` exists at all so `PollCard` reads fields no endpoint returns — and the design specifies no poll read path either, so `messaging-platform.md` must be amended first; `services.py` has 3 `_publish` call sites for 12 designed frames, so reaction/poll live sync cannot work; `serialize_conversation` omits `last_message`, so the list preview is permanently empty. Carries `ui_reviewer` at WO end, which must check the corrected deviation list against the checklist row by row. **All 6 chunks implemented, independently reviewed and committed** (chunk 1: unread lifecycle end-to-end + contract-conformance test, own-fix for a markThreadRead failure silently blocking thread-open; chunk 2: `reply_to`/`reply_to_id` fix + quoting/jump-to-original, row 27 found and recorded BLOCKED (no dcm thread-receipt read path) after an independent-review P1 caught it being silently dropped first time; chunk 3: message action menu/edit/delete/copy with a host-supplied moderator capability prop (dcm exposes no server-side capability field), fixed an undefined-vs-undefined author-match bug; chunk 4: `DirectMessageLauncher` wiring `createDirectConversation`, fixed jest-dom-matcher and MUI-dialog-transition-timing test issues after Codex's own verification pass died without a `RESULT:` line; chunk 5: composer shortcuts/previews/compression/emoji, fixed Codex settling for indeterminate-only upload progress by threading real `onUploadProgress` through the adapter as the WO asked, fixed missing diacritics in new translations (same bug class caught once before in MSG-3), corrected an unverified poll/attachment-mutual-exclusivity claim before it could land in the deviation doc; chunk 6: list/timeline polish (relative timestamps, auto-scroll, announcement links, DM sender-suppression, read-receipt popover) plus the full deviation-doc rewrite against all 59 checklist rows — fixed a repeat of an already-once-fixed raw-interactive-element pattern, corrected an overclaiming doc line, fixed a stale-ref edge case in auto-scroll). Row 42 (managed all-vs-team) also verified genuinely BLOCKED — dcm has `external_key` but never serializes it. **WO-end `ui_reviewer`** (independent, row-by-row cross-check of `docs/messaging-deviations.md` against landed code for all 59 checklist rows, per the WO's binding "the review that signed off the false completeness claim is the one this WO exists to correct" instruction): no findings — every OK/DEV/BLOCKED row verified against actual code, not against the doc's own claims; translation coverage, DX-1 harness coverage, design-system/dark-mode/reuse all checked clean. Published: **ucm 2.17.0** (npm, CI-gated on push to `main`, `9748aca`). No CHANGELOG.md in this repo (same as NOTIF-12/NOTIF-13/MSG-3) — documented via commit messages + this register entry only. No app pin bumps in this WO. |
+| MSG-3c | Deliver the rows MSG-3b left blocked against a stale dcm version | Seven checklist rows (38, 51-53, 56-58) that MSG-3b correctly refused to fake against dcm 2.36.1, and which dcm 2.37.0 made buildable **while MSG-3b was still running**: real last-message preview + list reorder/preview refresh, full `PollCard` rendering (question / options / `vote_count` / `voters` / closed state), and the `reaction` / `poll_updated` frame handlers that stop being dead code. Plus the deviation-doc correction and a conformance-test extension requiring every BLOCKED entry to carry a dependency version pin. | 2026-07-31 | in-review | 84cc3c2, 5dd4d3a, 733588a | Envelope: [work-orders/MSG-3c.md](work-orders/MSG-3c.md); canonical row in dcm's register. Extends the landed MSG-3b (2.17.0). **Root cause — third occurrence of one pattern in this workstream:** the WO-end `ui_reviewer` cross-checked all 59 rows against *ucm's* landed code and took the dependency's state from the WO text instead of reading dcm, so seven rows closed as "blocked on a future dcm work order" that had already shipped. New rule this WO adds: a BLOCKED row is re-verified against the live dependency **at WO close, not at WO start**, and every BLOCKED entry names the version it was blocked at. MSG-3b already did the version-pinning unprompted — that pin is the only reason the staleness was a two-minute check rather than surfacing at MSG-5. Rows 27 and 42 stay correctly BLOCKED, on dcm `MSG-2d`. Highest latent risk: rows 56/57 are handler paths that have **never** run against a real frame, so treat them as new code under test rather than as working code being unblocked; and poll tests must use server-shaped payloads (`serialize_poll` output), since client-shaped fixtures are what let the `reply_to_id` bug survive MSG-3. **Codex was out of credits for this entire WO** (verified: every invocation returned only a workspace-credits error, no work done) — all three chunks implemented directly by the orchestrator per the Codex→Claude fallback rule, with mandatory independent review on every chunk (author ≠ reviewer). **Chunk 1** (rows 38/58): fixed a real bug found while scoping — `ConversationList` read `last_message.body`, but dcm's `serialize_last_message` only ever returns `.excerpt` — plus a defensive fix to `applyFrame`'s `message_edited` keying (reviewer found my initial bug analysis incomplete: dcm always attaches a full `frame.message`, so the fix is a no-op against the real wire contract but kept as genuine defensive robustness; the regression test was rewritten to use the real enriched frame shape instead of a fabricated minimal one). **Chunk 2** (rows 51-53): fixed `PollCard` reading non-existent `created_by`/`selected`/`voted` fields (real fields: `created_by_id`, `voted_option_ids` — the latter present only on the vote/create/close REST responses, never in `serialize_poll` or the `poll_updated` frame); found and fixed the same "frame wholesale-replaces viewer-specific state" defect class in `poll_updated`'s own handler ahead of chunk 3's explicit scope. **Chunk 3** (rows 56/57 + WO deliverables): found and fixed the identical defect in the `reaction` frame handler and `toggleReaction`'s REST-confirm path (dcm's `serialize_reactions` never returns a per-viewer `reacted` flag; both call sites were wholesale-replacing and silently wiping known reacted state); extended the contract-conformance test with the WO's new BLOCKED-version-pin rule plus a required negative-case test; rewrote `docs/messaging-deviations.md` (rows 38/51/53/56-58 → OK, row 52 → DEV, rows 27/42 stay BLOCKED with the new version pin, substance untouched). Status `in-review`, not yet `done`: WO-end `ui_reviewer` pass (per the WO's changed instruction — cross-check BLOCKED rows against dcm's *current* version) and the version-bump/publish step are still outstanding. |

package/dev/entries.jsx

@@ -61,7 +61,7 @@ function RealtimeAdapterEntry() {
 const messagingHarnessApi = {
   listConversations: async ({ cursor } = {}) => cursor
     ? ({ results: [{ id: 13, title: 'Archived planning', last_message_at: '2026-07-30T09:00:00Z' }], next_cursor: null })
-    : ({ results: [{ id: 12, title: 'Support group', unread_count: 1, last_message_at: '2026-07-31T09:00:00Z', last_message: { body: 'Can someone help?' } }], next_cursor: 'signed-next-page' }),
+    : ({ results: [{ id: 12, title: 'Support group', unread_count: 1, last_message_at: '2026-07-31T09:00:00Z', last_message: { excerpt: 'Can someone help?' } }], next_cursor: 'signed-next-page' }),
   // GET conversations/{id}/messages/ returns roots only (design §REST); replies
   // come from GET messages/{root_id}/thread/ (listThread below), never mixed in here.
   listMessages: async (conversationId, { cursor } = {}) => cursor

package/dist/i18n/messagingTranslations.js

@@ -85,6 +85,7 @@ export const messagingTranslations = {
     'MessagingPoll.ADD_OPTION': { de: 'Option hinzufügen', en: 'Add option', fr: 'Ajouter une option' },
     'MessagingPoll.ALLOW_MULTIPLE': { de: 'Mehrfachauswahl erlauben', en: 'Allow multiple choices', fr: 'Autoriser plusieurs choix' },
     'MessagingPoll.CANCEL': { de: 'Abbrechen', en: 'Cancel', fr: 'Annuler' },
+    'MessagingPoll.YOU_VOTED': { de: 'von dir gewählt', en: 'voted by you', fr: 'voté par vous' },
     'MessagingConfig.LABEL': { de: 'Nachrichten-Einstellungen', en: 'Messaging settings', fr: 'Paramètres de messagerie' },
     'MessagingConfig.TITLE': { de: 'Nachrichten-Einstellungen', en: 'Messaging settings', fr: 'Paramètres de messagerie' },
     'MessagingConfig.LOADING': { de: 'Einstellungen werden geladen…', en: 'Loading settings…', fr: 'Chargement des paramètres…' },

package/dist/messaging/ConversationList.js

@@ -77,6 +77,6 @@ export function ConversationList({ onOpen, groupLaunchers, broadcastLauncher, au
                     var _a;
                     const unread = unreadFor(conversation);
                     const archived = Boolean(conversation.archived || conversation.archived_at);
-                    return _jsxs(ListItemButton, { selected: conversation.id === activeConversationId, onClick: () => { markConversationRead(conversation.id).catch(() => { }); onOpen === null || onOpen === void 0 ? void 0 : onOpen(conversation); }, sx: { minHeight: 64, opacity: archived ? 0.6 : 1 }, children: [_jsx(Badge, { color: "error", badgeContent: unread || null, max: 99, sx: { mr: 2 }, children: archived ? _jsx(Archive, { fontSize: "small", color: "disabled" }) : _jsx(KindIcon, { conversation: conversation }) }), _jsx(ListItemText, { primary: _jsxs(Stack, { direction: "row", spacing: 1, justifyContent: "space-between", children: [_jsx(Typography, { component: "span", fontWeight: unread ? 700 : 400, noWrap: true, children: titleOf(conversation, t) }), relativeTime(conversation.last_message_at, i18n === null || i18n === void 0 ? void 0 : i18n.language) && _jsx(Typography, { component: "span", variant: "caption", color: "text.secondary", noWrap: true, children: relativeTime(conversation.last_message_at, i18n === null || i18n === void 0 ? void 0 : i18n.language) })] }), secondary: ((_a = conversation.last_message) === null || _a === void 0 ? void 0 : _a.body) || t('MessagingList.NO_MESSAGES'), secondaryTypographyProps: { noWrap: true } }), _jsx(IconButton, { "aria-label": t('MessagingList.ACTIONS'), onClick: (event) => { event.stopPropagation(); setMenuAnchor(event.currentTarget); setMenuConversation(conversation); }, children: _jsx(MoreVert, {}) })] }, conversation.id);
+                    return _jsxs(ListItemButton, { selected: conversation.id === activeConversationId, onClick: () => { markConversationRead(conversation.id).catch(() => { }); onOpen === null || onOpen === void 0 ? void 0 : onOpen(conversation); }, sx: { minHeight: 64, opacity: archived ? 0.6 : 1 }, children: [_jsx(Badge, { color: "error", badgeContent: unread || null, max: 99, sx: { mr: 2 }, children: archived ? _jsx(Archive, { fontSize: "small", color: "disabled" }) : _jsx(KindIcon, { conversation: conversation }) }), _jsx(ListItemText, { primary: _jsxs(Stack, { direction: "row", spacing: 1, justifyContent: "space-between", children: [_jsx(Typography, { component: "span", fontWeight: unread ? 700 : 400, noWrap: true, children: titleOf(conversation, t) }), relativeTime(conversation.last_message_at, i18n === null || i18n === void 0 ? void 0 : i18n.language) && _jsx(Typography, { component: "span", variant: "caption", color: "text.secondary", noWrap: true, children: relativeTime(conversation.last_message_at, i18n === null || i18n === void 0 ? void 0 : i18n.language) })] }), secondary: ((_a = conversation.last_message) === null || _a === void 0 ? void 0 : _a.excerpt) || t('MessagingList.NO_MESSAGES'), secondaryTypographyProps: { noWrap: true } }), _jsx(IconButton, { "aria-label": t('MessagingList.ACTIONS'), onClick: (event) => { event.stopPropagation(); setMenuAnchor(event.currentTarget); setMenuConversation(conversation); }, children: _jsx(MoreVert, {}) })] }, conversation.id);
                 }) })), cache.cursors.conversations && _jsx(Button, { onClick: loadMore, disabled: loadingMore, children: loadingMore ? _jsx(CircularProgress, { size: 18 }) : t('MessagingList.LOAD_MORE') }), _jsxs(Menu, { anchorEl: menuAnchor, open: Boolean(menuConversation), onClose: closeMenu, children: [_jsxs(MenuItem, { onClick: toggleMute, children: [_jsx(NotificationsOff, { fontSize: "small", sx: { mr: 1 } }), (menuConversation === null || menuConversation === void 0 ? void 0 : menuConversation.muted) ? t('MessagingList.UNMUTE') : t('MessagingList.MUTE')] }), _jsxs(MenuItem, { onClick: archive, children: [_jsx(Archive, { fontSize: "small", sx: { mr: 1 } }), t('MessagingList.ARCHIVE')] })] })] }));
 }

package/dist/messaging/MessagingProvider.js

@@ -92,7 +92,7 @@ export function messagingReducer(state, action) {
     }
 }
 export function applyFrame(state, frame, activeConversationId = null) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f;
     const payload = frame.message || frame.conversation || frame.participant || frame;
     const conversationId = (_a = frame.conversation_id) !== null && _a !== void 0 ? _a : payload.conversation_id;
     if (frame.type === 'message') {
@@ -106,17 +106,45 @@ export function applyFrame(state, frame, activeConversationId = null) {
         const previousCount = ((_b = unread.by_conversation) === null || _b === void 0 ? void 0 : _b[conversationId]) || 0;
         return Object.assign(Object.assign({}, state), { messages, unread: Object.assign(Object.assign({}, unread), { unread_count: (unread.unread_count || 0) + 1, by_conversation: Object.assign(Object.assign({}, unread.by_conversation), { [conversationId]: previousCount + 1 }) }) });
     }
-    if (frame.type === 'message_edited')
-        return Object.assign(Object.assign({}, state), { messages: mergeById(state.messages, payload) });
-    if (frame.type === 'reaction') {
+    if (frame.type === 'message_edited') {
+        // dcm's publish_messaging_event always attaches a full frame.message
+        // (serialize_message) for this event type, so `payload` already carries
+        // the message's own `.id` in practice. The explicit `id:` override below
+        // is defensive only — it keeps this branch correct even if a future
+        // producer ever omits `.message` and falls through to the raw frame,
+        // whose `conversation_id` would otherwise win idOf()'s fallback order.
         const messageId = (_c = frame.message_id) !== null && _c !== void 0 ? _c : payload.message_id;
+        return Object.assign(Object.assign({}, state), { messages: mergeById(state.messages, Object.assign(Object.assign({}, payload), { id: messageId })) });
+    }
+    if (frame.type === 'reaction') {
+        const messageId = (_d = frame.message_id) !== null && _d !== void 0 ? _d : payload.message_id;
         const previous = state.messages[messageId] || { id: messageId };
-        return Object.assign(Object.assign({}, state), { messages: mergeById(state.messages, Object.assign(Object.assign({}, previous), { reactions: payload.reactions || frame.reactions || previous.reactions || [] })) });
+        // serialize_reactions (dcm) returns [{emoji, count}] only, never a
+        // per-viewer `reacted` flag, in any context — not REST, not frames, by
+        // design (aggregate-only). Wholesale-replacing `reactions` with the
+        // incoming server list would silently wipe every previously-known
+        // `reacted` flag on this message, not just whichever emoji changed.
+        // Merge by emoji instead: carry forward a previously-known `reacted`
+        // flag for any emoji still present in the incoming aggregate.
+        const incoming = payload.reactions || frame.reactions || previous.reactions || [];
+        const previousByEmoji = new Map((previous.reactions || []).map((reaction) => [reaction.emoji, reaction]));
+        const reactions = incoming.map((reaction) => { var _a, _b, _c; return (Object.assign(Object.assign({}, reaction), { reacted: (_c = (_a = reaction.reacted) !== null && _a !== void 0 ? _a : (_b = previousByEmoji.get(reaction.emoji)) === null || _b === void 0 ? void 0 : _b.reacted) !== null && _c !== void 0 ? _c : false })); });
+        return Object.assign(Object.assign({}, state), { messages: mergeById(state.messages, Object.assign(Object.assign({}, previous), { reactions })) });
     }
     if (frame.type === 'poll_updated') {
-        const messageId = (_d = frame.message_id) !== null && _d !== void 0 ? _d : payload.message_id;
+        const messageId = (_e = frame.message_id) !== null && _e !== void 0 ? _e : payload.message_id;
         const previous = state.messages[messageId] || { id: messageId };
-        const poll = payload.poll || frame.poll || payload;
+        const incomingPoll = payload.poll || frame.poll || payload;
+        // dcm's poll_updated frame is a viewer-independent projection
+        // (serialize_poll) — it never carries voted_option_ids, which dcm only
+        // ever adds to this viewer's own vote/create/close REST response. A
+        // frame arriving after a REST-derived vote is known must not wipe that
+        // locally-known selection; carry it forward when the frame is silent
+        // about it, never invert it from frame data that structurally can't
+        // contain it.
+        const previousVotedOptionIds = (_f = previous.poll) === null || _f === void 0 ? void 0 : _f.voted_option_ids;
+        const poll = incomingPoll.voted_option_ids === undefined && previousVotedOptionIds
+            ? Object.assign(Object.assign({}, incomingPoll), { voted_option_ids: previousVotedOptionIds }) : incomingPoll;
         return Object.assign(Object.assign({}, state), { messages: mergeById(state.messages, Object.assign(Object.assign({}, previous), { poll })), polls: mergeById(state.polls, poll) });
     }
     if (frame.type === 'message_deleted') {
@@ -284,7 +312,14 @@ export function MessagingProvider({ children, filters = {}, activeConversationId
         patchMessage(Object.assign(Object.assign({}, message), { reactions: nextReactions }));
         try {
             const result = active ? await api.removeReaction(messageId, emoji) : await api.addReaction(messageId, emoji);
-            patchMessage(Object.assign(Object.assign(Object.assign({}, message), ((result === null || result === void 0 ? void 0 : result.message) || result)), { reactions: (result === null || result === void 0 ? void 0 : result.reactions) || ((_a = result === null || result === void 0 ? void 0 : result.message) === null || _a === void 0 ? void 0 : _a.reactions) || nextReactions }));
+            // Same aggregate-only shape as the realtime `reaction` frame (serialize_reactions
+            // never returns a per-viewer `reacted` flag) — merge the server's confirmed
+            // counts with the reacted flags nextReactions already computed correctly,
+            // rather than letting the reacted-less server array wipe them.
+            const confirmedCounts = (result === null || result === void 0 ? void 0 : result.reactions) || ((_a = result === null || result === void 0 ? void 0 : result.message) === null || _a === void 0 ? void 0 : _a.reactions);
+            const nextByEmoji = new Map(nextReactions.map((reaction) => [reaction.emoji, reaction]));
+            const reactions = confirmedCounts ? confirmedCounts.map((reaction) => { var _a, _b, _c; return (Object.assign(Object.assign({}, reaction), { reacted: (_c = (_a = reaction.reacted) !== null && _a !== void 0 ? _a : (_b = nextByEmoji.get(reaction.emoji)) === null || _b === void 0 ? void 0 : _b.reacted) !== null && _c !== void 0 ? _c : false })); }) : nextReactions;
+            patchMessage(Object.assign(Object.assign(Object.assign({}, message), ((result === null || result === void 0 ? void 0 : result.message) || result)), { reactions }));
             return result;
         }
         catch (error) {

package/dist/messaging/PollCard.js

@@ -5,19 +5,27 @@ import { useTranslation } from 'react-i18next';
 import { extractApiErrorMessage, useMessaging } from './MessagingProvider';
 /** Independently mountable live poll view. Server authorization remains authoritative. */
 export function PollCard({ message, canClose: canCloseProp }) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g;
     const { t } = useTranslation();
     const { castPollVote, closeConversationPoll, currentUser } = useMessaging();
     const poll = message === null || message === void 0 ? void 0 : message.poll;
     const [selected, setSelected] = useState([]);
     const [error, setError] = useState(null);
     const [busy, setBusy] = useState(false);
-    useEffect(() => setSelected(((poll === null || poll === void 0 ? void 0 : poll.options) || []).filter((option) => option.selected || option.voted).map((option) => option.id)), [poll]);
+    // voted_option_ids is a view-level enrichment dcm adds ONLY to the
+    // create/vote/close poll REST responses (serialize_poll itself, every
+    // message-list/thread load, and every poll_updated realtime frame never
+    // carry it) — so it's only ever present right after this viewer's own
+    // vote/create/close action. When it's absent (a freshly loaded or
+    // frame-updated poll), there's no way to know this viewer's vote from the
+    // payload alone; default to no selection rather than guessing or carrying
+    // over stale local state.
+    useEffect(() => setSelected((poll === null || poll === void 0 ? void 0 : poll.voted_option_ids) ? [...poll.voted_option_ids] : []), [poll]);
     if (!poll)
         return null;
     const closed = Boolean(poll.closed_at);
-    const creatorId = (_b = (_a = poll.created_by) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : poll.created_by;
-    const canClose = (_f = (_d = (_c = canCloseProp !== null && canCloseProp !== void 0 ? canCloseProp : poll.can_close) !== null && _c !== void 0 ? _c : message === null || message === void 0 ? void 0 : message.can_close) !== null && _d !== void 0 ? _d : (_e = message === null || message === void 0 ? void 0 : message.permissions) === null || _e === void 0 ? void 0 : _e.can_close) !== null && _f !== void 0 ? _f : (creatorId != null && creatorId === (currentUser === null || currentUser === void 0 ? void 0 : currentUser.id));
+    const creatorId = (_c = (_a = poll.created_by_id) !== null && _a !== void 0 ? _a : (_b = poll.created_by) === null || _b === void 0 ? void 0 : _b.id) !== null && _c !== void 0 ? _c : poll.created_by;
+    const canClose = (_g = (_e = (_d = canCloseProp !== null && canCloseProp !== void 0 ? canCloseProp : poll.can_close) !== null && _d !== void 0 ? _d : message === null || message === void 0 ? void 0 : message.can_close) !== null && _e !== void 0 ? _e : (_f = message === null || message === void 0 ? void 0 : message.permissions) === null || _f === void 0 ? void 0 : _f.can_close) !== null && _g !== void 0 ? _g : (creatorId != null && creatorId === (currentUser === null || currentUser === void 0 ? void 0 : currentUser.id));
     const changeSelection = (id) => setSelected((current) => poll.allow_multiple ? (current.includes(id) ? current.filter((value) => value !== id) : [...current, id]) : (current.includes(id) ? [] : [id]));
     const vote = async () => {
         if (!selected.length) {
@@ -49,5 +57,14 @@ export function PollCard({ message, canClose: canCloseProp }) {
             setBusy(false);
         }
     };
-    return _jsx(Paper, { variant: "outlined", sx: { p: 1 }, "aria-label": t('MessagingPoll.LABEL'), children: _jsxs(Stack, { spacing: 0.5, children: [_jsx(Typography, { variant: "subtitle2", children: poll.question }), (poll.options || []).map((option) => { var _a, _b; return _jsx(FormControlLabel, { disabled: closed || busy, control: _jsx(Checkbox, { checked: selected.includes(option.id), onChange: () => changeSelection(option.id) }), label: `${option.text || option.label} (${(_b = (_a = option.vote_count) !== null && _a !== void 0 ? _a : option.votes_count) !== null && _b !== void 0 ? _b : 0})` }, option.id); }), error && _jsx(Alert, { severity: "error", role: "alert", children: error }), _jsxs(Stack, { direction: "row", spacing: 1, children: [_jsx(Button, { size: "small", onClick: vote, disabled: closed || busy, children: t('MessagingPoll.VOTE') }), canClose && !closed && _jsx(Button, { size: "small", color: "warning", onClick: close, disabled: busy, children: t('MessagingPoll.CLOSE') }), closed && _jsx(Typography, { variant: "caption", children: t('MessagingPoll.CLOSED') })] })] }) });
+    return _jsx(Paper, { variant: "outlined", sx: { p: 1 }, "aria-label": t('MessagingPoll.LABEL'), children: _jsxs(Stack, { spacing: 0.5, children: [_jsx(Typography, { variant: "subtitle2", children: poll.question }), (poll.options || []).map((option) => {
+                    var _a, _b, _c, _d, _e, _f, _g;
+                    // dcm's poll projection gives voter user ids only, never names — there
+                    // is no user-directory endpoint (same structural limit already
+                    // established for the DM candidate list). A count is always correct;
+                    // marking the viewer's own vote is derivable from voted_option_ids.
+                    const votedByMe = Boolean((_a = poll.voted_option_ids) === null || _a === void 0 ? void 0 : _a.includes(option.id));
+                    const voterCount = (_e = (_d = (_c = (_b = option.voters) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : option.vote_count) !== null && _d !== void 0 ? _d : option.votes_count) !== null && _e !== void 0 ? _e : 0;
+                    return _jsx(FormControlLabel, { disabled: closed || busy, control: _jsx(Checkbox, { checked: selected.includes(option.id), onChange: () => changeSelection(option.id) }), label: `${option.text || option.label} (${(_g = (_f = option.vote_count) !== null && _f !== void 0 ? _f : voterCount) !== null && _g !== void 0 ? _g : 0})${votedByMe ? ` — ${t('MessagingPoll.YOU_VOTED')}` : ''}` }, option.id);
+                }), error && _jsx(Alert, { severity: "error", role: "alert", children: error }), _jsxs(Stack, { direction: "row", spacing: 1, children: [_jsx(Button, { size: "small", onClick: vote, disabled: closed || busy, children: t('MessagingPoll.VOTE') }), canClose && !closed && _jsx(Button, { size: "small", color: "warning", onClick: close, disabled: busy, children: t('MessagingPoll.CLOSE') }), closed && _jsx(Typography, { variant: "caption", children: t('MessagingPoll.CLOSED') })] })] }) });
 }

package/docs/messaging-deviations.md

@@ -1,11 +1,22 @@
-# Messaging parity outcomes (MSG-3b)
-
-This is the authoritative MSG-3b parity record. It replaces the former
-file-level “final parity confirmation,” which was not sufficient evidence of
-feature parity. Each entry maps directly to the numbered checklist in Part A
-of `work-orders/MSG-3b.md`. `OK` means the capability is present; `DEV` means
-an intentional, documented redesign or non-parity; `BLOCKED` means dcm 2.36.1
-does not expose the data or realtime contract needed to implement it truthfully.
+# Messaging parity outcomes (MSG-3b, extended by MSG-3c)
+
+This is the authoritative parity record for the ucm messaging surfaces. It
+replaces the former file-level “final parity confirmation,” which was not
+sufficient evidence of feature parity. Each entry maps directly to the
+numbered checklist in Part A of `work-orders/MSG-3b.md`. `OK` means the
+capability is present; `DEV` means an intentional, documented redesign or
+non-parity; `BLOCKED` means the dependency (dcm) does not expose the data or
+realtime contract needed to implement it truthfully.
+
+**Binding rule, added by MSG-3c:** every `BLOCKED` entry below must name the
+dcm version it was verified blocked against. MSG-3b was itself blocked
+against dcm 2.36.1 and recorded seven rows as `BLOCKED` on "a future dcm work
+order" — dcm 2.37.0 shipped that work mid-flight, and MSG-3b's own WO-end
+review closed without noticing, because it cross-checked the checklist
+against ucm's landed code and took the dependency's state from the WO text
+instead of the live dependency. A version pin turns that re-check into a
+two-minute job instead of an archaeology exercise; `tests/messagingContractConformance.test.js`
+now fails the build if a `BLOCKED` line omits one.
 
 ## Unread lifecycle
 
@@ -44,7 +55,7 @@ does not expose the data or realtime contract needed to implement it truthfully.
 24. **OK** — Replies show a sender and short quoted snippet.
 25. **OK** — Clicking a quote scrolls its source message into view.
 26. **OK** — Quotes of deleted messages render the deleted placeholder rather than stale content.
-27. **BLOCKED** — dcm writes a thread receipt but exposes no prior thread receipt state, unread flag, or unread count to read. A truthful cross-device unread-reply dot cannot be rendered without a dcm contract addition.
+27. **BLOCKED** (blocked as of dcm 2.37.0) — dcm writes a thread receipt but exposes no prior thread receipt state, unread flag, or unread count to read. A truthful cross-device unread-reply dot cannot be rendered without a dcm contract addition. Re-verified against 2.37.0 (MSG-3c): still absent. Waits on dcm `MSG-2d`.
 28. **OK** — Reply threads load lazily on expand and collapse locally.
 29. **DEV** — Reply composition is supplied through the independently mountable `Composer` target prop rather than jg’s per-thread embedded composer.
 
@@ -61,11 +72,11 @@ does not expose the data or realtime contract needed to implement it truthfully.
 
 ## Conversation list
 
-38. **BLOCKED** — dcm does not serialize `last_message`, so a last-message preview cannot be made correct against the real backend.
+38. **OK** (delivered in MSG-3c, was BLOCKED as of dcm 2.36.1) — dcm 2.37.0 serializes `last_message` (`excerpt`/`created_at`) on the conversation payload and emits it live via `conversation_upsert` on new-message send. `ConversationList` was found reading the wrong field name (`last_message.body` instead of the real `excerpt`) — fixed, so the preview now actually renders against the real contract instead of always falling back to the empty state. Reorder and live preview refresh work for new messages; dcm does not publish `conversation_upsert` on message edit/delete, so those cases update on the next REST refresh rather than live (see row 58).
 39. **OK** — `last_message_at` renders through browser-native, locale-aware `Intl.RelativeTimeFormat` labels.
 40. **OK** — The existing MUI `selected={conversation.id === activeConversationId}` wiring produces the `Mui-selected` active-row highlight; it was verified and needs no redundant styling.
 41. **OK** — Unread badges and bold unread titles are present.
-42. **BLOCKED** — dcm stores the managed all/team distinction in `external_key` but omits it from conversation serialization. The UI must not guess from titles or other unrelated fields.
+42. **BLOCKED** (blocked as of dcm 2.37.0) — dcm stores the managed all/team distinction in `external_key`, but `serialize_conversation_core` still omits it from every conversation payload. The UI must not guess from titles or other unrelated fields. Re-verified against 2.37.0 (MSG-3c): still absent. Waits on dcm `MSG-2d`.
 43. **DEV** — Generic MUI kind icons replace jg’s richer per-kind/person avatar treatment while retaining type identification.
 44. **OK** — Mute and archive actions are present.
 
@@ -83,19 +94,25 @@ does not expose the data or realtime contract needed to implement it truthfully.
 
 ## Polls
 
-51. **BLOCKED** — dcm has no poll read serialization for question, option, or count data; client-side fabrication would hide the backend contract gap.
-52. **BLOCKED** — Per-option voter names are likewise absent from dcm’s readable poll contract.
-53. **BLOCKED** — Closed state and disabled-voting rendering depend on that absent poll read contract.
+51. **OK** (delivered in MSG-3c, was BLOCKED as of dcm 2.36.1) — dcm 2.37.0's `serialize_poll` renders question, options and per-option `vote_count` through `PollCard`. Fixed against the real shape: the initial-selection effect previously read non-existent per-option `selected`/`voted` flags — it now derives from `voted_option_ids`, which dcm adds only to the create/vote/close REST responses (never to `serialize_poll` itself or the `poll_updated` frame), and correctly shows no known selection when that field is absent rather than guessing.
+52. **DEV** (delivered in MSG-3c, was BLOCKED as of dcm 2.36.1) — dcm 2.37.0's poll options carry `voters` as user ids only, never names, and there is no user-directory endpoint (the same structural limit already established for the DM candidate list, row 19). `PollCard` renders the vote count and marks the viewer's own vote (derived from `voted_option_ids`) rather than a per-voter name list, which the dependency cannot supply.
+53. **OK** (delivered in MSG-3c, was BLOCKED as of dcm 2.36.1) — `closed_at` is in the real poll projection; voting is disabled once set. The poll creator's close permission was found broken against the real contract (`created_by_id` is the real field; the prior code read a non-existent `created_by.id`) — fixed.
 54. **OK** — Composer starts at two options and disables adding options once it reaches ten; the server’s two-option minimum remains enforced.
-55. **OK** — Vote and close write paths are wired; their full read rendering remains subject to rows 51–53.
+55. **OK** — Vote and close write paths are wired; full read rendering is now delivered per rows 51-53.
 
 ## Live synchronization
 
-56. **BLOCKED** — Reaction frame handling remains intentionally ready, but dcm 2.36.1 does not emit `reaction` frames.
-57. **BLOCKED** — Poll-update frame handling remains intentionally ready, but dcm 2.36.1 does not emit `poll_updated` frames.
-58. **BLOCKED** — Conversation reorder and preview refresh require dcm’s missing `last_message` projection.
+56. **OK** (delivered in MSG-3c, was BLOCKED as of dcm 2.36.1) — dcm 2.37.0 emits `reaction` frames. The handler had never run against a real frame; verification found it wholesale-replacing the message's reaction list with the server's aggregate-only projection (`{emoji, count}`, never a per-viewer `reacted` flag, by design) on every arrival — silently wiping every previously-known `reacted` flag on that message, not just whichever emoji changed. The same defect existed in the REST-confirm path for the viewer's own toggle. Both fixed to merge by emoji, preserving previously-known `reacted` state instead of discarding it.
+57. **OK** (delivered in MSG-3c, was BLOCKED as of dcm 2.36.1) — dcm 2.37.0 emits `poll_updated` frames. Same defect class as row 56, found while implementing row 51-53: the frame handler wholesale-replaced a message's `poll` object, silently dropping a REST-known `voted_option_ids` the moment any `poll_updated` frame arrived (e.g. a vote-count bump from another viewer). Fixed to carry the previous value forward when the incoming frame is silent about it, per the WO's explicit "must not clear or invert the viewer's own vote state" requirement.
+58. **OK** (delivered in MSG-3c, was BLOCKED as of dcm 2.36.1) — new messages live-reorder the conversation list and refresh its preview via `conversation_upsert` (row 38). dcm does not publish `conversation_upsert` on message edit or delete (only on new-message send — verified against every `_publish(..., "conversation_upsert", ...)` call site in `services.py`), so an edit/delete of a conversation's last message updates the preview on the next REST refresh rather than live; this is a dcm-side gap outside this WO's scope, not a ucm limitation.
 59. **OK** — dcm’s emitted message, message-edited, and message-deleted frames are handled live.
 
 ## Required backend follow-up
 
-Rows 27, 38, 42, 51–53, and 56–58 require a future dcm work order: expose readable thread receipt state, serialize `external_key` where managed all/team labeling is required, define and serialize the poll read contract, add `last_message`, and emit the designed realtime frames. Until then, these are explicit BLOCKED outcomes rather than simulated client behavior.
+Rows 27 and 42 require a future dcm work order (`MSG-2d`): expose readable thread receipt state, and
+serialize `external_key` where managed all/team labeling is required. Until then, these are explicit
+BLOCKED outcomes, each pinned to the dcm version they were verified blocked against, rather than
+simulated client behavior. MSG-2c (dcm 2.37.0) already delivered what MSG-3b's own audit had recorded
+as blocking rows 38, 51–53 and 56–58 — MSG-3c re-verified each against the live dependency and
+delivered them; see those rows above for what was actually built (in three cases, fixing a real
+client-side bug found only once real server data was checked against, not just unblocked).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@micha.bigler/ui-core-micha",
-  "version": "2.17.0",
+  "version": "2.18.0",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "repository": {

package/src/i18n/messagingTranslations.ts

@@ -85,6 +85,7 @@ export const messagingTranslations = {
   'MessagingPoll.ADD_OPTION': { de: 'Option hinzufügen', en: 'Add option', fr: 'Ajouter une option' },
   'MessagingPoll.ALLOW_MULTIPLE': { de: 'Mehrfachauswahl erlauben', en: 'Allow multiple choices', fr: 'Autoriser plusieurs choix' },
   'MessagingPoll.CANCEL': { de: 'Abbrechen', en: 'Cancel', fr: 'Annuler' },
+  'MessagingPoll.YOU_VOTED': { de: 'von dir gewählt', en: 'voted by you', fr: 'voté par vous' },
   'MessagingConfig.LABEL': { de: 'Nachrichten-Einstellungen', en: 'Messaging settings', fr: 'Paramètres de messagerie' },
   'MessagingConfig.TITLE': { de: 'Nachrichten-Einstellungen', en: 'Messaging settings', fr: 'Paramètres de messagerie' },
   'MessagingConfig.LOADING': { de: 'Einstellungen werden geladen…', en: 'Loading settings…', fr: 'Chargement des paramètres…' },

package/src/messaging/ConversationList.jsx

@@ -68,7 +68,7 @@ export function ConversationList({ onOpen, groupLaunchers, broadcastLauncher, au
               <Badge color="error" badgeContent={unread || null} max={99} sx={{ mr: 2 }}>
                 {archived ? <Archive fontSize="small" color="disabled" /> : <KindIcon conversation={conversation} />}
               </Badge>
-              <ListItemText primary={<Stack direction="row" spacing={1} justifyContent="space-between"><Typography component="span" fontWeight={unread ? 700 : 400} noWrap>{titleOf(conversation, t)}</Typography>{relativeTime(conversation.last_message_at, i18n?.language) && <Typography component="span" variant="caption" color="text.secondary" noWrap>{relativeTime(conversation.last_message_at, i18n?.language)}</Typography>}</Stack>} secondary={conversation.last_message?.body || t('MessagingList.NO_MESSAGES')} secondaryTypographyProps={{ noWrap: true }} />
+              <ListItemText primary={<Stack direction="row" spacing={1} justifyContent="space-between"><Typography component="span" fontWeight={unread ? 700 : 400} noWrap>{titleOf(conversation, t)}</Typography>{relativeTime(conversation.last_message_at, i18n?.language) && <Typography component="span" variant="caption" color="text.secondary" noWrap>{relativeTime(conversation.last_message_at, i18n?.language)}</Typography>}</Stack>} secondary={conversation.last_message?.excerpt || t('MessagingList.NO_MESSAGES')} secondaryTypographyProps={{ noWrap: true }} />
               <IconButton aria-label={t('MessagingList.ACTIONS')} onClick={(event) => { event.stopPropagation(); setMenuAnchor(event.currentTarget); setMenuConversation(conversation); }}><MoreVert /></IconButton>
             </ListItemButton>;
           })}

package/src/messaging/MessagingProvider.jsx

@@ -141,16 +141,46 @@ export function applyFrame(state, frame, activeConversationId = null) {
       },
     };
   }
-  if (frame.type === 'message_edited') return { ...state, messages: mergeById(state.messages, payload) };
+  if (frame.type === 'message_edited') {
+    // dcm's publish_messaging_event always attaches a full frame.message
+    // (serialize_message) for this event type, so `payload` already carries
+    // the message's own `.id` in practice. The explicit `id:` override below
+    // is defensive only — it keeps this branch correct even if a future
+    // producer ever omits `.message` and falls through to the raw frame,
+    // whose `conversation_id` would otherwise win idOf()'s fallback order.
+    const messageId = frame.message_id ?? payload.message_id;
+    return { ...state, messages: mergeById(state.messages, { ...payload, id: messageId }) };
+  }
   if (frame.type === 'reaction') {
     const messageId = frame.message_id ?? payload.message_id;
     const previous = state.messages[messageId] || { id: messageId };
-    return { ...state, messages: mergeById(state.messages, { ...previous, reactions: payload.reactions || frame.reactions || previous.reactions || [] }) };
+    // serialize_reactions (dcm) returns [{emoji, count}] only, never a
+    // per-viewer `reacted` flag, in any context — not REST, not frames, by
+    // design (aggregate-only). Wholesale-replacing `reactions` with the
+    // incoming server list would silently wipe every previously-known
+    // `reacted` flag on this message, not just whichever emoji changed.
+    // Merge by emoji instead: carry forward a previously-known `reacted`
+    // flag for any emoji still present in the incoming aggregate.
+    const incoming = payload.reactions || frame.reactions || previous.reactions || [];
+    const previousByEmoji = new Map((previous.reactions || []).map((reaction) => [reaction.emoji, reaction]));
+    const reactions = incoming.map((reaction) => ({ ...reaction, reacted: reaction.reacted ?? previousByEmoji.get(reaction.emoji)?.reacted ?? false }));
+    return { ...state, messages: mergeById(state.messages, { ...previous, reactions }) };
   }
   if (frame.type === 'poll_updated') {
     const messageId = frame.message_id ?? payload.message_id;
     const previous = state.messages[messageId] || { id: messageId };
-    const poll = payload.poll || frame.poll || payload;
+    const incomingPoll = payload.poll || frame.poll || payload;
+    // dcm's poll_updated frame is a viewer-independent projection
+    // (serialize_poll) — it never carries voted_option_ids, which dcm only
+    // ever adds to this viewer's own vote/create/close REST response. A
+    // frame arriving after a REST-derived vote is known must not wipe that
+    // locally-known selection; carry it forward when the frame is silent
+    // about it, never invert it from frame data that structurally can't
+    // contain it.
+    const previousVotedOptionIds = previous.poll?.voted_option_ids;
+    const poll = incomingPoll.voted_option_ids === undefined && previousVotedOptionIds
+      ? { ...incomingPoll, voted_option_ids: previousVotedOptionIds }
+      : incomingPoll;
     return { ...state, messages: mergeById(state.messages, { ...previous, poll }), polls: mergeById(state.polls, poll) };
   }
   if (frame.type === 'message_deleted') {
@@ -324,7 +354,14 @@ export function MessagingProvider({ children, filters = {}, activeConversationId
     patchMessage({ ...message, reactions: nextReactions });
     try {
       const result = active ? await api.removeReaction(messageId, emoji) : await api.addReaction(messageId, emoji);
-      patchMessage({ ...message, ...(result?.message || result), reactions: result?.reactions || result?.message?.reactions || nextReactions });
+      // Same aggregate-only shape as the realtime `reaction` frame (serialize_reactions
+      // never returns a per-viewer `reacted` flag) — merge the server's confirmed
+      // counts with the reacted flags nextReactions already computed correctly,
+      // rather than letting the reacted-less server array wipe them.
+      const confirmedCounts = result?.reactions || result?.message?.reactions;
+      const nextByEmoji = new Map(nextReactions.map((reaction) => [reaction.emoji, reaction]));
+      const reactions = confirmedCounts ? confirmedCounts.map((reaction) => ({ ...reaction, reacted: reaction.reacted ?? nextByEmoji.get(reaction.emoji)?.reacted ?? false })) : nextReactions;
+      patchMessage({ ...message, ...(result?.message || result), reactions });
       return result;
     } catch (error) { patchMessage(message); throw error; }
   }, [api, cache.messages, patchMessage]);

package/src/messaging/PollCard.jsx

@@ -12,10 +12,18 @@ export function PollCard({ message, canClose: canCloseProp }) {
   const [selected, setSelected] = useState([]);
   const [error, setError] = useState(null);
   const [busy, setBusy] = useState(false);
-  useEffect(() => setSelected((poll?.options || []).filter((option) => option.selected || option.voted).map((option) => option.id)), [poll]);
+  // voted_option_ids is a view-level enrichment dcm adds ONLY to the
+  // create/vote/close poll REST responses (serialize_poll itself, every
+  // message-list/thread load, and every poll_updated realtime frame never
+  // carry it) — so it's only ever present right after this viewer's own
+  // vote/create/close action. When it's absent (a freshly loaded or
+  // frame-updated poll), there's no way to know this viewer's vote from the
+  // payload alone; default to no selection rather than guessing or carrying
+  // over stale local state.
+  useEffect(() => setSelected(poll?.voted_option_ids ? [...poll.voted_option_ids] : []), [poll]);
   if (!poll) return null;
   const closed = Boolean(poll.closed_at);
-  const creatorId = poll.created_by?.id ?? poll.created_by;
+  const creatorId = poll.created_by_id ?? poll.created_by?.id ?? poll.created_by;
   const canClose = canCloseProp ?? poll.can_close ?? message?.can_close ?? message?.permissions?.can_close ?? (creatorId != null && creatorId === currentUser?.id);
   const changeSelection = (id) => setSelected((current) => poll.allow_multiple ? (current.includes(id) ? current.filter((value) => value !== id) : [...current, id]) : (current.includes(id) ? [] : [id]));
   const vote = async () => {
@@ -29,7 +37,15 @@ export function PollCard({ message, canClose: canCloseProp }) {
   };
   return <Paper variant="outlined" sx={{ p: 1 }} aria-label={t('MessagingPoll.LABEL')}><Stack spacing={0.5}>
     <Typography variant="subtitle2">{poll.question}</Typography>
-    {(poll.options || []).map((option) => <FormControlLabel key={option.id} disabled={closed || busy} control={<Checkbox checked={selected.includes(option.id)} onChange={() => changeSelection(option.id)} />} label={`${option.text || option.label} (${option.vote_count ?? option.votes_count ?? 0})`} />)}
+    {(poll.options || []).map((option) => {
+      // dcm's poll projection gives voter user ids only, never names — there
+      // is no user-directory endpoint (same structural limit already
+      // established for the DM candidate list). A count is always correct;
+      // marking the viewer's own vote is derivable from voted_option_ids.
+      const votedByMe = Boolean(poll.voted_option_ids?.includes(option.id));
+      const voterCount = option.voters?.length ?? option.vote_count ?? option.votes_count ?? 0;
+      return <FormControlLabel key={option.id} disabled={closed || busy} control={<Checkbox checked={selected.includes(option.id)} onChange={() => changeSelection(option.id)} />} label={`${option.text || option.label} (${option.vote_count ?? voterCount ?? 0})${votedByMe ? ` — ${t('MessagingPoll.YOU_VOTED')}` : ''}`} />;
+    })}
     {error && <Alert severity="error" role="alert">{error}</Alert>}
     <Stack direction="row" spacing={1}><Button size="small" onClick={vote} disabled={closed || busy}>{t('MessagingPoll.VOTE')}</Button>{canClose && !closed && <Button size="small" color="warning" onClick={close} disabled={busy}>{t('MessagingPoll.CLOSE')}</Button>}{closed && <Typography variant="caption">{t('MessagingPoll.CLOSED')}</Typography>}</Stack>
   </Stack></Paper>;

package/tests/ConversationList.test.jsx

@@ -17,7 +17,7 @@ describe('ConversationList', () => {
   let api;
   beforeEach(() => {
     api = {
-      listConversations: vi.fn().mockResolvedValue({ results: [{ id: 1, title: 'First', unread_count: 2, last_message: { body: 'Hello' } }], next_cursor: 'opaque-cursor' }),
+      listConversations: vi.fn().mockResolvedValue({ results: [{ id: 1, title: 'First', unread_count: 2, last_message: { excerpt: 'Hello' } }], next_cursor: 'opaque-cursor' }),
       getUnreadCount: vi.fn().mockResolvedValue({ unread_count: 2, by_conversation: { 1: 2 } }),
       listMessages: vi.fn().mockResolvedValue({ results: [] }),
       archiveConversation: vi.fn().mockResolvedValue({ id: 1, archived: true }),

package/tests/messagingContractConformance.test.js

@@ -21,6 +21,33 @@ const FRAME_EXEMPTIONS = {
   thread_read_state: 'Receipt synchronisation is outside MSG-3b.',
 };
 
+const BLOCKED_LINE = /\*\*BLOCKED\*\*/;
+const VERSION_PIN = /dcm \d+\.\d+\.\d+/;
+
+// A BLOCKED row without a version pin is exactly how MSG-3b's seven blocked
+// rows went stale unnoticed: dcm shipped what they needed mid-flight and the
+// WO-end review had no cheap way to tell. This check can't know whether dcm
+// has since shipped — it only guarantees the pin exists, which is what turns
+// the re-check into a two-minute job instead of an archaeology exercise.
+function unpinnedBlockedLines(markdown) {
+  return markdown.split('\n').filter((line) => BLOCKED_LINE.test(line) && !VERSION_PIN.test(line));
+}
+
+describe('messaging deviation-doc BLOCKED entries carry a dependency version pin', () => {
+  it('every BLOCKED line in docs/messaging-deviations.md names the dcm version it was blocked at', () => {
+    const markdown = fs.readFileSync(path.join(root, 'docs', 'messaging-deviations.md'), 'utf8');
+    expect(unpinnedBlockedLines(markdown)).toEqual([]);
+  });
+
+  // Required negative case (the WO is explicit: prove the check can fail,
+  // not only that the real file happens to pass).
+  it('flags a BLOCKED line that omits the version pin', () => {
+    const unpinned = '99. **BLOCKED** — some capability with no dependency version named.';
+    const pinned = '100. **BLOCKED** (blocked as of dcm 2.37.0) — some other capability.';
+    expect(unpinnedBlockedLines(`${unpinned}\n${pinned}`)).toEqual([unpinned]);
+  });
+});
+
 describe('messaging adapter and realtime contract conformance', () => {
   it('has a caller for every API export unless it has an explicit rationale', () => {
     const apiSource = fs.readFileSync(path.join(messagingRoot, 'api.js'), 'utf8');

package/tests/messagingInteractions.test.jsx

@@ -19,7 +19,9 @@ afterEach(cleanup);
 
 describe('messaging reactions and polls', () => {
   it('round-trips add and remove reactions through the cache-backed API', async () => {
-    const api = baseApi(); api.addReaction.mockResolvedValue({ reactions: [{ emoji: '👍', count: 1, reacted: true }] }); api.removeReaction.mockResolvedValue({ reactions: [] });
+    // serialize_reactions (dcm) never returns a per-viewer `reacted` flag —
+    // {emoji, count} only, in every context.
+    const api = baseApi(); api.addReaction.mockResolvedValue({ reactions: [{ emoji: '👍', count: 1 }] }); api.removeReaction.mockResolvedValue({ reactions: [] });
     const { rerender } = render(<MessagingProvider api={api} active={false}><ReactionBar message={{ id: 7, reactions: [{ emoji: '👍', count: 1, reacted: false }] }} /></MessagingProvider>);
     fireEvent.click(screen.getByRole('button', { name: 'MessagingReactions.TOGGLE' })); await waitFor(() => expect(api.addReaction).toHaveBeenCalledWith(7, '👍'));
     rerender(<MessagingProvider api={api} active={false}><ReactionBar message={{ id: 7, reactions: [{ emoji: '👍', count: 1, reacted: true }] }} /></MessagingProvider>);

package/tests/messagingLastMessagePreview.test.jsx

@@ -0,0 +1,93 @@
+// @vitest-environment jsdom
+import React from 'react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { cleanup, render, screen, waitFor } from '@testing-library/react';
+
+vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key) => key }) }));
+
+const realtimeSubscribers = new Map();
+vi.mock('../src/notifications/realtime', () => ({
+  useRealtime: () => ({
+    subscribe: (envelope, handler) => { realtimeSubscribers.set(envelope, handler); return () => realtimeSubscribers.delete(envelope); },
+    onReconnect: () => () => {},
+  }),
+}));
+function dispatchMessagingFrame(frame) { realtimeSubscribers.get('messaging')?.(frame); }
+
+import { ConversationList } from '../src/messaging/ConversationList';
+import { applyFrame, MessagingProvider, useMessaging } from '../src/messaging/MessagingProvider';
+
+function cache() { return { conversations: {}, messages: {}, threads: {}, polls: {}, reactions: {}, receipts: {}, unread: { unread_count: 0, by_conversation: {} }, cursors: { conversations: null, messages: {}, threads: {} } }; }
+
+afterEach(() => { cleanup(); realtimeSubscribers.clear(); });
+
+describe('last-message preview and conversation reorder', () => {
+  it('moves a conversation to the top and updates its preview from a server-shaped conversation_upsert frame', async () => {
+    const api = {
+      listConversations: vi.fn().mockResolvedValue({
+        results: [
+          { id: 1, title: 'Older', last_message_at: '2026-07-31T09:00:00Z', last_message: { excerpt: 'Old preview' } },
+          { id: 2, title: 'Newer', last_message_at: '2026-07-31T10:00:00Z', last_message: { excerpt: 'Newer preview' } },
+        ],
+        next_cursor: null,
+      }),
+      getUnreadCount: vi.fn().mockResolvedValue({ unread_count: 0, by_conversation: {} }),
+      listMessages: vi.fn().mockResolvedValue({ results: [] }),
+    };
+    render(<MessagingProvider api={api}><ConversationList /></MessagingProvider>);
+    await screen.findByText('Newer preview');
+    // Server-shaped conversation_upsert payload: serialize_conversation_core's
+    // real keys (id, last_message_at, last_message: {excerpt}), not a
+    // client-invented shape.
+    dispatchMessagingFrame({
+      envelope: 'messaging', type: 'conversation_upsert', event_id: 'evt-1', conversation_id: 1,
+      id: '1', last_message_at: '2026-07-31T12:00:00Z', last_message: { excerpt: 'Fresh reply' },
+    });
+    await screen.findByText('Fresh reply');
+    const rows = screen.getAllByRole('button').map((el) => el.textContent);
+    const olderIndex = rows.findIndex((text) => text.includes('Older'));
+    const newerIndex = rows.findIndex((text) => text.includes('Newer'));
+    expect(olderIndex).toBeGreaterThanOrEqual(0);
+    expect(olderIndex).toBeLessThan(newerIndex);
+  });
+
+  it('reflects an edited or deleted last message through a REST refresh', async () => {
+    const api = {
+      listConversations: vi.fn()
+        .mockResolvedValueOnce({ results: [{ id: 1, title: 'Chat', last_message: { excerpt: 'Original text' } }], next_cursor: null })
+        .mockResolvedValueOnce({ results: [{ id: 1, title: 'Chat', last_message: { excerpt: '' } }], next_cursor: null }),
+      getUnreadCount: vi.fn().mockResolvedValue({ unread_count: 0, by_conversation: {} }),
+      listMessages: vi.fn().mockResolvedValue({ results: [] }),
+    };
+    function Refresher() {
+      const { refreshConversations } = useMessaging();
+      return <button onClick={() => refreshConversations()}>refresh</button>;
+    }
+    render(<MessagingProvider api={api}><ConversationList /><Refresher /></MessagingProvider>);
+    await screen.findByText('Original text');
+    screen.getByText('refresh').click();
+    await waitFor(() => expect(screen.queryByText('Original text')).toBeNull());
+    await screen.findByText('MessagingList.NO_MESSAGES');
+  });
+
+  it('applies a real message_edited frame (dcm always attaches frame.message) and updates the edited body', () => {
+    const state = { ...cache(), messages: { 'msg-1': { id: 'msg-1', conversation_id: 'conv-1', body: 'Before' } } };
+    // dcm's publish_messaging_event (realtime.py) always attaches a full
+    // frame.message = serialize_message(message) for message_edited, never
+    // just {message_id} alone — verified against django_core_micha's actual
+    // realtime.py. This is the real wire shape, not a client-invented one.
+    const next = applyFrame(state, {
+      envelope: 'messaging', type: 'message_edited', event_id: 'evt-2', conversation_id: 'conv-1', message_id: 'msg-1',
+      message: { id: 'msg-1', conversation_id: 'conv-1', body: 'After edit', edited_at: '2026-07-31T12:00:00Z' },
+    }, null);
+    expect(next.messages['msg-1'].body).toBe('After edit');
+    expect(next.messages['msg-1'].edited_at).toBe('2026-07-31T12:00:00Z');
+  });
+
+  it('keys a message_edited frame by message_id defensively, even if a producer ever omitted frame.message', () => {
+    const state = { ...cache(), messages: { 'msg-1': { id: 'msg-1', conversation_id: 'conv-1', body: 'Before' } } };
+    const next = applyFrame(state, { envelope: 'messaging', type: 'message_edited', event_id: 'evt-3', conversation_id: 'conv-1', message_id: 'msg-1' }, null);
+    expect(next.messages['msg-1']).toBeTruthy();
+    expect(next.messages['conv-1']).toBeUndefined();
+  });
+});

package/tests/messagingPollRendering.test.jsx

@@ -0,0 +1,115 @@
+// @vitest-environment jsdom
+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 }) }));
+
+const realtimeSubscribers = new Map();
+vi.mock('../src/notifications/realtime', () => ({
+  useRealtime: () => ({
+    subscribe: (envelope, handler) => { realtimeSubscribers.set(envelope, handler); return () => realtimeSubscribers.delete(envelope); },
+    onReconnect: () => () => {},
+  }),
+}));
+function dispatchMessagingFrame(frame) { realtimeSubscribers.get('messaging')?.(frame); }
+
+import { AuthContext } from '../src/auth/AuthContext';
+import { PollCard } from '../src/messaging/PollCard';
+import { MessagingProvider, useMessaging } from '../src/messaging/MessagingProvider';
+
+function baseApi(overrides = {}) {
+  return {
+    listConversations: vi.fn().mockResolvedValue({ results: [] }), listMessages: vi.fn().mockResolvedValue({ results: [] }),
+    getUnreadCount: vi.fn().mockResolvedValue({ unread_count: 0, by_conversation: {} }),
+    votePoll: vi.fn(), closePoll: vi.fn(),
+    ...overrides,
+  };
+}
+
+// A genuinely server-shaped serialize_poll payload (django_core_micha
+// serializers.py:52-64): id/question/allow_multiple/closed_at/created_by_id,
+// options carry {id,text,order,vote_count,voters} — never selected/voted
+// flags, never created_by as an object. voted_option_ids is added ONLY on
+// the vote/create/close REST responses (views.py _poll_response), never here.
+function serverPoll(overrides = {}) {
+  return {
+    id: 'poll-1', question: 'Where should we meet?', allow_multiple: false, closed_at: null, created_by_id: 'user-9',
+    options: [
+      { id: 'opt-a', text: 'Library', order: 0, vote_count: 2, voters: ['user-1', 'user-2'] },
+      { id: 'opt-b', text: 'Cafe', order: 1, vote_count: 1, voters: ['user-3'] },
+    ],
+    ...overrides,
+  };
+}
+function State() { const { cache } = useMessaging(); return <output data-testid="cache">{JSON.stringify(cache)}</output>; }
+// PollCard is a "dumb" prop-driven component (matches Thread.jsx's usage,
+// which passes down cache.messages[id] directly) — it does not subscribe to
+// the cache itself. A live-frame test must read the message back out of the
+// cache, not hold a static prop, or it can never observe a frame update.
+function ConnectedPollCard({ messageId }) {
+  const { cache } = useMessaging();
+  return <PollCard message={cache.messages[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', () => {
+    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();
+  });
+
+  it('derives selection from voted_option_ids (REST-only) and marks the viewer\'s own vote', () => {
+    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();
+  });
+
+  it('does not clear or invert the viewer\'s own vote when a poll_updated frame carries no voted_option_ids', async () => {
+    const api = baseApi();
+    const votedPoll = serverPoll({ voted_option_ids: ['opt-a'] });
+    render(<MessagingProvider api={api} active={false}><ConnectedPollCard messageId="msg-1" /><State /></MessagingProvider>);
+    // Seed the cache the way a real poll message arrives: a `message` frame
+    // (kind: 'poll') carrying the just-voted poll, exactly as this viewer's
+    // 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));
+    // 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
+    // not touch this viewer's own selection.
+    dispatchMessagingFrame({
+      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());
+    // 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);
+  });
+
+  it('grants close only to the poll creator (created_by_id) or a host override, never a guess from an object shape', () => {
+    const poll = serverPoll({ created_by_id: 'user-9' });
+    const { rerender } = render(<AuthContext.Provider value={{ user: { id: 'user-9' } }}><MessagingProvider api={baseApi()} active={false}><PollCard message={{ id: 'msg-1', poll }} /></MessagingProvider></AuthContext.Provider>);
+    expect(screen.getByRole('button', { name: 'MessagingPoll.CLOSE' })).toBeTruthy();
+    rerender(<AuthContext.Provider value={{ user: { id: 'user-2' } }}><MessagingProvider api={baseApi()} active={false}><PollCard message={{ id: 'msg-1', poll }} /></MessagingProvider></AuthContext.Provider>);
+    expect(screen.queryByRole('button', { name: 'MessagingPoll.CLOSE' })).toBeNull();
+    rerender(<AuthContext.Provider value={{ user: { id: 'user-2' } }}><MessagingProvider api={baseApi()} active={false}><PollCard canClose message={{ id: 'msg-1', poll }} /></MessagingProvider></AuthContext.Provider>);
+    expect(screen.getByRole('button', { name: 'MessagingPoll.CLOSE' })).toBeTruthy();
+  });
+
+  it('disables voting once the poll is closed', () => {
+    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);
+    expect(screen.getByText('MessagingPoll.CLOSED')).toBeTruthy();
+  });
+});

package/tests/messagingReactionMerge.test.jsx

@@ -0,0 +1,79 @@
+// @vitest-environment jsdom
+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?.emoji ? `${key}:${options.emoji}:${options.count}` : key }) }));
+
+const realtimeSubscribers = new Map();
+vi.mock('../src/notifications/realtime', () => ({
+  useRealtime: () => ({
+    subscribe: (envelope, handler) => { realtimeSubscribers.set(envelope, handler); return () => realtimeSubscribers.delete(envelope); },
+    onReconnect: () => () => {},
+  }),
+}));
+function dispatchMessagingFrame(frame) { realtimeSubscribers.get('messaging')?.(frame); }
+
+import { ReactionBar } from '../src/messaging/ReactionBar';
+import { MessagingProvider, useMessaging } from '../src/messaging/MessagingProvider';
+
+function baseApi(overrides = {}) {
+  return {
+    listConversations: vi.fn().mockResolvedValue({ results: [] }), listMessages: vi.fn().mockResolvedValue({ results: [] }),
+    getUnreadCount: vi.fn().mockResolvedValue({ unread_count: 0, by_conversation: {} }),
+    addReaction: vi.fn(), removeReaction: vi.fn(),
+    ...overrides,
+  };
+}
+// ReactionBar is prop-driven (matches every other messaging leaf component) —
+// a live-frame test must read the message back out of the cache.
+function ConnectedReactionBar({ messageId }) {
+  const { cache } = useMessaging();
+  return <ReactionBar message={cache.messages[messageId]} />;
+}
+
+afterEach(() => { cleanup(); realtimeSubscribers.clear(); });
+
+describe('reaction frame/REST merge against the real aggregate-only contract', () => {
+  it('an unrelated reaction frame updates its own emoji without touching the viewer\'s known reacted state on other emoji', async () => {
+    const api = baseApi();
+    render(<MessagingProvider api={api} active={false}><ConnectedReactionBar messageId="msg-1" /></MessagingProvider>);
+    // Seed: the viewer has already reacted with 👍 (locally known — e.g. from
+    // an earlier REST confirmation), the server aggregate never carries that.
+    dispatchMessagingFrame({ envelope: 'messaging', type: 'message', event_id: 'seed', conversation_id: 'conv-1', message: { id: 'msg-1', conversation_id: 'conv-1', body: 'Hi', reactions: [{ emoji: '👍', count: 1, reacted: true }] } });
+    await waitFor(() => expect(screen.getByRole('button', { name: 'MessagingReactions.TOGGLE:👍:1' })).toBeTruthy());
+    // A different viewer reacts with 🎉 — dcm's real reaction frame shape
+    // (serialize_reactions): {emoji, count} only, never reacted, for the
+    // WHOLE aggregate list including 👍.
+    dispatchMessagingFrame({ envelope: 'messaging', type: 'reaction', event_id: 'evt-1', conversation_id: 'conv-1', message_id: 'msg-1', reactions: [{ emoji: '👍', count: 1 }, { emoji: '🎉', count: 1 }] });
+    await waitFor(() => expect(screen.getByRole('button', { name: 'MessagingReactions.TOGGLE:🎉:1' })).toBeTruthy());
+    const thumbsUp = screen.getByRole('button', { name: 'MessagingReactions.TOGGLE:👍:1' });
+    expect(thumbsUp.className.includes('MuiChip-colorPrimary')).toBe(true); // still marked as the viewer's own reaction
+  });
+
+  it('the viewer\'s own optimistic reacted flag survives its own REST confirmation, which returns an aggregate-only shape', async () => {
+    const api = baseApi({ addReaction: vi.fn().mockResolvedValue({ reactions: [{ emoji: '👍', count: 1 }] }) });
+    render(<MessagingProvider api={api} active={false}><ConnectedReactionBar messageId="msg-1" /></MessagingProvider>);
+    dispatchMessagingFrame({ envelope: 'messaging', type: 'message', event_id: 'seed', conversation_id: 'conv-1', message: { id: 'msg-1', conversation_id: 'conv-1', body: 'Hi', reactions: [] } });
+    await waitFor(() => screen.getByLabelText('MessagingReactions.ADD'));
+    fireEvent.click(screen.getByLabelText('MessagingReactions.ADD'));
+    fireEvent.click(screen.getByText('👍'));
+    await waitFor(() => expect(api.addReaction).toHaveBeenCalledWith('msg-1', '👍'));
+    await waitFor(() => {
+      const chip = screen.getByRole('button', { name: 'MessagingReactions.TOGGLE:👍:1' });
+      expect(chip.className.includes('MuiChip-colorPrimary')).toBe(true);
+    });
+  });
+
+  it('a duplicate event_id changes nothing', async () => {
+    const api = baseApi();
+    render(<MessagingProvider api={api} active={false}><ConnectedReactionBar messageId="msg-1" /></MessagingProvider>);
+    dispatchMessagingFrame({ envelope: 'messaging', type: 'message', event_id: 'seed', conversation_id: 'conv-1', message: { id: 'msg-1', conversation_id: 'conv-1', body: 'Hi', reactions: [{ emoji: '👍', count: 1 }] } });
+    await waitFor(() => screen.getByRole('button', { name: 'MessagingReactions.TOGGLE:👍:1' }));
+    dispatchMessagingFrame({ envelope: 'messaging', type: 'reaction', event_id: 'dup-1', conversation_id: 'conv-1', message_id: 'msg-1', reactions: [{ emoji: '👍', count: 2 }] });
+    await waitFor(() => expect(screen.getByRole('button', { name: 'MessagingReactions.TOGGLE:👍:2' })).toBeTruthy());
+    dispatchMessagingFrame({ envelope: 'messaging', type: 'reaction', event_id: 'dup-1', conversation_id: 'conv-1', message_id: 'msg-1', reactions: [{ emoji: '👍', count: 99 }] });
+    expect(screen.queryByRole('button', { name: 'MessagingReactions.TOGGLE:👍:99' })).toBeNull();
+    expect(screen.getByRole('button', { name: 'MessagingReactions.TOGGLE:👍:2' })).toBeTruthy();
+  });
+});

package/work-orders/MSG-3c.md

@@ -0,0 +1,378 @@
+# MSG-3c — deliver the rows MSG-3b left blocked against a stale dcm version
+
+Status: planned · Tier 2 · Target repo: `ui-core-micha` (main)
+**Binding spec:** `django-core-micha/docs/design/messaging-platform.md`. Extends the landed MSG-3b
+(published ucm 2.17.0), same convention as `MSG-2b` / `MSG-2c` / `NOTIF-8b`.
+
+---
+
+## Part A — Envelope (Expertenchat, 2026-07-31)
+
+### Goal
+
+Deliver the seven checklist rows MSG-3b correctly refused to fake — and which became buildable while
+MSG-3b was still running, without the session ever learning.
+
+### Why this WO exists
+
+MSG-3b started against dcm **2.36.1** and pinned that version explicitly in every BLOCKED entry of
+`docs/messaging-deviations.md`. dcm **2.37.0** (MSG-2c) landed mid-flight and delivered exactly what
+those entries said was missing. The WO closed — six chunks, per-chunk reviews, a clean WO-end
+`ui_reviewer` row-by-row cross-check — with seven rows recorded as blocked on "a future dcm work order"
+that had in fact already shipped.
+
+The WO-end review did not catch it because it cross-checked the checklist against **ucm's** landed code
+and took the dependency's state from the WO text. That is the third occurrence of one pattern in this
+workstream: a side verified against itself, with the seam assumed rather than read. See §5 of
+`notifications-messaging-roadmap.md`.
+
+**Credit where it is due, and the reason this was cheap to find:** MSG-3b wrote the dcm version into
+every BLOCKED entry. Without that pin the staleness would have been invisible instead of a two-minute
+check. Keep doing it — this WO makes it a rule.
+
+### Verified as deliverable against dcm 2.37.0
+
+Checked in `django-core-micha` at 2.37.0 before this WO was written:
+
+| Row | What MSG-3b recorded | Actual state in 2.37.0 |
+|---|---|---|
+| 38 | "dcm does not serialize `last_message`" | `serialize_last_message` exists; `last_message` is on the conversation payload |
+| 51 | "no poll read serialization" | `serialize_poll` exists, embedded in `serialize_message` for `kind == "poll"` |
+| 52 | "per-option voter names absent" | `voters` is in the poll projection (user ids, every conversation kind) |
+| 53 | "closed state depends on the absent poll contract" | `closed_at` is in the projection |
+| 56 | "dcm 2.36.1 does not emit `reaction`" | emitted (MSG-2c wired 8 frames) |
+| 57 | "dcm 2.36.1 does not emit `poll_updated`" | emitted |
+| 58 | "reorder/preview need the missing `last_message`" | available per row 38 |
+
+### Expected outcome
+
+The seven rows above delivered per the MSG-3b checklist's original descriptions:
+
+- **38 / 58** — real last-message preview in `ConversationList`, and list reorder plus preview refresh
+  on new / edited / deleted messages.
+- **51-53** — `PollCard` renders question, options, per-option `vote_count` and `voters`, closed state
+  with voting disabled. Read `voted_option_ids` **only** from the three poll REST responses; it is
+  deliberately absent from `serialize_poll` and from every realtime frame, so do not look for it there
+  and do not reconstruct it from a frame.
+- **56 / 57** — the existing `reaction` and `poll_updated` handlers stop being dead code; verify they
+  merge correctly now that frames actually arrive, rather than assuming the untested paths are right.
+- `docs/messaging-deviations.md` corrected: these seven entries move from BLOCKED to delivered, and the
+  closing paragraph stops claiming they need a future dcm WO.
+
+**Still legitimately BLOCKED, do not touch:** rows **27** (no readable thread reply state) and **42**
+(`external_key` not serialized). Both are real dcm gaps that MSG-2c did not cover; both are addressed by
+dcm `MSG-2d`, and a later ucm WO delivers them. MSG-3b assessed these two correctly.
+
+### The rule this WO adds
+
+**A BLOCKED row is re-verified against the live dependency at WO close, not at WO start.** Concretely:
+
+1. Every BLOCKED entry in `docs/messaging-deviations.md` must name the dependency version it was
+   blocked at — MSG-3b already did this; make it explicit policy.
+2. Extend the contract-conformance test from MSG-3b chunk 1: it must fail when a BLOCKED entry carries
+   no version pin. A test cannot check whether dcm has since shipped — it has no access to it — but it
+   can guarantee the pin exists, which is what makes the manual re-check a two-minute job instead of an
+   archaeology exercise.
+3. The WO-end review instruction changes: cross-check BLOCKED rows against the **dependency repo at its
+   current version**, not against the WO text.
+
+### Non-goals / do-not-touch
+
+Rows 27 and 42 (blocked on dcm `MSG-2d`). Any dcm change. Any app-side code. The jg migration (MSG-5).
+Search, typing, client→server WS. The decomposition and component boundaries established in MSG-3 and
+held through MSG-3b — new rendering lands in the component that owns it, and the ~400 LOC soft trigger
+and one-harness-entry-per-component rule stay in force. Do not re-open rows already delivered or
+already recorded as deliberate deviations.
+
+### Required tests to WRITE
+
+- **Poll rendering** against a server-shaped payload — the projection as `serialize_poll` actually emits
+  it, not a client-constructed object. This is the MSG-3b lesson repeated: the threading tests passed
+  for a year of nobody noticing precisely because they used client-shaped fixtures.
+- **`voted_option_ids` comes only from REST:** a `poll_updated` frame carrying no such key must not
+  clear or invert the viewer's own vote state.
+- **`reaction` / `poll_updated` frame merge:** an arriving frame updates the rendered message for a
+  viewer who did not cause it; a duplicate `event_id` changes nothing.
+- **Last-message preview and reorder:** a new message moves its conversation to the top and updates the
+  preview; an edit updates it; a delete empties it.
+- **Conformance test extension:** a BLOCKED entry without a version pin fails the build — assert the
+  negative case, not only the positive.
+- Existing ucm suites stay green.
+
+### Risks
+
+- **The dead handlers were never exercised.** Rows 56/57 are the paths most likely to contain latent
+  bugs, because they have never run against a real frame. Treat them as new code under test, not as
+  already-working code being unblocked.
+- **Fixture shape** — see the poll test above; the single most repeated failure in this workstream is a
+  test that passes because it invented its own payload.
+- Deviation-doc drift: correcting seven entries by hand while leaving two correct ones intact is exactly
+  where an over-eager edit removes a real blocker.
+
+### Preconditions
+
+dcm 2.37.0 published (met). Approval Gate #1 = operator go on this envelope. Rows 27/42 additionally
+require dcm `MSG-2d`, which is **not** a precondition for this WO.
+
+### Release
+
+One version bump + npm publish at WO end.
+
+### Execution directive
+
+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 a file;
+fall back to direct Claude implementation only on Codex quota / rate-limit / non-zero exit.
+
+### Mini-handover (pastable)
+
+Orchestrator: implement `work-orders/MSG-3c.md` in `ui-core-micha` (main). `git pull` first, read the WO
++ `django-core-micha/docs/design/messaging-platform.md`, then follow `orchestrate-codex` (Codex-first,
+own review per chunk, `ui_reviewer` at WO end, one publish at WO end). Rows 27 and 42 stay BLOCKED —
+they wait on dcm `MSG-2d`.
+
+---
+
+## Part B — Implementation map (Orchestrator)
+
+**Target repo working directory (all chunks):** `C:\Users\biglmi\Documents\webapps\ui-core-micha` (repo
+root). **Chunk plan (Orchestrator's own — the envelope named rows, not chunks):**
+
+1. Last-message preview + reorder (rows 38, 58).
+2. Poll rendering (rows 51-53).
+3. Reaction/poll_updated frame-merge fixes (row 56/57 verification) + the conformance-test extension +
+   the deviation-doc rewrite for all seven rows.
+
+**Verified against dcm 2.37.0 while scoping** (do not re-derive these, they're settled): `serialize_last_message`/
+`serialize_conversation_core` (`django-core-micha/src/django_core_micha/messaging/serializers.py:89-113`),
+`serialize_poll`/`serialize_reactions` (`serializers.py:41-46,52-64`), `_poll_response` — the ONLY place
+`voted_option_ids` is added, view-level, on top of `serialize_poll` (`views.py:32-36`, used by the
+create/vote/close poll responses only — never by `serialize_message`'s embedded poll, never by the
+`poll_updated` frame), and the three `conversation_upsert` publish sites (`services.py:95,120,165` —
+**new-message send only**; `edit_message`/`soft_delete_message` publish `message_edited`/`message_deleted`
+but never `conversation_upsert`, so a background conversation's list preview cannot live-update on an
+edit/delete of its last message without a dcm change — out of scope, verify via REST refresh instead,
+per chunk 1 below, do not invent a frame dcm doesn't send).
+
+**Two additional bugs found during this scoping, in files this WO already touches — fix them here rather
+than filing separately:**
+- `MessagingProvider.jsx:144` (`applyFrame`'s `message_edited` case): `mergeById(state.messages, payload)`
+  where `payload` (no `.message` sub-key on this frame — it only ever carries `message_id`) falls through
+  to the raw `frame` object, and `idOf()` (`MessagingProvider.jsx:45`, `item?.id ?? item?.conversation_id
+  ?? item?.message_id ?? item?.poll_id`) checks `.conversation_id` **before** `.message_id` — every frame
+  envelope carries `conversation_id`, so a `message_edited` frame gets keyed into the cache by the
+  conversation's id instead of the message's id, silently creating a bogus cache entry and never touching
+  the real message. Zero test coverage anywhere in this repo caught it. Fix in chunk 1 (same file as the
+  conversation-preview work): merge with an explicit `id: frame.message_id`, not the `idOf` fallback chain.
+- `MessagingProvider.jsx:315-330` (`toggleReaction`) and the `reaction` frame case (`:145-149`): `serialize_reactions`
+  (verified above) returns `[{emoji, count}]` **only, never a per-viewer `reacted` flag, ever** — not in
+  REST responses, not in frames, by design (aggregate-only). `toggleReaction`'s optimistic update
+  correctly sets `reacted: true/false` locally on the user's own click, but then the REST-confirm step
+  (`:327`, `reactions: result?.reactions || ...`) and the frame handler (`:148`, `payload.reactions ||
+  frame.reactions || ...`) both prefer the server's `reacted`-less array over the optimistic one — so
+  confirming the user's own toggle, or literally any other viewer's reaction frame arriving for the same
+  message, silently wipes every emoji's locally-known `reacted` state. This is exactly what row 56 asks
+  to be verified rather than assumed. Fix in chunk 3 (bundled with the frame-merge verification, same
+  underlying fix in both places): merge the server's `{emoji,count}` list with previously-known `reacted`
+  flags by emoji key, never wholesale-replace.
+
+### Chunk 1 — last-message preview and conversation reorder (rows 38, 58)
+
+**Files:** `src/messaging/MessagingProvider.jsx` (the `message_edited` bug fix above; verify — do not
+rebuild — the existing `conversation_upsert` handling at `:160` and `EMPTY_CACHE`/reducer shape),
+`src/messaging/ConversationList.jsx` (verify — likely no change needed, see below), new tests.
+
+**Much of rows 38/58 turns out to already be built.** MSG-3b wrote `applyFrame`'s `conversation_upsert`
+case and `ConversationList`'s `last_message?.body` rendering + `last_message_at` sort defensively,
+against the design doc's frame contract, before dcm actually sent the data. Now that dcm 2.37.0 does
+(`conversation_upsert` on new-message send carries the real `serialize_conversation_core`, including
+`last_message`), this is primarily a **verification + test-writing chunk**, not a rebuild — confirm this
+by reading `ConversationList.jsx:11` (`ordered()`, sorts by `last_message_at`) and `:71`
+(`conversation.last_message?.body`) before writing anything new. If you find either needs a real change
+beyond the `message_edited` fix above, make it — but don't assume a rewrite is needed without checking.
+
+**Row 58's "an edit updates it; a delete empties it"** must be tested via **REST refresh**
+(`refreshConversations()`), not a live frame — dcm does not publish `conversation_upsert` on edit/delete
+(see the verified call-site list above). `serialize_last_message` (`serializers.py:89-97`) already
+returns `excerpt: ""` for a deleted last message — that's the server behavior a refresh test should
+assert against, mocked with a server-shaped `listConversations` response, not invented.
+
+**Required tests (chunk 1):**
+- A `conversation_upsert` frame with a real `last_message` moves that conversation to the top of
+  `ConversationList` and updates its preview text — server-shaped fixture (`last_message: {body, ...}`,
+  not a client-invented shape).
+- A REST refresh reflecting an edited last message updates the preview; reflecting a deleted one
+  (`last_message.excerpt: ""` — check the actual field name your fixture should use, verify against
+  `serialize_last_message`'s real key, which is `excerpt` not `body`, at the `last_message` level —
+  don't assume the `Conversation.last_message` shape matches `Message`'s own `body` field name) shows
+  the empty/no-preview state.
+- The `message_edited` frame-keying regression: a `message_edited` frame with only `{message_id,
+  conversation_id}` (the real minimal shape — verified above, it carries no other fields) must patch the
+  message keyed by `message_id`, and must NOT create/touch any cache entry keyed by `conversation_id`.
+- Existing ucm suites stay green.
+
+**Progress contract / preamble:** identical to MSG-3b's chunks — `PLAN:`/`PROGRESS:`/`RESULT:` lines, no
+git operations, write-and-run-only-the-new-tests, leave the diff uncommitted for the orchestrator's
+review.
+
+**Mini-handover:** repo `C:\Users\biglmi\Documents\webapps\ui-core-micha`, branch `main`, WO
+`work-orders/MSG-3c.md` chunk 1 (Part B above). Follow `orchestrate-codex`.
+
+**Note on chunk 1's actual execution:** Codex reported `workspace is out of credits` on invocation
+(not a transient rate limit) — the orchestrator implemented chunk 1 directly per the Codex→Claude
+fallback rule, and an independent reviewer ran (mandatory once the orchestrator is the author). Chunks
+2/3 below should still attempt Codex first per the execution directive, but expect the same
+out-of-credits failure and fall back the same way if it recurs — don't loop retrying it.
+
+### Chunk 2 — poll rendering (rows 51-53)
+
+**Files:** `src/messaging/PollCard.jsx` (all three rows land here), new tests. `PollCard.jsx` was built
+in MSG-3 speculatively, before dcm's poll read contract existed — it guesses at field names, and two of
+those guesses are confirmed wrong against the real server shape.
+
+**Verified against dcm 2.37.0 (`django-core-micha/src/django_core_micha/messaging/serializers.py:52-64`,
+`views.py:32-36`):** `serialize_poll` returns `{id, question, allow_multiple, closed_at, created_by_id,
+options: [{id, text, order, vote_count, voters}]}` — `voters` is an array of user ids (row 52).
+`voted_option_ids` is added **only** by `_poll_response` (`views.py:32-36`), a view-level enrichment
+used **only** by the create/vote/close poll REST responses — it is never in `serialize_poll` itself,
+never in `serialize_message`'s embedded poll (message list/thread loads), and never in the
+`poll_updated` realtime frame. This is the WO's explicit "read `voted_option_ids` only from the three
+poll REST responses" instruction, now with the exact citations.
+
+**Two confirmed bugs in `PollCard.jsx` against this real shape — fix both:**
+1. `PollCard.jsx:18` — `const creatorId = poll.created_by?.id ?? poll.created_by;` assumes a
+   `created_by` object or scalar; the real field is `created_by_id` (a plain id, verified above).
+   `poll.created_by` is always `undefined` against the real server, so `creatorId` is always
+   `undefined`, so `canClose`'s only non-host-supplied fallback (`creatorId === currentUser?.id`,
+   `:19`) can never be true for a genuine creator — close is effectively broken for every poll unless a
+   host explicitly passes `canClose`. Fix: read `poll.created_by_id` directly.
+2. `PollCard.jsx:15` — `useEffect(() => setSelected((poll?.options || []).filter((option) =>
+   option.selected || option.voted)...` assumes per-option `selected`/`voted` flags that don't exist
+   anywhere in the real projection (verified above: options only ever have `{id, text, order,
+   vote_count, voters}`). Selection must instead derive from `poll.voted_option_ids` **when present**
+   (only true right after a create/vote/close REST call — the WO's explicit constraint) and otherwise
+   default to empty (a poll loaded via `listMessages`/`listThread`, or updated via a `poll_updated`
+   frame, correctly has no way to know the current viewer's vote state from that payload alone — do not
+   guess, do not carry over stale local state across a payload that structurally cannot contain the
+   answer).
+
+**Row 52 (voters) — not rendered at all today:** add voter identification per option. dcm only gives
+user **ids** (`option.voters: [user_id, ...]`), never names — there is no user-directory endpoint
+(same constraint already established for the DM candidate list in `MSG-3b`). Render what's actually
+available: a count (`voters.length`) is always correct; showing the *current viewer's own* vote as
+"you voted for this" is derivable from `voted_option_ids` after a REST action, or otherwise left
+unmarked. Do not invent a name lookup — this is a real, structural limit of the dcm contract, not
+something to work around client-side. If host-supplied user resolution is later wanted, that is a
+future WO's host-prop pattern, not this chunk's job.
+
+**Row 53 (closed state, voting disabled)** — `PollCard.jsx:17` (`const closed =
+Boolean(poll.closed_at)`) is already correct; verify the disabled-while-closed wiring on the vote
+controls (`:32`) still works once selection is correctly derived from `voted_option_ids`, and add
+coverage — this row was previously untested against a real payload shape too.
+
+**Required tests (chunk 2):**
+- Poll rendering against a genuinely server-shaped `serialize_poll` payload (all the real keys above,
+  not a client-invented one) — question, options, `vote_count`, some indication of `voters`.
+- `voted_option_ids` present only in the vote/create/close REST response correctly drives selection
+  state; a `poll_updated` frame carrying no `voted_option_ids` key must not clear or invert the
+  viewer's own already-known vote state (this is the WO's explicitly named required test).
+- Close permission: `created_by_id === currentUser.id` correctly enables the close control; a
+  non-creator without a host-supplied `canClose` override does not get it.
+- Closed poll disables voting.
+- Existing ucm suites (chunk 1 inclusive) stay green.
+
+**Progress contract / preamble:** identical to chunk 1's — `PLAN:`/`PROGRESS:`/`RESULT:` lines, no git
+operations, write-and-run-only-the-new-tests, leave the diff uncommitted for the orchestrator's review.
+
+**Mini-handover:** repo `C:\Users\biglmi\Documents\webapps\ui-core-micha`, branch `main`, WO
+`work-orders/MSG-3c.md` chunk 2 (Part B above, after chunk 1 is committed). Follow `orchestrate-codex`.
+
+**Note from chunk 2:** the same defect class row 56/57 ask to be verified for (a `poll_updated`/
+`reaction` frame's viewer-independent projection silently wiping viewer-specific state the client
+learned from a REST response) was ALSO found and fixed in `poll_updated`'s handler while writing
+chunk 2's own tests (`MessagingProvider.jsx`'s `poll_updated` case now preserves a previously-known
+`voted_option_ids` when the incoming frame lacks it). Chunk 3 must check whether the `reaction` case
+has the analogous issue — it very likely does (see below), don't assume it's fine because it's a
+similar shape to the code that turned out to be wrong.
+
+### Chunk 3 — reaction frame-merge fix, conformance-test extension, deviation-doc rewrite (rows 56, 57 + the WO's new rule)
+
+**Files:** `src/messaging/MessagingProvider.jsx` (`applyFrame`'s `reaction` case, and `toggleReaction`'s
+REST-confirm path — same underlying bug, two call sites), `tests/messagingContractConformance.test.js`
+(the version-pin extension), `docs/messaging-deviations.md` (full rewrite of the seven now-delivered
+rows + the two still-BLOCKED rows, each BLOCKED entry now carrying an explicit version pin), new tests.
+
+**The reaction bug — verified, not hypothetical:** `django-core-micha/src/django_core_micha/messaging/serializers.py:41-46`
+(`serialize_reactions`) returns `[{emoji, count}]` **only, never a per-viewer `reacted` flag, in any
+context** — not REST, not frames, by design (the design doc's "aggregate only" rule). `MessagingProvider.jsx`'s
+`toggleReaction` (around `:315-330`) correctly sets `reacted: true/false` optimistically on the current
+user's own click, but then:
+- its own REST-confirm step merges `reactions: result?.reactions || result?.message?.reactions ||
+  nextReactions` — `result.reactions` (the real server array) is truthy and picked first, wiping the
+  optimistic `reacted` flags for every emoji on that message.
+- `applyFrame`'s `reaction` case (`:154` area) merges `reactions: payload.reactions || frame.reactions
+  || previous.reactions || []` — same problem: any `reaction` frame arriving for this message (the
+  user's own echoed toggle, or literally any other viewer reacting with a different emoji) wholesale-
+  replaces the reactions array with the server's `reacted`-less version, wiping every previously-known
+  `reacted` flag on that message, not just the one that changed.
+
+**Fix both call sites the same way:** merge the server's `{emoji,count}` list with previously-known
+`reacted` flags by emoji key — never wholesale-replace. For each emoji in the incoming server list, if
+a previous entry for that same emoji had `reacted: true`, carry it forward (unless this merge IS the
+direct result of the current user's own toggle action, in which case the just-computed optimistic value
+is correct and already known — don't let the REST-confirm step regress what the optimistic update just
+set). An emoji present in the previous list but absent from the incoming one means its count hit zero
+and it should simply not appear (matches the existing pattern at `:320`, `.filter((reaction) =>
+reaction.count !== 0)`).
+
+**Required tests (chunk 3, reaction part):**
+- A `reaction` frame for an emoji the viewer has NOT reacted with updates its count without touching
+  the viewer's `reacted` state on any OTHER emoji on the same message (the WO's explicitly named "an
+  arriving frame updates the rendered message for a viewer who did not cause it" case).
+- The viewer's own optimistically-set `reacted: true` on one emoji survives (a) the REST confirmation
+  of that same toggle, and (b) an unrelated `reaction` frame for a different emoji on the same message
+  arriving afterward.
+- A duplicate `event_id` changes nothing (verify the existing `seenEventsRef` de-dup in the provider's
+  `subscribe(...)` handler already covers this at the reducer-dispatch level — this may already be
+  correct and just need a test, not a code change; check before assuming otherwise).
+
+**Conformance-test extension (the WO's new rule, required, not optional):** add a check to
+`tests/messagingContractConformance.test.js` that reads `docs/messaging-deviations.md` and fails if any
+line containing `**BLOCKED**` does not also carry an explicit dependency-version pin (e.g. a regex for
+`dcm \d+\.\d+\.\d+` on that line or within its paragraph — check the actual final wording you land on
+in the doc rewrite below and match the regex to it, don't write the regex first and hope the prose
+matches). **Verified: this check does not currently exist, and would currently fail** — as of this
+WO's start, rows 27/38/42/51/52/53/58's `**BLOCKED**` lines in `docs/messaging-deviations.md` do NOT
+carry a version pin (only the doc's intro sentence and rows 56/57 happen to mention "dcm 2.36.1"); only
+rewriting the doc's BLOCKED rows to each name the version fixes this. **Required negative-case test**
+(the WO is explicit: "assert the negative case, not only the positive"): construct a small in-memory
+BLOCKED line missing a version pin and assert the check's own logic flags it — don't only test that the
+real file passes, prove the check can fail.
+
+**`docs/messaging-deviations.md` rewrite — the WO's central deliverable for this chunk:**
+- Rows 38, 51, 52, 53, 56, 57, 58 move from `BLOCKED` to their real delivered outcome (`OK`, matching
+  the pattern MSG-3b's own doc used for delivered rows) — each entry should reflect what was actually
+  built across chunks 1-3 of MSG-3c (last-message preview/reorder, poll rendering incl. the
+  `created_by_id`/`voted_option_ids` fixes, the `reaction`/`poll_updated` frame-merge fixes), not a
+  generic "delivered" note copy-pasted seven times.
+- Rows **27 and 42 stay BLOCKED** — do not touch their substance, only add the now-required version pin
+  if missing (e.g. "as of dcm 2.37.0" or whatever phrasing matches the new conformance-test regex).
+  These are real, still-open gaps (thread-receipt read state; `external_key` serialization) waiting on
+  a future dcm `MSG-2d`.
+- The closing "Required backend follow-up" paragraph (currently lists rows 27/38/42/51-53/56-58 as all
+  needing a future dcm WO) must be corrected to name only rows 27 and 42.
+- **Risk named in the WO, read before editing:** "correcting seven entries by hand while leaving two
+  correct ones intact is exactly where an over-eager edit removes a real blocker" — do not touch rows
+  27/42's substantive claims, only add the version pin to them if the doc rewrite's new house style
+  requires it project-wide.
+
+**Progress contract / preamble:** identical to prior chunks — `PLAN:`/`PROGRESS:`/`RESULT:` lines, no
+git operations, write-and-run-only-the-new-tests, leave the diff uncommitted for the orchestrator's
+review.
+
+**Mini-handover:** repo `C:\Users\biglmi\Documents\webapps\ui-core-micha`, branch `main`, WO
+`work-orders/MSG-3c.md` chunk 3 (Part B above, after chunk 2 is committed) — the WO's last content
+chunk. After this chunk's independent review and commit, run the WO-end `ui_reviewer` pass per the
+WO's changed instruction (cross-check BLOCKED rows against the dependency repo at its **current**
+version, not against the WO text), then one version bump + npm publish.