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

package/WORK_ORDERS.md

@@ -38,3 +38,4 @@ prefixed ID; never reuse a bare flat number across workstreams.
 | MSG-6c | Three MSG-3f/MSG-6 follow-on bugs: scrollbar, DM announcement icon, direct-conversation names | Reported live on jg-ferien staging right after MSG-3f/MSG-6 shipped: (1) a horizontal scrollbar appeared under short bubbles; (2) the Composer showed a broadcast/announcement icon even in a 1:1 direct conversation; (3) direct conversations showed the generic "Unbenannte Unterhaltung" fallback instead of the counterpart's name. | 2026-08-02 | done | 50e966e | No WO file — three operator-reported bugs, fixed directly. **(1) Scrollbar**: `Thread.jsx`'s scroll `Box` had `overflowY: auto` only, leaving `overflowX` at its browser-promoted `auto` default — any few-px overflow anywhere produced a persistent horizontal scrollbar. Fixed with explicit `overflowX: hidden`, plus `MessageBubble.jsx`'s meta row got `flexWrap`/`minWidth: 0` so it can't force the shrink-to-content bubble wider than its `maxWidth` cap. `ui_reviewer` pass 1 found a real P1 regression risk in this fix: MSG-3f's overflow icon (`top: -12, right: -12`) could get clipped by the new `overflowX: hidden` for own/right-aligned bubbles in a short conversation with no vertical scrollbar (the exact scenario in the original bug screenshot) — fixed with extra right padding (moved onto the inner message `Stack`, not the outer scroll container, after `ui_reviewer` pass 2 flagged a P3 cosmetic side effect where the shared container's asymmetric padding skewed the centered "Load older" button; both re-verified live in the harness: no clipping with 8.8px margin, "Load older" back to 0px off-center). **(2) Announcement icon**: `Composer` now accepts a `conversation` prop; `canAnnounce = allowAnnouncement && conversation?.kind !== 'direct'` gates both the icon and the dialog — backward compatible (a host not passing `conversation` behaves exactly as before). **(3) Unnamed conversations**: `ConversationList.jsx`'s `titleOf` now tries a new optional `resolveDirectUserName(other_user_id)` host resolver before falling back to the generic label, consuming dcm's new `other_user_id` field (see django-core-micha `MSG-6b`) — bare id only, ucm still resolves no names itself. Independent `reviewer`: no findings (both passes). Scoped gate: 90/90 across 14 test files. Published as npm 2.21.1, verified live. jg-ferien pin bumped 2.21.0→2.21.1 and wired: `conversation` prop passed to `Composer`, `resolveDirectUserName` supplied from jg's existing DM-candidate data (best-effort — a counterpart no longer among current candidates, e.g. a lapsed shared event, falls back to the generic label; accepted gap, not chased). |
 | MSG-3f | Compact chat-bubble message layout | A one-word message currently renders as **six stacked rows** (~260px): `MessageBubble`'s vertical `Stack spacing={0.75}` gives every element its own full-width row — meta line, body, `ReactionBar`, the reply control (a full MUI `Button`, hence "Antworten" centred on its own line), the overflow `IconButton`, and `children` where the host's `ReadTicks` lands as a "Zugestellt an 0" text line. Rebuild as WhatsApp-style bubbles: own right-aligned and tinted, incoming left-aligned and neutral, shrink-to-content; **timestamp and status icons inline at the end of the final text line** (this is the line-count fix, everything else is cosmetic); status as tick icons instead of text, own messages only; reply/react/edit/delete/copy collapsed into one hover-or-long-press menu; reaction chips overlapping the bubble edge; reply quote as a tinted block inside the bubble. **Acceptance: a short message with no reactions/attachments/quote occupies at most TWO visual lines** (text plus, at most, a narrow right-aligned meta line inside the bubble) — down from six. | 2026-08-02 | done | 1cd777b | Envelope + map: [work-orders/MSG-3f.md](work-orders/MSG-3f.md). Independent `reviewer`: no findings. `ui_reviewer` pass 1 (static-only, no browser tooling that session): one P2 (U1) — the touch-tap reveal (`actionsVisible`) had no dismiss path, permanently pinning the overflow icon visible after any click that bubbled to the bubble (poll option, announcement link, reply quote), violating the "no visible affordance at rest" requirement; one P3 (U2, a consequence of U1). Fixed by the Orchestrator: a `bubbleRef` spanning the Paper + reaction-picker sibling, plus a document-level capture-phase `pointerdown` listener that dismisses `actionsVisible` on any outside interaction — live-verified in the running dev harness (reveal, dismiss-on-outside-click, and reaction-chip-click-does-not-dismiss all confirmed via DOM/computed-style inspection; screenshot tooling was unavailable this session, verification was structural/computed-style based). `ui_reviewer` pass 2 (re-review of the fix): confirmed the fix sound (event-phase ordering, per-instance isolation, cleanup all correct), but found one more gap (U3, P2) — no regression test pinned the dismiss behavior. Closed by adding two tests to `tests/messagingMessageActions.test.jsx`: outside-click dismiss + reaction-chip-does-not-dismiss, and cross-instance isolation (two bubbles, revealing one doesn't affect the other). Scoped gate: 42/42 passing across all 7 named test files. Acceptance criterion verified live: a short incoming direct-conversation message (no sender name, no reactions) renders at exactly 2 visual lines, 78px total height (down from ~260px). Published as npm 2.21.0, verified live on the registry. New `ui-core-micha-dev-harness` launch.json entry added (port 5140) for this and future ucm visual-verification WOs. | Approval Gate #1 granted by the operator 2026-08-02, who also supplied WhatsApp reference screenshots; the envelope records what those pin down beyond the prose (meta rides the LAST line of a multi-line body, not a line of its own; incoming messages carry no status icon at all; **no** action affordance visible at rest; meta visually recessed with read state carried by tick colour). **Tier 2** — shared-core, and an opinionated visual decision imposed on every future ucm messaging consumer. Acceptable now because jg-ferien is the only messaging consumer today (spesix deferred per the messaging-centralization course correction), so it lands with one adopter instead of being retrofitted — but jg vocabulary/layout assumptions must not leak in, same line MSG-3d drew for `external_key`. **Two non-negotiables:** every icon keeps the text it replaced as its accessible name (no i18n key deleted just because its text stopped rendering), and the action affordance must be keyboard-operable without hover or long-press — today's `opacity: 0` hover-only menu is unreachable on touch AND invisible to keyboard users, and reproducing that pre-existing defect is not acceptable. **Two deliberate cost-cuts by the operator (2026-08-02), both after being shown what they cost:** (1) the meta does **not** have to ride the last text line — inside the bubble and right-aligned is enough, a trailing meta line is fine; the inline pattern is listed as a risk to be *avoided*, not managed. (2) **No long-press and no swipe** — desktop uses hover plus keyboard focus (`opacity: 0` does not remove an element from the tab order, so a `:focus-within` rule closes the keyboard half cheaply), touch uses a plain tap on the bubble; React expands the existing `ReactionBar` emoji row rather than being nested inside the MUI `Menu`, which does not nest gracefully. **Trap found while scoping:** today the whole menu is gated on `canAct` (own message or moderator) because it only held Edit/Delete/Copy — once Reply lives there an **incoming** message needs a menu too, so there are two variants (any message: Reply/React/Copy; actionable message: plus Edit/Delete). Getting this wrong makes replying to anyone else impossible and will not surface in a fixture containing only own messages. Remaining risk: announcements/polls/attachments also render through this bubble and will look broken if only plain text is considered. **Read-status observation, deliberately NOT a precondition:** `ReadTicks` fetches per message and dcm's `serialize_message` carries no read state, so a thread fires one REST call per own message; tick icons make it more visible but not worse (`canShowReadTicks` already bounds it to own messages, deliberately). Putting the delivered/read aggregate on `serialize_message` — viewer-independent, exactly as `reply_count`/`last_reply_at` ride it since MSG-3d — would remove the fan-out and is a worthwhile dcm follow-up, but gating a UI fix behind a dcm release is the wrong trade. Deferred: swipe-to-reply, and the (also tall) Composer. Independent of MSG-3e — different files, but coordinate version bumps if both are in flight. |
 | MSG-6e | Messaging surface defects found by click-through: timestamps, poll cache key, read-state frames, double read-marking, plurals | Six independent defects reproduced in a running app: (A) `MessageBubble.jsx:133` formats with a bare `toLocaleString()` — runtime locale, not i18next's, and the full date instead of `HH:MM` + a day separator; (B) `createConversationPoll` (`MessagingProvider.jsx:403`) does `poll?.message \|\| poll`, but dcm's `_poll_response` has no `message` key, so a phantom entry is cached under the POLL id with no `created_at`; (C) `applyFrame` discards dcm's `read_state`/`delivered`/`thread_read_state` frames; (D) `markConversationRead` fires twice per open (Thread's useEffect + ConversationList's onClick); (E) `SHOW_REPLIES` has no plural forms. | 2026-08-03 | done | 3c7cfbd | Envelope: [work-orders/MSG-6e.md](work-orders/MSG-6e.md). **Reviewed independently: `reviewer` + `ui_reviewer` (requested per envelope for scope A), both clean after one fix round.** Fix round 1 closed a **P1** (`reviewer`): the read-state receipt fix only worked through `recipient_detail`, which dcm never returns for direct (1:1) conversations — the most common case — so `ReadTicks` silently never updated for DMs; fixed by deriving the receipt from `cache.receipts` keyed by `conversation.other_user_id` for the direct case. **Scope C landed narrower than the original envelope** (see the WO's "OPERATOR DECISIONS" section): only `read_state`/`thread_read_state` are handled — `delivered` was deliberately left out, since `django-core-micha` MSG-7 (same release) retires its only publisher (`mark_delivered`). **Not fixed, tracked as follow-ups (P2/P3, `ui_reviewer`, non-blocking):** the day-separator is a bespoke `Divider`+`Typography` pair rather than reusing `LoginForm.jsx`'s existing divider-with-label convention; the separator text has no `nowrap` guard (unlike `MessageBubble`'s timestamp); the first day in a thread never gets a separator (matches the WO's literal spec, not a deviation). Full suite 215→222 passed, 0 failed; `tsc` clean. jg's pin bump is a separate step, still NOT part of this WO — jg also needs `django-core-micha` MSG-7. **B is the one that corrupts state and the most instructive:** the `\|\| poll` fallback turns a wrong assumption about the response shape into silent data corruption instead of an error — observed as a fresh poll rendering with no timestamp and sorting to the TOP of the timeline, above messages from two days earlier, because `chronological()` sorts on `new Date(undefined)` → NaN. Correct after reload. **Explicit non-goal: do NOT touch `isOwn`/`canShowReadTicks`/`senderName`** — the own/incoming alignment, missing ticks and "Unbekannte Person" all trace to dcm never sending a `sender` object; ucm's code is already correct (`MessageBubble.jsx:100/108/109` implements the alignment in full, it just never sees `isOwn === true`). That fix is `django-core-micha` MSG-7. **Ordering caveat on C:** jg MSG-9 finding 1 (live WS push ~10 min late) is undiagnosed — handling frames that do not arrive fixes nothing, so do C last and report if finding 1 is still open. jg's pin bump is NOT part of this WO: jg also needs dcm MSG-7, and bumping one alone leaves the surface half-fixed. |
+| MSG-6f | `titleOf` never calls the host resolver for a broadcast; the read ticks claim a delivery that does not exist | (A) `ConversationList.jsx` `titleOf()` gates the host callback on `conversation.kind === 'managed'`, so jg-ferien MSG-10's correct broadcast branch in `resolveManagedConversationLabel` is **unreachable from the list** — the row still falls through to `MessagingList.UNTITLED`. (B) dcm MSG-7 removed `delivered_count` from `read-status`, but `ReadTicks.jsx` still renders `t('MessagingReadTicks.DELIVERED', { count: renderedStatus.delivered_count \|\| 0 })`, so `undefined \|\| 0` produces the identical "Zugestellt an 0" label as before — a claimed delivery with no data source behind it. (C) a viewer already sitting in an open thread when a new message lands is recorded as "not read" until they navigate away and back — the mount-effect only re-marks once per open. | 2026-08-03 | done | (pending push) | Envelope: [work-orders/MSG-6f.md](work-orders/MSG-6f.md); all three scopes released together per operator's critical-path directive (one release instead of two, since A and C never depended on dcm) — this also stands as the operator confirmation the envelope asked for before implementing B's vocabulary change. **A:** kind gate removed entirely from `titleOf()`; a host resolver returning `null` already means "no label", so gating duplicated a decision that belongs to the host. **B:** `DELIVERED` retired; dcm MSG-9 (published 2.40.0) added `read_count`/`recipient_count` to `read-status`, gated the same way as `recipient_detail` (non-direct, `read_receipt_detail`-eligible). `ReadTicks.jsx` now renders: counts present → a read ratio (`READ_RATIO`, e.g. "18/40"), no counts + `direct` → two-state tick (`SENT`/`ALL_READ`), no counts + non-direct → nothing (was a permanently-grey "always delivered" tick before). **C:** `Thread.jsx` now also subscribes to `MESSAGING_ENVELOPE` directly (independent of `MessagingProvider`'s own subscription — the registry supports multiple handlers per envelope) and re-marks read on a live `message` frame for the open conversation, skipped when the tab is hidden. **Reviewed independently: `reviewer` + `ui_reviewer`, both clean after one fix round.** Fix round 1 closed a **P1** (`reviewer`, self-caught during the fix, not shipped): the ratio was briefly recomputed client-side from `recipientDetail.filter(r => r.last_read_at).length` to make it "live-update" from `read_state` frames — this silently contradicts the WO's explicit instruction and is wrong, because `recipientDetail`'s `last_read_at` is never thresholded against the specific message's `created_at` the way dcm's own aggregate is (`last_read_at__gte=message.created_at`, dcm `services.py`); in a real group with history it would read as close to N/N regardless of who actually saw *this* message. Reverted to trusting dcm's `read_count`/`recipient_count` verbatim, with the trade-off documented in `ReadTicks.jsx`: the ratio no longer live-updates from a `read_state` frame, only on the next read-status fetch (unlike the DM tick and the per-person popover, both viewer/timestamp-relative facts that safely reuse `cache.receipts`). Also fixed a P3 (`ui_reviewer`): the ratio's `color="text.secondary"` diverged from the sibling meta row's `inherit` convention, changed to `inherit`. **Known, disclosed, non-blocking follow-up (`ui_reviewer` P2, not fixed here):** the DM tick's fixed `grey.500`/`primary.main` colour pair is not fully dark-mode contrast-neutral — verified by hand (WCAG-style luminance/contrast math against both themes' actual palette values, not just accepting the reviewer's claim): light-mode state separation ≈1.71:1, dark-mode ≈1.53:1 (worse, since `primary.main` lightens substantially in dark mode while `grey.500` is a fixed, non-mode-aware value). No single grey threads both themes well — the two themes need opposite-direction adjustments relative to their own inverted primary-blue lightness — and the icon shape (`Done` vs `DoneAll`) remains the primary, non-colour signal per the component's own design principle, so this is tracked rather than guessed at further without live visual verification. Test-infrastructure fix alongside C, not a behavioural change: `Thread.jsx`'s new `subscribe()` call broke 3 existing test files' single-captured-handler mock pattern (`frameHandler = handler`, overwritten per call) — converted to Set/Map-based multi-handler dispatch in `messagingChunk6.test.jsx`, `messagingMsg6.test.jsx`, `messagingThreadReceipts.test.jsx`. Full suite 234/234 (was 222), `tsc` clean. Published as npm 2.22.0 (pending). jg-ferien pin bump to `dcm 2.40.0` / `ucm 2.22.0` is a separate, subsequent step. |

package/dist/i18n/messagingTranslations.js

@@ -55,7 +55,8 @@ export const messagingTranslations = {
     'MessagingDirect.CANCEL': { de: 'Abbrechen', en: 'Cancel', fr: 'Annuler' },
     'MessagingDirect.START_ERROR': { de: 'Direktnachricht konnte nicht gestartet werden.', en: 'Direct message could not be started.', fr: 'Impossible de démarrer le message direct.' },
     'MessagingReadTicks.ALL_READ': { de: 'Von allen gelesen', en: 'Read by everyone', fr: 'Lu par tout le monde' },
-    'MessagingReadTicks.DELIVERED': { de: 'Zugestellt an {{count}}', en: 'Delivered to {{count}}', fr: 'Distribué à {{count}}' },
+    'MessagingReadTicks.SENT': { de: 'Gesendet', en: 'Sent', fr: 'Envoyé' },
+    'MessagingReadTicks.READ_RATIO': { de: '{{read}} von {{total}} gelesen', en: '{{read}} of {{total}} read', fr: '{{read}} sur {{total}} lu(s)' },
     'MessagingReadTicks.RECIPIENTS': { de: 'Lesebestätigungen', en: 'Read recipients', fr: 'Destinataires lus' },
     'MessagingComposer.LABEL': { de: 'Nachricht verfassen', en: 'Compose message', fr: 'Rédiger un message' },
     'MessagingComposer.MESSAGE': { de: 'Nachricht', en: 'Message', fr: 'Message' },

package/dist/messaging/ConversationList.js

@@ -15,7 +15,14 @@ import { ConversationLaunchers } from './ConversationLaunchers';
 // like a managed conversation's label above.
 function titleOf(conversation, t, resolveManagedLabel, resolveDirectUserName) {
     var _a, _b;
-    if (conversation.kind === 'managed' && resolveManagedLabel) {
+    // Not gated on kind === 'managed': a host resolver already returns null to
+    // mean "I have no label for this conversation" (the delegation contract
+    // this comment block describes above), so gating here duplicated a
+    // decision that belongs to the host and silently made the resolver
+    // unreachable for any kind the host later decided to label (found live:
+    // jg-ferien's resolver was taught to handle 'broadcast' too, but never got
+    // a chance to run because this gate excluded it).
+    if (resolveManagedLabel) {
         const label = resolveManagedLabel(conversation);
         if (label)
             return label;

package/dist/messaging/ReadTicks.js

@@ -1,11 +1,31 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import DoneAllOutlinedIcon from '@mui/icons-material/DoneAllOutlined';
 import DoneOutlinedIcon from '@mui/icons-material/DoneOutlined';
-import { ButtonBase, List, ListItem, Popover } from '@mui/material';
+import { ButtonBase, List, ListItem, Popover, Typography } from '@mui/material';
 import { useEffect, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { useMessaging } from './MessagingProvider';
-/** Renders only the aggregate receipt unless the server explicitly supplies permitted detail. */
+// Explicit tokens, not `inherit`/`primary` -- `inherit` inside the message
+// meta Stack resolved to `text.disabled`, which read too close to the "read"
+// state at the rendered 1rem icon size. The icon shape (Done vs DoneAll)
+// already differs, so the colour distinction is a second, independent signal
+// rather than the only one.
+const DM_SENT_COLOR = 'grey.500';
+const DM_READ_COLOR = 'primary.main';
+/**
+ * Shape-driven, no client-side role/permission branching: dcm only ever
+ * includes `read_count`/`recipient_count` inside the same `read_receipt_detail`-
+ * gated block as `recipient_detail`, and never for a `direct` conversation
+ * (the DM privacy carve-out). So "counts present" already means "team member,
+ * non-direct" -- checking anything else here would re-implement a decision
+ * dcm's response shape already makes.
+ *
+ * - counts present -> a read ratio ("18/40"), numeric, no icon ladder.
+ * - no counts, `direct` -> a two-state tick (sent / read).
+ * - no counts, non-direct -> no indicator at all (an ordinary participant in
+ *   a group; a permanently-grey tick here would be the "looks always
+ *   delivered" defect this component exists to remove).
+ */
 export function ReadTicks({ messageId, conversation }) {
     var _a;
     const { t } = useTranslation();
@@ -26,13 +46,35 @@ export function ReadTicks({ messageId, conversation }) {
         ? cache.receipts[`${conversation.id}:${conversation.other_user_id}`]
         : null;
     const allRead = status.all_read || Boolean(directReceipt === null || directReceipt === void 0 ? void 0 : directReceipt.last_read_at) || Boolean((recipientDetail === null || recipientDetail === void 0 ? void 0 : recipientDetail.length) && recipientDetail.every((recipient) => recipient.last_read_at));
-    const renderedStatus = Object.assign(Object.assign({}, status), { recipient_detail: recipientDetail, all_read: allRead });
-    const label = renderedStatus.all_read ? t('MessagingReadTicks.ALL_READ') : t('MessagingReadTicks.DELIVERED', { count: renderedStatus.delivered_count || 0 });
-    const StatusIcon = renderedStatus.all_read ? DoneAllOutlinedIcon : DoneOutlinedIcon;
+    const hasCounts = typeof status.read_count === 'number' && typeof status.recipient_count === 'number';
+    if (!hasCounts && (conversation === null || conversation === void 0 ? void 0 : conversation.kind) !== 'direct')
+        return null;
     // The server never returns DM detail; enforce the same carve-out defensively.
-    const detail = (conversation === null || conversation === void 0 ? void 0 : conversation.kind) === 'direct' ? null : renderedStatus.recipient_detail;
+    const detail = (conversation === null || conversation === void 0 ? void 0 : conversation.kind) === 'direct' ? null : recipientDetail;
     const recipients = (detail === null || detail === void 0 ? void 0 : detail.map((recipient) => recipient.display_name || recipient.username || recipient.user_id).filter(Boolean)) || [];
-    if (!recipients.length)
-        return _jsx(StatusIcon, { role: "img", "aria-label": label, color: renderedStatus.all_read ? 'primary' : 'inherit' });
-    return _jsxs(_Fragment, { children: [_jsx(ButtonBase, { "aria-label": label, "aria-haspopup": "dialog", "aria-expanded": Boolean(anchorEl), onClick: (event) => setAnchorEl(event.currentTarget), sx: { display: 'inline-flex', color: renderedStatus.all_read ? 'primary.main' : 'inherit' }, children: _jsx(StatusIcon, { "aria-hidden": "true" }) }), _jsx(Popover, { open: Boolean(anchorEl), anchorEl: anchorEl, onClose: () => setAnchorEl(null), children: _jsx(List, { "aria-label": t('MessagingReadTicks.RECIPIENTS'), children: recipients.map((recipient) => _jsx(ListItem, { children: recipient }, recipient)) }) })] });
+    if (hasCounts) {
+        // Read count/recipient_count exactly as dcm computed them -- do NOT
+        // recompute from recipientDetail here. dcm thresholds each participant's
+        // last_read_at against THIS message's created_at
+        // (`last_read_at__gte=message.created_at`, services.py); recipientDetail
+        // only carries each participant's raw, unthresholded last_read_at, and
+        // ReadTicks has no access to the message's own created_at to reproduce
+        // that comparison. Recomputing from recipientDetail (tried during
+        // implementation, caught in review) silently counted anyone who had ever
+        // read the conversation at any point as "read this message" -- in a real
+        // group with history, that reads as close to N/N regardless of who
+        // actually saw this specific message, the opposite of the WO's intent.
+        // The trade-off: unlike the DM tick and the per-person popover below
+        // (both viewer/timestamp-relative facts, not message-relative, so they
+        // safely reuse cache.receipts), this numeric ratio only updates on the
+        // next read-status fetch, not live from a read_state frame.
+        const label = t('MessagingReadTicks.READ_RATIO', { read: status.read_count, total: status.recipient_count });
+        const ratio = _jsxs(Typography, { component: "span", variant: "caption", color: "inherit", children: [status.read_count, "/", status.recipient_count] });
+        if (!recipients.length)
+            return _jsx("span", { role: "img", "aria-label": label, children: ratio });
+        return _jsxs(_Fragment, { children: [_jsx(ButtonBase, { "aria-label": label, "aria-haspopup": "dialog", "aria-expanded": Boolean(anchorEl), onClick: (event) => setAnchorEl(event.currentTarget), sx: { display: 'inline-flex' }, children: ratio }), _jsx(Popover, { open: Boolean(anchorEl), anchorEl: anchorEl, onClose: () => setAnchorEl(null), children: _jsx(List, { "aria-label": t('MessagingReadTicks.RECIPIENTS'), children: recipients.map((recipient) => _jsx(ListItem, { children: recipient }, recipient)) }) })] });
+    }
+    const label = allRead ? t('MessagingReadTicks.ALL_READ') : t('MessagingReadTicks.SENT');
+    const StatusIcon = allRead ? DoneAllOutlinedIcon : DoneOutlinedIcon;
+    return _jsx(StatusIcon, { role: "img", "aria-label": label, sx: { color: allRead ? DM_READ_COLOR : DM_SENT_COLOR } });
 }

package/dist/messaging/Thread.js

@@ -4,8 +4,9 @@ import { useCallback, useContext, useEffect, useMemo, useRef, useState } from 'r
 import { useTranslation } from 'react-i18next';
 import { AuthContext } from '../auth/AuthContext';
 import { MessageBubble } from './MessageBubble';
-import { useMessaging } from './MessagingProvider';
+import { MESSAGING_ENVELOPE, useMessaging } from './MessagingProvider';
 import { ReadTicks } from './ReadTicks';
+import { useRealtime } from '../notifications/realtime';
 function chronological(messages) { return [...messages].sort((left, right) => new Date(left.created_at || 0) - new Date(right.created_at || 0)); }
 function replyToId(message) { var _a; return (_a = message.reply_to_id) !== null && _a !== void 0 ? _a : message.reply_to; }
 // last_reply_at/reply_count are viewer-independent (always on serialize_message);
@@ -45,6 +46,7 @@ export function Thread({ conversationId, onReplyTargetChange, canModerateMessage
     const { t, i18n } = useTranslation();
     const { user } = useContext(AuthContext) || {};
     const { cache, loadMoreMessages, loadThreadReplies, markConversationRead, markThreadRead, refreshThread } = useMessaging();
+    const { subscribe } = useRealtime();
     const scrollRef = useRef(null);
     const wasNearBottomRef = useRef(true);
     const messageCountRef = useRef(0);
@@ -59,6 +61,32 @@ export function Thread({ conversationId, onReplyTargetChange, canModerateMessage
     const datedRoots = useMemo(() => roots.map((message, index) => ({ message, showDateSeparator: index > 0 && new Date(roots[index - 1].created_at).toDateString() !== new Date(message.created_at).toDateString() })), [roots]);
     useEffect(() => { if (conversationId != null)
         markConversationRead(conversationId).catch(() => { }); }, [conversationId, markConversationRead]);
+    // Re-mark read when a live message frame arrives for the conversation
+    // currently open -- without this, `read_count` biases downward for the
+    // person paying the most attention: the mount-effect above only fires once
+    // per open, so a viewer already sitting in the thread when a new message
+    // lands is recorded as "not read" until they navigate away and back.
+    // Subscribes independently of MessagingProvider's own subscription to the
+    // same envelope (the registry supports multiple handlers per envelope) so
+    // this stays a Thread-local concern, not a MessagingProvider reducer change.
+    // No sender check needed: dcm's `resolve_live_recipients(sender=actor)`
+    // already excludes the sender from the live fan-out, so a `message` frame
+    // for this conversation structurally cannot be the viewer's own send.
+    useEffect(() => {
+        if (conversationId == null)
+            return undefined;
+        return subscribe(MESSAGING_ENVELOPE, (frame) => {
+            var _a, _b;
+            if (frame.type !== 'message')
+                return;
+            const frameConversationId = (_a = frame.conversation_id) !== null && _a !== void 0 ? _a : (_b = frame.message) === null || _b === void 0 ? void 0 : _b.conversation_id;
+            if (String(frameConversationId) !== String(conversationId))
+                return;
+            if (document.visibilityState === 'hidden')
+                return;
+            markConversationRead(conversationId).catch(() => { });
+        });
+    }, [conversationId, markConversationRead, subscribe]);
     useEffect(() => { wasNearBottomRef.current = true; messageCountRef.current = 0; }, [conversationId]);
     // Nothing else in this component ever fetches messages for the conversation
     // actually being opened — `cache.messages` is otherwise only populated by a

package/package.json

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

package/src/i18n/messagingTranslations.ts

@@ -55,7 +55,8 @@ export const messagingTranslations = {
   'MessagingDirect.CANCEL': { de: 'Abbrechen', en: 'Cancel', fr: 'Annuler' },
   'MessagingDirect.START_ERROR': { de: 'Direktnachricht konnte nicht gestartet werden.', en: 'Direct message could not be started.', fr: 'Impossible de démarrer le message direct.' },
   'MessagingReadTicks.ALL_READ': { de: 'Von allen gelesen', en: 'Read by everyone', fr: 'Lu par tout le monde' },
-  'MessagingReadTicks.DELIVERED': { de: 'Zugestellt an {{count}}', en: 'Delivered to {{count}}', fr: 'Distribué à {{count}}' },
+  'MessagingReadTicks.SENT': { de: 'Gesendet', en: 'Sent', fr: 'Envoyé' },
+  'MessagingReadTicks.READ_RATIO': { de: '{{read}} von {{total}} gelesen', en: '{{read}} of {{total}} read', fr: '{{read}} sur {{total}} lu(s)' },
   'MessagingReadTicks.RECIPIENTS': { de: 'Lesebestätigungen', en: 'Read recipients', fr: 'Destinataires lus' },
   'MessagingComposer.LABEL': { de: 'Nachricht verfassen', en: 'Compose message', fr: 'Rédiger un message' },
   'MessagingComposer.MESSAGE': { de: 'Nachricht', en: 'Message', fr: 'Message' },

package/src/messaging/ConversationList.jsx

@@ -15,7 +15,14 @@ import { ConversationLaunchers } from './ConversationLaunchers';
 // name — so a direct conversation's counterpart name is host-supplied, exactly
 // like a managed conversation's label above.
 function titleOf(conversation, t, resolveManagedLabel, resolveDirectUserName) {
-  if (conversation.kind === 'managed' && resolveManagedLabel) {
+  // Not gated on kind === 'managed': a host resolver already returns null to
+  // mean "I have no label for this conversation" (the delegation contract
+  // this comment block describes above), so gating here duplicated a
+  // decision that belongs to the host and silently made the resolver
+  // unreachable for any kind the host later decided to label (found live:
+  // jg-ferien's resolver was taught to handle 'broadcast' too, but never got
+  // a chance to run because this gate excluded it).
+  if (resolveManagedLabel) {
     const label = resolveManagedLabel(conversation);
     if (label) return label;
   }

package/src/messaging/ReadTicks.jsx

@@ -1,12 +1,33 @@
 import DoneAllOutlinedIcon from '@mui/icons-material/DoneAllOutlined';
 import DoneOutlinedIcon from '@mui/icons-material/DoneOutlined';
-import { ButtonBase, List, ListItem, Popover } from '@mui/material';
+import { ButtonBase, List, ListItem, Popover, Typography } from '@mui/material';
 import { useEffect, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 
 import { useMessaging } from './MessagingProvider';
 
-/** Renders only the aggregate receipt unless the server explicitly supplies permitted detail. */
+// Explicit tokens, not `inherit`/`primary` -- `inherit` inside the message
+// meta Stack resolved to `text.disabled`, which read too close to the "read"
+// state at the rendered 1rem icon size. The icon shape (Done vs DoneAll)
+// already differs, so the colour distinction is a second, independent signal
+// rather than the only one.
+const DM_SENT_COLOR = 'grey.500';
+const DM_READ_COLOR = 'primary.main';
+
+/**
+ * Shape-driven, no client-side role/permission branching: dcm only ever
+ * includes `read_count`/`recipient_count` inside the same `read_receipt_detail`-
+ * gated block as `recipient_detail`, and never for a `direct` conversation
+ * (the DM privacy carve-out). So "counts present" already means "team member,
+ * non-direct" -- checking anything else here would re-implement a decision
+ * dcm's response shape already makes.
+ *
+ * - counts present -> a read ratio ("18/40"), numeric, no icon ladder.
+ * - no counts, `direct` -> a two-state tick (sent / read).
+ * - no counts, non-direct -> no indicator at all (an ordinary participant in
+ *   a group; a permanently-grey tick here would be the "looks always
+ *   delivered" defect this component exists to remove).
+ */
 export function ReadTicks({ messageId, conversation }) {
   const { t } = useTranslation();
   const { cache, getMessageReadStatus } = useMessaging();
@@ -18,17 +39,43 @@ export function ReadTicks({ messageId, conversation }) {
     return () => { mounted = false; };
   }, [getMessageReadStatus, messageId]);
   if (!status) return null;
+
   const recipientDetail = status.recipient_detail?.map((recipient) => ({ ...recipient, last_read_at: cache.receipts[`${conversation?.id}:${recipient.user_id}`]?.last_read_at ?? recipient.last_read_at })) || status.recipient_detail;
   const directReceipt = conversation?.kind === 'direct' && conversation?.other_user_id != null
     ? cache.receipts[`${conversation.id}:${conversation.other_user_id}`]
     : null;
   const allRead = status.all_read || Boolean(directReceipt?.last_read_at) || Boolean(recipientDetail?.length && recipientDetail.every((recipient) => recipient.last_read_at));
-  const renderedStatus = { ...status, recipient_detail: recipientDetail, all_read: allRead };
-  const label = renderedStatus.all_read ? t('MessagingReadTicks.ALL_READ') : t('MessagingReadTicks.DELIVERED', { count: renderedStatus.delivered_count || 0 });
-  const StatusIcon = renderedStatus.all_read ? DoneAllOutlinedIcon : DoneOutlinedIcon;
+  const hasCounts = typeof status.read_count === 'number' && typeof status.recipient_count === 'number';
+
+  if (!hasCounts && conversation?.kind !== 'direct') return null;
+
   // The server never returns DM detail; enforce the same carve-out defensively.
-  const detail = conversation?.kind === 'direct' ? null : renderedStatus.recipient_detail;
+  const detail = conversation?.kind === 'direct' ? null : recipientDetail;
   const recipients = detail?.map((recipient) => recipient.display_name || recipient.username || recipient.user_id).filter(Boolean) || [];
-  if (!recipients.length) return <StatusIcon role="img" aria-label={label} color={renderedStatus.all_read ? 'primary' : 'inherit'} />;
-  return <><ButtonBase aria-label={label} aria-haspopup="dialog" aria-expanded={Boolean(anchorEl)} onClick={(event) => setAnchorEl(event.currentTarget)} sx={{ display: 'inline-flex', color: renderedStatus.all_read ? 'primary.main' : 'inherit' }}><StatusIcon aria-hidden="true" /></ButtonBase><Popover open={Boolean(anchorEl)} anchorEl={anchorEl} onClose={() => setAnchorEl(null)}><List aria-label={t('MessagingReadTicks.RECIPIENTS')}>{recipients.map((recipient) => <ListItem key={recipient}>{recipient}</ListItem>)}</List></Popover></>;
+
+  if (hasCounts) {
+    // Read count/recipient_count exactly as dcm computed them -- do NOT
+    // recompute from recipientDetail here. dcm thresholds each participant's
+    // last_read_at against THIS message's created_at
+    // (`last_read_at__gte=message.created_at`, services.py); recipientDetail
+    // only carries each participant's raw, unthresholded last_read_at, and
+    // ReadTicks has no access to the message's own created_at to reproduce
+    // that comparison. Recomputing from recipientDetail (tried during
+    // implementation, caught in review) silently counted anyone who had ever
+    // read the conversation at any point as "read this message" -- in a real
+    // group with history, that reads as close to N/N regardless of who
+    // actually saw this specific message, the opposite of the WO's intent.
+    // The trade-off: unlike the DM tick and the per-person popover below
+    // (both viewer/timestamp-relative facts, not message-relative, so they
+    // safely reuse cache.receipts), this numeric ratio only updates on the
+    // next read-status fetch, not live from a read_state frame.
+    const label = t('MessagingReadTicks.READ_RATIO', { read: status.read_count, total: status.recipient_count });
+    const ratio = <Typography component="span" variant="caption" color="inherit">{status.read_count}/{status.recipient_count}</Typography>;
+    if (!recipients.length) return <span role="img" aria-label={label}>{ratio}</span>;
+    return <><ButtonBase aria-label={label} aria-haspopup="dialog" aria-expanded={Boolean(anchorEl)} onClick={(event) => setAnchorEl(event.currentTarget)} sx={{ display: 'inline-flex' }}>{ratio}</ButtonBase><Popover open={Boolean(anchorEl)} anchorEl={anchorEl} onClose={() => setAnchorEl(null)}><List aria-label={t('MessagingReadTicks.RECIPIENTS')}>{recipients.map((recipient) => <ListItem key={recipient}>{recipient}</ListItem>)}</List></Popover></>;
+  }
+
+  const label = allRead ? t('MessagingReadTicks.ALL_READ') : t('MessagingReadTicks.SENT');
+  const StatusIcon = allRead ? DoneAllOutlinedIcon : DoneOutlinedIcon;
+  return <StatusIcon role="img" aria-label={label} sx={{ color: allRead ? DM_READ_COLOR : DM_SENT_COLOR }} />;
 }

package/src/messaging/Thread.jsx

@@ -4,8 +4,9 @@ import { useTranslation } from 'react-i18next';
 
 import { AuthContext } from '../auth/AuthContext';
 import { MessageBubble } from './MessageBubble';
-import { useMessaging } from './MessagingProvider';
+import { MESSAGING_ENVELOPE, useMessaging } from './MessagingProvider';
 import { ReadTicks } from './ReadTicks';
+import { useRealtime } from '../notifications/realtime';
 
 function chronological(messages) { return [...messages].sort((left, right) => new Date(left.created_at || 0) - new Date(right.created_at || 0)); }
 function replyToId(message) { return message.reply_to_id ?? message.reply_to; }
@@ -42,6 +43,7 @@ export function Thread({ conversationId, onReplyTargetChange, canModerateMessage
   const { t, i18n } = useTranslation();
   const { user } = useContext(AuthContext) || {};
   const { cache, loadMoreMessages, loadThreadReplies, markConversationRead, markThreadRead, refreshThread } = useMessaging();
+  const { subscribe } = useRealtime();
   const scrollRef = useRef(null);
   const wasNearBottomRef = useRef(true);
   const messageCountRef = useRef(0);
@@ -56,6 +58,27 @@ export function Thread({ conversationId, onReplyTargetChange, canModerateMessage
   const datedRoots = useMemo(() => roots.map((message, index) => ({ message, showDateSeparator: index > 0 && new Date(roots[index - 1].created_at).toDateString() !== new Date(message.created_at).toDateString() })), [roots]);
 
   useEffect(() => { if (conversationId != null) markConversationRead(conversationId).catch(() => {}); }, [conversationId, markConversationRead]);
+  // Re-mark read when a live message frame arrives for the conversation
+  // currently open -- without this, `read_count` biases downward for the
+  // person paying the most attention: the mount-effect above only fires once
+  // per open, so a viewer already sitting in the thread when a new message
+  // lands is recorded as "not read" until they navigate away and back.
+  // Subscribes independently of MessagingProvider's own subscription to the
+  // same envelope (the registry supports multiple handlers per envelope) so
+  // this stays a Thread-local concern, not a MessagingProvider reducer change.
+  // No sender check needed: dcm's `resolve_live_recipients(sender=actor)`
+  // already excludes the sender from the live fan-out, so a `message` frame
+  // for this conversation structurally cannot be the viewer's own send.
+  useEffect(() => {
+    if (conversationId == null) return undefined;
+    return subscribe(MESSAGING_ENVELOPE, (frame) => {
+      if (frame.type !== 'message') return;
+      const frameConversationId = frame.conversation_id ?? frame.message?.conversation_id;
+      if (String(frameConversationId) !== String(conversationId)) return;
+      if (document.visibilityState === 'hidden') return;
+      markConversationRead(conversationId).catch(() => {});
+    });
+  }, [conversationId, markConversationRead, subscribe]);
   useEffect(() => { wasNearBottomRef.current = true; messageCountRef.current = 0; }, [conversationId]);
   // Nothing else in this component ever fetches messages for the conversation
   // actually being opened — `cache.messages` is otherwise only populated by a

package/tests/ConversationList.test.jsx

@@ -79,6 +79,58 @@ describe('ConversationList', () => {
     expect(resolveDirectUserName).not.toHaveBeenCalled();
   });
 
+  it('calls resolveManagedLabel for a broadcast conversation, not just managed -- must fail against the kind-gated code (MSG-6f scope A)', async () => {
+    api.listConversations.mockResolvedValueOnce({
+      results: [{ id: 9, kind: 'broadcast', external_key: 'broadcast', title: null, last_message: { excerpt: 'Hi all' } }],
+      next_cursor: null,
+    });
+    const resolveManagedLabel = vi.fn((conversation) => (conversation.kind === 'broadcast' ? 'Event-Ankündigungen' : null));
+    renderList(api, { resolveManagedLabel });
+    await screen.findByText('Event-Ankündigungen');
+    expect(resolveManagedLabel).toHaveBeenCalledWith(expect.objectContaining({ id: 9, kind: 'broadcast' }));
+  });
+
+  it('falls through to the existing title chain unchanged when resolveManagedLabel returns null, for any kind', async () => {
+    api.listConversations.mockResolvedValueOnce({
+      results: [{ id: 10, kind: 'broadcast', title: null, last_message: { excerpt: 'Hi' } }],
+      next_cursor: null,
+    });
+    const resolveManagedLabel = vi.fn(() => null);
+    renderList(api, { resolveManagedLabel });
+    await screen.findByText('MessagingList.UNTITLED');
+    expect(resolveManagedLabel).toHaveBeenCalled();
+  });
+
+  it('a truthy resolveManagedLabel wins over resolveDirectUserName for a direct conversation -- documents the new precedence, not previously reachable when the gate excluded every kind but managed', async () => {
+    api.listConversations.mockResolvedValueOnce({
+      results: [{ id: 12, kind: 'direct', other_user_id: 42, title: null, last_message: { excerpt: 'Hi' } }],
+      next_cursor: null,
+    });
+    const resolveManagedLabel = vi.fn(() => 'Host label wins');
+    const resolveDirectUserName = vi.fn(() => 'Alex');
+    renderList(api, { resolveManagedLabel, resolveDirectUserName });
+    await screen.findByText('Host label wins');
+    // resolveManagedLabel is checked first, unconditionally -- a host whose
+    // resolver ever returns non-null for kind: 'direct' pre-empts the
+    // id-based resolveDirectUserName lookup entirely. Deliberate per the
+    // WO's delegation contract (a host is trusted to return null for kinds
+    // it doesn't handle), but was structurally impossible before this WO
+    // (the old kind === 'managed' gate excluded every other kind), so it is
+    // now a real, if host-controlled, precedence a resolver author must know.
+    expect(resolveDirectUserName).not.toHaveBeenCalled();
+  });
+
+  it('keeps managed event_all/event_team labelling unchanged (regression guard)', async () => {
+    api.listConversations.mockResolvedValueOnce({
+      results: [{ id: 11, kind: 'managed', external_key: 'event_all', title: null, last_message: { excerpt: 'Hi' } }],
+      next_cursor: null,
+    });
+    const resolveManagedLabel = vi.fn((conversation) => (conversation.external_key === 'event_all' ? 'Alle - Sommerlager' : null));
+    renderList(api, { resolveManagedLabel });
+    await screen.findByText('Alle - Sommerlager');
+    expect(resolveManagedLabel).toHaveBeenCalledWith(expect.objectContaining({ id: 11, kind: 'managed', external_key: 'event_all' }));
+  });
+
   it('wires mute and archive through participant APIs', async () => {
     renderList(api);
     await screen.findByText('First');

package/tests/Thread.test.jsx

@@ -18,7 +18,7 @@ function makeApi() {
     getUnreadCount: vi.fn().mockResolvedValue({ unread_count: 0, by_conversation: {} }),
     listMessages: vi.fn().mockResolvedValue({ results: [{ id: 2, conversation_id: 1, body: 'Visible message', created_at: '2026-07-31T10:00:00Z' }], next_cursor: 'signed-opaque-cursor' }),
     listThread: vi.fn().mockResolvedValue({ results: [] }),
-    getReadStatus: vi.fn().mockResolvedValue({ all_read: false, delivered_count: 2 }),
+    getReadStatus: vi.fn().mockResolvedValue({ all_read: false }),
   };
 }
 // No `activeConversationId` on the provider: this matches how jg-ferien
@@ -56,17 +56,17 @@ describe('messaging Thread surfaces', () => {
     expect(screen.queryByText('Stale secret')).toBeNull();
   });
 
-  it('renders aggregate read state and never exposes supplied recipient details for a direct conversation', async () => {
-    api.getReadStatus.mockResolvedValue({ all_read: false, delivered_count: 2, recipient_detail: [{ display_name: 'Private recipient' }] });
+  it('renders the two-state direct tick and never exposes supplied recipient details for a direct conversation', async () => {
+    api.getReadStatus.mockResolvedValue({ all_read: false, recipient_detail: [{ display_name: 'Private recipient' }] });
     render(<MessagingProvider api={api} active={false}><ReadTicks messageId={2} conversation={{ id: 1, kind: 'direct' }} /></MessagingProvider>);
-    await screen.findByLabelText('MessagingReadTicks.DELIVERED:2');
+    await screen.findByLabelText('MessagingReadTicks.SENT');
     expect(screen.queryByText('Private recipient')).toBeNull();
   });
 
-  it('renders supplied recipient detail for a non-direct conversation (the permitted case)', async () => {
-    api.getReadStatus.mockResolvedValue({ all_read: false, delivered_count: 2, recipient_detail: [{ display_name: 'Visible recipient' }] });
+  it('renders supplied recipient detail for a non-direct conversation with counts (the permitted case)', async () => {
+    api.getReadStatus.mockResolvedValue({ all_read: false, read_count: 1, recipient_count: 2, recipient_detail: [{ display_name: 'Visible recipient' }] });
     render(<MessagingProvider api={api} active={false}><ReadTicks messageId={2} conversation={{ id: 1, kind: 'group' }} /></MessagingProvider>);
-    const tick = await screen.findByLabelText('MessagingReadTicks.DELIVERED:2');
+    const tick = await screen.findByLabelText('MessagingReadTicks.READ_RATIO');
     fireEvent.click(tick);
     await screen.findByText('Visible recipient');
   });
@@ -100,8 +100,9 @@ describe('messaging Thread surfaces', () => {
     renderThread(api);
     await screen.findByLabelText('MessagingThread.TIMELINE');
     cleanup();
+    api.getReadStatus.mockResolvedValue({ all_read: false, read_count: 0, recipient_count: 3 });
     render(<MessagingProvider api={api} active={false}><ReadTicks messageId={2} conversation={{ id: 1, kind: 'group' }} /></MessagingProvider>);
-    await waitFor(() => expect(screen.getByLabelText('MessagingReadTicks.DELIVERED:2')).toBeTruthy());
+    await waitFor(() => expect(screen.getByLabelText('MessagingReadTicks.READ_RATIO')).toBeTruthy());
   });
 
   it('fetches and shows a conversation\'s historical messages on open, with no realtime frame or optimistic send involved', async () => {

package/tests/messagingChunk6.test.jsx

@@ -3,9 +3,14 @@ import React from 'react';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
 
-let frameHandler;
+// Thread.jsx (MSG-6f scope C) now subscribes to the messaging envelope
+// independently of MessagingProvider's own subscription -- a Set of handlers,
+// not a single captured variable, so frameHandler(...) still reaches every
+// current subscriber, matching the real registry's multi-handler support.
+let frameHandlers;
+function frameHandler(frame) { frameHandlers.forEach((handler) => handler(frame)); }
 vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key, options) => options?.count != null ? `${key}:${options.count}` : key, i18n: { language: 'en' } }) }));
-vi.mock('../src/notifications/realtime', () => ({ useRealtime: () => ({ subscribe: (_envelope, handler) => { frameHandler = handler; return () => {}; }, onReconnect: () => () => {} }) }));
+vi.mock('../src/notifications/realtime', () => ({ useRealtime: () => ({ subscribe: (_envelope, handler) => { frameHandlers.add(handler); return () => frameHandlers.delete(handler); }, onReconnect: () => () => {} }) }));
 
 import { Composer } from '../src/messaging/Composer';
 import { ConversationList } from '../src/messaging/ConversationList';
@@ -20,14 +25,15 @@ function makeApi(overrides = {}) {
     listMessages: vi.fn().mockResolvedValue({ results: [] }),
     listThread: vi.fn().mockResolvedValue({ results: [] }),
     getUnreadCount: vi.fn().mockResolvedValue({ unread_count: 0, by_conversation: {} }),
-    getReadStatus: vi.fn().mockResolvedValue({ all_read: false, delivered_count: 2 }),
+    getReadStatus: vi.fn().mockResolvedValue({ all_read: false }),
     markConversationRead: vi.fn().mockResolvedValue({}), markThreadRead: vi.fn().mockResolvedValue({}),
     createPoll: vi.fn().mockResolvedValue({}),
     ...overrides,
   };
 }
 
-afterEach(() => { cleanup(); vi.useRealTimers(); vi.restoreAllMocks(); frameHandler = undefined; });
+beforeEach(() => { frameHandlers = new Set(); });
+afterEach(() => { cleanup(); vi.useRealTimers(); vi.restoreAllMocks(); frameHandlers = new Set(); });
 
 describe('MSG-3b chunk 6', () => {
   it('renders localized relative list timestamps for now, minutes, hours, and days', async () => {
@@ -84,16 +90,17 @@ describe('MSG-3b chunk 6', () => {
     expect(screen.queryByText('Ava')).toBeNull();
   });
 
-  it('opens receipt recipients by click for non-direct conversations and never exposes direct details', async () => {
-    const api = makeApi({ getReadStatus: vi.fn().mockResolvedValue({ all_read: false, delivered_count: 2, recipient_detail: [{ display_name: 'Ava' }] }) });
+  it('opens receipt recipients by click for non-direct conversations with counts, and never exposes direct details', async () => {
+    const api = makeApi({ getReadStatus: vi.fn().mockResolvedValue({ all_read: false, read_count: 1, recipient_count: 2, recipient_detail: [{ display_name: 'Ava' }] }) });
     const view = render(<MessagingProvider api={api} active={false}><ReadTicks messageId={7} conversation={{ kind: 'group' }} /></MessagingProvider>);
-    const detail = await screen.findByRole('button', { name: 'MessagingReadTicks.DELIVERED:2' });
+    const detail = await screen.findByRole('button', { name: 'MessagingReadTicks.READ_RATIO' });
     fireEvent.click(detail);
     expect(await screen.findByText('Ava')).toBeTruthy();
     view.unmount();
+    api.getReadStatus.mockResolvedValue({ all_read: false, recipient_detail: [{ display_name: 'Ava' }] });
     render(<MessagingProvider api={api} active={false}><ReadTicks messageId={7} conversation={{ kind: 'direct' }} /></MessagingProvider>);
-    await screen.findByLabelText('MessagingReadTicks.DELIVERED:2');
-    expect(screen.queryByRole('button', { name: 'MessagingReadTicks.DELIVERED:2' })).toBeNull();
+    await screen.findByLabelText('MessagingReadTicks.SENT');
+    expect(screen.queryByRole('button', { name: 'MessagingReadTicks.READ_RATIO' })).toBeNull();
     expect(screen.queryByText('Ava')).toBeNull();
   });
 

package/tests/messagingCompactBubble.test.jsx

@@ -12,7 +12,7 @@ import { MessagingProvider } from '../src/messaging/MessagingProvider';
 import { ReadTicks } from '../src/messaging/ReadTicks';
 
 const api = () => ({
-  getReadStatus: vi.fn().mockResolvedValue({ all_read: false, delivered_count: 2 }),
+  getReadStatus: vi.fn().mockResolvedValue({ all_read: false }),
   getAttachment: vi.fn(), getAttachmentThumbnail: vi.fn(), addReaction: vi.fn(), removeReaction: vi.fn(),
   votePoll: vi.fn(), closePoll: vi.fn(),
 });
@@ -24,8 +24,8 @@ afterEach(cleanup);
 
 describe('compact message bubbles', () => {
   it('keeps the timestamp and own-message status icon inside the bubble and has no standalone plain-message controls', async () => {
-    const { container } = renderBubble({ id: 1, body: 'Hallo', sender: { id: 1, display_name: 'Me' }, created_at: '2026-08-02T10:00:00Z' }, { child: <ReadTicks messageId={1} conversation={{ kind: 'group' }} /> });
-    const tick = await screen.findByLabelText('MessagingReadTicks.DELIVERED:2');
+    const { container } = renderBubble({ id: 1, body: 'Hallo', sender: { id: 1, display_name: 'Me' }, created_at: '2026-08-02T10:00:00Z' }, { child: <ReadTicks messageId={1} conversation={{ kind: 'direct' }} /> });
+    const tick = await screen.findByLabelText('MessagingReadTicks.SENT');
     const paper = container.querySelector('[data-message-id="1"] .MuiPaper-root');
     expect(paper.contains(tick)).toBe(true);
     expect(paper.querySelector('[data-testid="message-meta"]')).toBeTruthy();

package/tests/messagingMsg6.test.jsx

@@ -1,11 +1,16 @@
 // @vitest-environment jsdom
 import React from 'react';
-import { afterEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
 
-let frameHandler;
+// Thread.jsx (MSG-6f scope C) now subscribes to the messaging envelope
+// independently of MessagingProvider's own subscription -- a Set of handlers,
+// not a single captured variable, so frameHandler(...) still reaches every
+// current subscriber, matching the real registry's multi-handler support.
+let frameHandlers;
+function frameHandler(frame) { frameHandlers.forEach((handler) => handler(frame)); }
 vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key, options) => options?.count != null ? `${key}:${options.count}` : key, i18n: { language: 'de-DE' } }) }));
-vi.mock('../src/notifications/realtime', () => ({ useRealtime: () => ({ subscribe: (_envelope, handler) => { frameHandler = handler; return () => {}; }, onReconnect: () => () => {} }) }));
+vi.mock('../src/notifications/realtime', () => ({ useRealtime: () => ({ subscribe: (_envelope, handler) => { frameHandlers.add(handler); return () => frameHandlers.delete(handler); }, onReconnect: () => () => {} }) }));
 
 import { MessageBubble } from '../src/messaging/MessageBubble';
 import { ConversationList } from '../src/messaging/ConversationList';
@@ -15,8 +20,9 @@ import { Thread } from '../src/messaging/Thread';
 import { messagingTranslations } from '../src/i18n/messagingTranslations';
 import { AuthContext } from '../src/auth/AuthContext';
 
-const api = (overrides = {}) => ({ listConversations: vi.fn().mockResolvedValue({ results: [{ id: 'c1', kind: 'group' }] }), listMessages: vi.fn().mockResolvedValue({ results: [] }), listThread: vi.fn().mockResolvedValue({ results: [] }), getUnreadCount: vi.fn().mockResolvedValue({ unread_count: 0, by_conversation: {} }), getReadStatus: vi.fn().mockResolvedValue({ all_read: false, delivered_count: 1, recipient_detail: [{ user_id: 'u2', display_name: 'Ava' }] }), markConversationRead: vi.fn().mockResolvedValue({}), ...overrides });
+const api = (overrides = {}) => ({ listConversations: vi.fn().mockResolvedValue({ results: [{ id: 'c1', kind: 'group' }] }), listMessages: vi.fn().mockResolvedValue({ results: [] }), listThread: vi.fn().mockResolvedValue({ results: [] }), getUnreadCount: vi.fn().mockResolvedValue({ unread_count: 0, by_conversation: {} }), getReadStatus: vi.fn().mockResolvedValue({ all_read: false, read_count: 0, recipient_count: 1, recipient_detail: [{ user_id: 'u2', display_name: 'Ava' }] }), markConversationRead: vi.fn().mockResolvedValue({}), ...overrides });
 const state = () => ({ conversations: {}, messages: {}, threads: {}, polls: {}, reactions: {}, receipts: {}, unread: { unread_count: 0, by_conversation: {} }, cursors: { conversations: null, messages: {}, threads: {} } });
+beforeEach(() => { frameHandlers = new Set(); });
 afterEach(cleanup);
 
 function PollHarness() { const { createConversationPoll, cache } = useMessaging(); return <><button onClick={() => createConversationPoll('c1', { question: 'Q' })}>create</button><output>{JSON.stringify(cache.messages)}</output></>; }
@@ -44,21 +50,30 @@ describe('MSG-6 messaging regressions', () => {
     expect(screen.getAllByTestId('day-separator')).toHaveLength(1);
   });
 
-  it('applies read and thread-read frames to cache and lets ReadTicks change without another REST call', async () => {
+  it('applies read frames to cache (for the per-person popover) but the group read ratio stays dcm\'s own numbers, not recomputed', async () => {
     const client = api();
     render(<MessagingProvider api={client} active={false}><ReadTicks messageId="m1" conversation={{ id: 'c1', kind: 'group' }} /></MessagingProvider>);
-    await screen.findByLabelText('MessagingReadTicks.DELIVERED:1');
+    const tick = await screen.findByLabelText('MessagingReadTicks.READ_RATIO');
+    expect(tick.textContent).toBe('0/1');
     act(() => frameHandler({ type: 'read_state', conversation_id: 'c1', user_id: 'u2', last_read_at: '2026-08-03T10:00:00Z' }));
-    await screen.findByLabelText('MessagingReadTicks.ALL_READ');
+    // Deliberate, documented trade-off (see ReadTicks.jsx): the numeric ratio
+    // is dcm's own read_count/recipient_count verbatim, never recomputed from
+    // recipientDetail -- recipientDetail has no way to threshold against
+    // this specific message's created_at, only dcm's own aggregate does.
+    // So a read_state frame updates the *popover's* per-person list (proven
+    // by the receipts assertion below) but the ratio digits only change on
+    // the next read-status fetch, same as before this frame arrived.
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    expect(screen.getByLabelText('MessagingReadTicks.READ_RATIO').textContent).toBe('0/1');
     expect(client.getReadStatus).toHaveBeenCalledTimes(1);
     const next = applyFrame(state(), { type: 'thread_read_state', root_id: 'root-1', user_id: 'u2', last_read_at: '2026-08-03T10:00:00Z' });
     expect(next.receipts['thread:root-1:u2'].last_read_at).toBe('2026-08-03T10:00:00Z');
   });
 
   it('updates direct-conversation ReadTicks from a read frame without another REST call', async () => {
-    const client = api();
+    const client = api({ getReadStatus: vi.fn().mockResolvedValue({ all_read: false }) });
     render(<MessagingProvider api={client} active={false}><ReadTicks messageId="m1" conversation={{ id: 'c1', kind: 'direct', other_user_id: 'u2' }} /></MessagingProvider>);
-    await screen.findByLabelText('MessagingReadTicks.DELIVERED:1');
+    await screen.findByLabelText('MessagingReadTicks.SENT');
     act(() => frameHandler({ type: 'read_state', conversation_id: 'c1', user_id: 'u2', last_read_at: '2026-08-03T10:00:00Z' }));
     await screen.findByLabelText('MessagingReadTicks.ALL_READ');
     expect(client.getReadStatus).toHaveBeenCalledTimes(1);

package/tests/messagingMsg6f.test.jsx

@@ -0,0 +1,155 @@
+// @vitest-environment jsdom
+import React from 'react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { act, cleanup, render, screen, waitFor } from '@testing-library/react';
+import { ThemeProvider, createTheme } from '@mui/material/styles';
+
+// Thread.jsx (scope C) subscribes to the messaging envelope independently of
+// MessagingProvider's own subscription -- a Set of handlers per envelope, not
+// one, so a dispatched frame reaches every current subscriber.
+let frameHandlers;
+function dispatchFrame(frame) { frameHandlers.forEach((handler) => handler(frame)); }
+vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key, options) => options && Object.keys(options).length ? `${key}:${JSON.stringify(options)}` : key, i18n: { language: 'en' } }) }));
+vi.mock('../src/notifications/realtime', () => ({
+  useRealtime: () => ({
+    subscribe: (_envelope, handler) => { frameHandlers.add(handler); return () => frameHandlers.delete(handler); },
+    onReconnect: () => () => {},
+  }),
+}));
+
+import { AuthContext } from '../src/auth/AuthContext';
+import { MessagingProvider } from '../src/messaging/MessagingProvider';
+import { ReadTicks } from '../src/messaging/ReadTicks';
+import { Thread } from '../src/messaging/Thread';
+
+const theme = createTheme();
+function withTheme(children) { return <ThemeProvider theme={theme}>{children}</ThemeProvider>; }
+
+function makeApi(overrides = {}) {
+  return {
+    listConversations: vi.fn().mockResolvedValue({ results: [] }),
+    listMessages: vi.fn().mockResolvedValue({ results: [] }),
+    listThread: vi.fn().mockResolvedValue({ results: [] }),
+    getUnreadCount: vi.fn().mockResolvedValue({ unread_count: 0, by_conversation: {} }),
+    markConversationRead: vi.fn().mockResolvedValue({}),
+    getReadStatus: vi.fn().mockResolvedValue({ all_read: false }),
+    ...overrides,
+  };
+}
+
+beforeEach(() => { frameHandlers = new Set(); });
+afterEach(cleanup);
+
+describe('MSG-6f scope B: read ratio vs two-state tick', () => {
+  it('4a: a direct conversation renders a two-state tick, and the two states resolve to visibly different colours', async () => {
+    const api = makeApi({ getReadStatus: vi.fn().mockResolvedValue({ all_read: false }) });
+    const { rerender } = render(withTheme(
+      <MessagingProvider api={api} active={false}><ReadTicks messageId="m1" conversation={{ id: 'c1', kind: 'direct' }} /></MessagingProvider>
+    ));
+    const sentIcon = await screen.findByLabelText('MessagingReadTicks.SENT');
+    const sentColor = getComputedStyle(sentIcon).color;
+
+    api.getReadStatus.mockResolvedValue({ all_read: true });
+    cleanup();
+    render(withTheme(
+      <MessagingProvider api={api} active={false}><ReadTicks messageId="m1" conversation={{ id: 'c1', kind: 'direct' }} /></MessagingProvider>
+    ));
+    const readIcon = await screen.findByLabelText('MessagingReadTicks.ALL_READ');
+    const readColor = getComputedStyle(readIcon).color;
+
+    expect(sentColor).toBeTruthy();
+    expect(readColor).toBeTruthy();
+    expect(sentColor).not.toBe(readColor);
+  });
+
+  it('4b: a group WITH counts renders dcm\'s own read_count/recipient_count verbatim, never recomputed from recipientDetail (must fail if recomputed -- recipientDetail is not thresholded against this message\'s created_at, only dcm\'s own counts are)', async () => {
+    // Deliberately inconsistent with read_count/recipient_count: every
+    // participant has SOME last_read_at (e.g. from reading the conversation
+    // long before this message existed), which is exactly the shape that
+    // would make a naive "count non-null last_read_at" recomputation report
+    // 40/40 -- the bug caught in review. dcm's own read_count (18) is the
+    // only correct source; recipientDetail must not be trusted for the ratio.
+    const allEverRead = Array.from({ length: 40 }, (_, i) => ({ user_id: `u-${i}`, last_read_at: '2020-01-01T00:00:00Z' }));
+    const api = makeApi({ getReadStatus: vi.fn().mockResolvedValue({ all_read: false, read_count: 18, recipient_count: 40, recipient_detail: allEverRead }) });
+    render(<MessagingProvider api={api} active={false}><ReadTicks messageId="m1" conversation={{ id: 'c1', kind: 'group' }} /></MessagingProvider>);
+    const ratio = await screen.findByLabelText(/READ_RATIO/);
+    expect(ratio.textContent).toBe('18/40');
+    expect(document.body.querySelector('[data-testid="DoneOutlinedIcon"]')).toBeNull();
+    expect(document.body.querySelector('[data-testid="DoneAllOutlinedIcon"]')).toBeNull();
+    expect(document.body.textContent).not.toMatch(/Zugestellt/);
+  });
+
+  it('4c: a group WITHOUT counts (an ordinary participant) renders no indicator at all', async () => {
+    const api = makeApi({ getReadStatus: vi.fn().mockResolvedValue({ all_read: false }) });
+    const { container } = render(<MessagingProvider api={api} active={false}><ReadTicks messageId="m1" conversation={{ id: 'c1', kind: 'group' }} /></MessagingProvider>);
+    await waitFor(() => expect(api.getReadStatus).toHaveBeenCalled());
+    expect(container.textContent).toBe('');
+    expect(container.querySelector('svg')).toBeNull();
+  });
+
+  it('5: all_read still renders the double check with its own unchanged label', async () => {
+    const api = makeApi({ getReadStatus: vi.fn().mockResolvedValue({ all_read: true }) });
+    render(<MessagingProvider api={api} active={false}><ReadTicks messageId="m1" conversation={{ id: 'c1', kind: 'direct' }} /></MessagingProvider>);
+    const icon = await screen.findByLabelText('MessagingReadTicks.ALL_READ');
+    expect(icon.getAttribute('data-testid')).toBe('DoneAllOutlinedIcon');
+  });
+});
+
+describe('MSG-6f scope C: re-mark read on a live message frame for the open conversation', () => {
+  function renderThread(api, { userId = 1 } = {}) {
+    return render(
+      <AuthContext.Provider value={{ user: { id: userId } }}>
+        <MessagingProvider api={api}><Thread conversationId="c1" /></MessagingProvider>
+      </AuthContext.Provider>
+    );
+  }
+
+  it('marks read again when a message frame arrives for the currently-open conversation', async () => {
+    const api = makeApi();
+    renderThread(api);
+    await waitFor(() => expect(api.markConversationRead).toHaveBeenCalledTimes(1));
+    api.markConversationRead.mockClear();
+
+    act(() => dispatchFrame({ type: 'message', conversation_id: 'c1', message: { id: 'm2', conversation_id: 'c1', sender: { id: 2 } } }));
+
+    await waitFor(() => expect(api.markConversationRead).toHaveBeenCalled());
+    expect(api.markConversationRead.mock.calls[0][0]).toBe('c1');
+  });
+
+  it('does not re-mark for a message frame belonging to a different conversation', async () => {
+    const api = makeApi();
+    renderThread(api);
+    await waitFor(() => expect(api.markConversationRead).toHaveBeenCalledTimes(1));
+    api.markConversationRead.mockClear();
+
+    act(() => dispatchFrame({ type: 'message', conversation_id: 'other-conversation', message: { id: 'm2' } }));
+
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(api.markConversationRead).not.toHaveBeenCalled();
+  });
+
+  it('does not re-mark while the document is hidden', async () => {
+    const api = makeApi();
+    renderThread(api);
+    await waitFor(() => expect(api.markConversationRead).toHaveBeenCalledTimes(1));
+    api.markConversationRead.mockClear();
+
+    const visibilitySpy = vi.spyOn(document, 'visibilityState', 'get').mockReturnValue('hidden');
+    act(() => dispatchFrame({ type: 'message', conversation_id: 'c1', message: { id: 'm2' } }));
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(api.markConversationRead).not.toHaveBeenCalled();
+    visibilitySpy.mockRestore();
+  });
+
+  it('does not re-mark for a non-message frame type (e.g. reaction) for the same conversation', async () => {
+    const api = makeApi();
+    renderThread(api);
+    await waitFor(() => expect(api.markConversationRead).toHaveBeenCalledTimes(1));
+    api.markConversationRead.mockClear();
+
+    act(() => dispatchFrame({ type: 'reaction', conversation_id: 'c1', message_id: 'm2' }));
+
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(api.markConversationRead).not.toHaveBeenCalled();
+  });
+});

package/tests/messagingThreadReceipts.test.jsx

@@ -7,14 +7,22 @@ import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/re
 
 vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key, options) => options?.count !== undefined ? `${key}:${options.count}` : key, i18n: { language: 'en' } }) }));
 
+// Thread.jsx (MSG-6f scope C) now subscribes to the messaging envelope
+// independently of MessagingProvider's own subscription -- a Set of handlers
+// per envelope, not one handler per envelope, so a dispatched frame still
+// reaches every current subscriber, matching the real registry's multi-handler support.
 const realtimeSubscribers = new Map();
 vi.mock('../src/notifications/realtime', () => ({
   useRealtime: () => ({
-    subscribe: (envelope, handler) => { realtimeSubscribers.set(envelope, handler); return () => realtimeSubscribers.delete(envelope); },
+    subscribe: (envelope, handler) => {
+      if (!realtimeSubscribers.has(envelope)) realtimeSubscribers.set(envelope, new Set());
+      realtimeSubscribers.get(envelope).add(handler);
+      return () => realtimeSubscribers.get(envelope)?.delete(handler);
+    },
     onReconnect: () => () => {},
   }),
 }));
-function dispatchMessagingFrame(frame) { realtimeSubscribers.get('messaging')?.(frame); }
+function dispatchMessagingFrame(frame) { realtimeSubscribers.get('messaging')?.forEach((handler) => handler(frame)); }
 
 import { ConversationList } from '../src/messaging/ConversationList';
 import { Thread } from '../src/messaging/Thread';

package/tests/messagingThreadingQuoting.test.jsx

@@ -19,7 +19,7 @@ function makeApi(messages = []) {
     getUnreadCount: vi.fn().mockResolvedValue({ unread_count: 0, by_conversation: {} }),
     markConversationRead: vi.fn().mockResolvedValue({}),
     markThreadRead: vi.fn().mockResolvedValue({}),
-    getReadStatus: vi.fn().mockResolvedValue({ all_read: false, delivered_count: 0 }),
+    getReadStatus: vi.fn().mockResolvedValue({ all_read: false }),
   };
 }
 function renderBubble(ui) {

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

@@ -0,0 +1,214 @@
+# WORK ORDER MSG-6f (ui-core-micha) — the host title resolver is never called for broadcasts, and the read ticks claim a delivery that does not exist
+
+**EXECUTION DIRECTIVE.** If you are the implementer reading this as your own spec, this section is not
+addressed to you — it tells the Orchestrator how to invoke you; you ARE that invocation, do not shell
+out to `codex exec`. Orchestrator: implement through `codex exec` in the background, invoked **directly
+via Bash** (never the `debugger`/`*_coder` Agent wrappers) with **both** flags `--skip-git-repo-check`
+and `--dangerously-bypass-approvals-and-sandbox`, prompt passed as a positional argument from this
+file. Fall back to direct Claude implementation only on Codex quota / rate-limit / non-zero exit.
+
+Feature-level WO (Expertenchat envelope). Both defects were found by **verifying the landed MSG-6e /
+MSG-7 / MSG-8 / MSG-10 work in a running app** (jg-ferien local, flag on, ucm 2.21.3, dcm 2.39.5,
+2026-08-03). Both are cases of "the other side shipped its half; ucm still renders the old behaviour".
+
+## TIER
+Tier 2 — shared-core, consumed by every app. Independent `reviewer` mandatory. `ui_reviewer` for
+scope B (it changes what a user believes about message delivery).
+
+## SCOPE
+
+**A. `titleOf` never calls the host resolver for a broadcast — jg's fix is dead code.**
+
+`ConversationList.jsx` `titleOf()` gates the host callback on kind:
+
+```js
+if (conversation.kind === 'managed' && resolveManagedLabel) {
+  const label = resolveManagedLabel(conversation);
+  if (label) return label;
+}
+```
+
+jg-ferien MSG-10 correctly taught its `resolveManagedConversationLabel` to handle
+`kind === 'broadcast'` — but ucm never calls it for that kind, so the branch is unreachable from the
+list and the row still falls through to `t('MessagingList.UNTITLED')`.
+
+**Verified live after MSG-10 landed:** the same conversation (`kind: "broadcast"`,
+`external_key: "broadcast"`, `title: null`) renders **"Unbenannte Unterhaltung"** in the list and
+**"Event-Ankündigungen"** in the open thread header — the thread header works only because jg's own
+`resolveConversationTitle` calls the resolver directly, with no kind gate.
+
+**The fix: stop gating on kind.** Call `resolveManagedLabel` for **every** conversation and let the
+host decide — a `null` return already means "I have no label", which is exactly the delegation contract,
+and the comment directly above `titleOf` already describes the label as host-supplied. Gating on kind
+inside ucm duplicates a decision that belongs to the host and will break again for the next kind.
+
+Check `resolveDirectUserName`'s gate (`kind === 'direct' && other_user_id != null`) in the same pass and
+state whether it has the same problem. Do not change it blindly — a direct conversation is the one kind
+where the id-based lookup is genuinely required.
+
+**B. The read ticks assert a delivery that the platform does not track.**
+
+Operator report, 2026-08-03: *"die Häkchen geben das Gefühl, dass jede Nachricht sofort zugestellt ist,
+auch wenn das Browserfenster geschlossen ist."* Correct, and it is now strictly worse than when it was
+written:
+
+- dcm MSG-7 scope C **removed `delivered_count`** from the `read-status` response — verified live, the
+  response now carries only `all_read` and `recipient_detail`.
+- `ReadTicks.jsx` still renders
+  `t('MessagingReadTicks.DELIVERED', { count: renderedStatus.delivered_count || 0 })`. With the field
+  gone, `undefined || 0` produces the **identical** label as before. Verified live: every own message
+  shows `aria-label="Zugestellt an 0"`.
+
+So the UI states "Zugestellt an 0" — simultaneously claiming a delivery and reporting that it reached
+nobody — on a single outlined check that reads as WhatsApp's delivered-tick. There is no delivery
+signal behind it at all.
+
+**Resolution (operator-directed, 2026-08-03): show a read PROPORTION in group and broadcast, keep a
+two-state tick in DMs.**
+
+The operational need in a camp is *"did a relevant share of the group read this?"* — a leader posting
+"bus leaves at 14:00" to forty participants needs a number, not a checkmark. `all_read` is the wrong
+measurement, not a useless feature: in any group it is essentially never true, so a boolean pins the
+indicator to its first state precisely where the information matters most.
+
+Operator decision, 2026-08-03:
+
+| Conversation kind | Viewer | Display |
+|---|---|---|
+| `direct` | sender | two-state tick — `DoneOutlinedIcon` **light grey** "Gesendet" → `DoneAllOutlinedIcon` **dark blue** "Gelesen" |
+| `group`, `broadcast`, `managed` | team member | a **ratio**: "18/40" (read / members). Numeric, no icon ladder. |
+| `group`, `broadcast`, `managed` | ordinary participant | **nothing** — render no indicator at all |
+| per-recipient detail | team member | unchanged — already correctly gated (see below) |
+
+**The contrast between the two DM states must be clearly stronger than today.** Currently
+`color={status.all_read ? 'primary' : 'inherit'}`, and `inherit` inside the meta `Stack` resolves to
+`text.disabled` — the two states are barely distinguishable. Use an explicit light grey and an explicit
+dark blue rather than `inherit`/`primary`, and verify the difference is obvious at the rendered
+`1rem` icon size in both light and dark theme. The icon shape already differs (`Done` vs `DoneAll`), so
+the distinction does not rest on colour alone — keep it that way.
+
+**"nothing" for an ordinary participant in a group is deliberate, not an oversight.** A permanently
+grey tick — which is what `all_read` would produce in any real group — is the "looks stuck" failure this
+scope exists to remove. No indicator is better than a misleading one.
+
+**No client-side permission logic.** dcm MSG-9 returns the counts only to viewers holding
+`read_receipt_detail`, so the rule is purely shape-driven: *counts present → ratio; else `direct` →
+tick; else → render nothing*. Do not branch on roles or capabilities in ucm.
+
+**The server already has the number and throws it away.** `read_status` (`services.py:344-347`) computes
+`all_read` from exactly the queryset that yields the count:
+`participants.filter(last_read_at__gte=message.created_at).count()` — the same shape as the
+`delivered_count` that had no writer. **A `read_count` + `recipient_count` pair is the counter
+`delivered_count` should have been.**
+
+Adding them is a `django-core-micha` change, not ucm's: **this scope is blocked on `django-core-micha`
+MSG-9**, which adds `read_count` and `recipient_count` inside the existing `read_receipt_detail`-gated
+block. Keep `all_read` — the DM branch still uses it.
+
+Do not derive the ratio client-side by counting `recipient_detail` yourself. It would happen to work
+(both are gated on the same right), but it re-implements a server aggregate in the client and would
+silently produce a wrong denominator the moment dcm's participant filtering changes. Read the counts
+dcm sends, or render nothing.
+
+Retire `MessagingReadTicks.DELIVERED` and its `{{count}}` regardless — the new ratio string is a
+different key with different semantics, and reusing "Zugestellt" would carry the false claim forward.
+Also stop reading the now-always-`null` `last_delivered_at` out of `recipient_detail`.
+
+**Per-recipient detail stays as it is.** `services.py:340` already gates it on
+`kind != DIRECT and "read_receipt_detail" in rights` (in jg: `MANAGER_RIGHTS`), and DMs never expose it
+even to moderators — a documented design invariant. This WO does not touch that; the popover keeps
+working for managers.
+
+**Why not implement delivery tracking as well** (wiring `mark_delivered` from a client ack, technically
+possible since dcm MSG-8 made WS frames arrive): in a browser app "delivered" can only mean "a tab had
+the socket open at that moment". For a recipient who is simply not online it would sit at the first
+state indefinitely — replacing "looks always delivered" with "looks permanently stuck", plus a write per
+received message. It only becomes meaningful with guaranteed device-level push. A read ratio answers the
+real question without that ambiguity. **If the operator wants delivery too, it is a feature WO.**
+
+**C. The read signal misses the most attentive reader — fix this or the ratio understates.**
+
+What `read_count` actually measures must be stated plainly, because it is weaker than "read":
+`mark_read` (`dcm services.py:288-294`) sets `ConversationParticipant.last_read_at` to *now*, and after
+MSG-6e scope D there is exactly **one** caller — `Thread.jsx:58`, a `useEffect` keyed on
+`[conversationId, markConversationRead]`. So the recorded fact is **"opened this conversation"**, and
+`read_count` counts participants who opened it at some point after the message was posted.
+
+It is not tab-open, not socket-connected, not per-message interaction, not viewport visibility.
+
+Two asymmetries follow. The first is acceptable, the second is a defect:
+
+1. Opening a conversation marks its **entire** history read in one stroke. Someone who opens it and
+   leaves immediately counts as having read a 200-message backlog. This is the universal convention
+   (WhatsApp behaves the same) — accept it, do not try to fix it here.
+2. **A participant already sitting in the open conversation when the message arrives is NOT counted.**
+   The effect is keyed on `conversationId`, so it does not re-fire when a new message lands. The person
+   who saw it in real time is recorded as not having read it, until they navigate away and back.
+
+Asymmetry 2 is newly common and newly consequential: before dcm MSG-8 no frame was ever delivered, so
+no thread ever updated live and this case did not arise. Now it is the *normal* case for anyone
+actually paying attention — and it biases the ratio **downward**, which is the wrong direction for a
+leader deciding whether to chase people about the bus time.
+
+**Fix: re-mark read when a new message arrives in the conversation currently open.** Trigger on the
+incoming `message` frame for the active conversation, not on a timer. Guard it: do not fire for the
+viewer's **own** send (dcm already excludes the sender from the fan-out, so no frame arrives — verify
+rather than assume), and do not fire when the thread is mounted but the document is hidden
+(`document.visibilityState`), or a background tab would report reads nobody performed. `mark_read` is
+already idempotent — it only writes when the new timestamp is later (`services.py:291`) — so a
+redundant call is cheap, but a *wrong* one is not.
+
+**Known cost, do not silently ignore:** `Thread` mounts `ReadTicks` per own message and each instance
+fires its own `read-status` request — O(n) for a sender with many messages in a thread, which is exactly
+the broadcast-heavy leader this feature serves. A batch endpoint (message ids → counts) is the natural
+answer and belongs in the same dcm WO. Do **not** fold the counts into `serialize_message` instead:
+`views.py:50-54` documents why viewer-specific read state must stay out of it — it would leak into the
+`message`/`message_edited` realtime frames, the same trap `thread_last_read_at` was kept out of.
+
+## NON-GOALS / DO NOT TOUCH
+- Do not reintroduce `delivered_count` on either side.
+- Do not change `all_read`'s semantics or how `read_state` frames update the cached receipt (that is
+  MSG-6e scope C, already landed — leave it working).
+- No change to `isOwn`/`senderName`/`canShowReadTicks`; the `sender` object from dcm 2.39.4 fixed those
+  and they are **verified working** (all server-loaded messages now render `own` with a tick).
+- Do not touch jg-ferien. Its `resolveManagedConversationLabel` is already correct and must stay as it
+  is — scope A is what makes it reachable.
+
+## RISKS
+- **A changes behaviour for every host app**, including any that relies on `resolveManagedLabel` being
+  called only for `managed`. A host returning a non-null label for an unexpected kind would newly see
+  it win over `conversation.title`. Check the ordering in `titleOf` after the change: a host label
+  should still lose to nothing it previously lost to, apart from the intended new case.
+- B changes a user-facing claim. Getting it wrong in the other direction (removing the indicator
+  entirely) loses the "did my message go out" affordance — hence two states, not zero.
+- The retired i18n key may be referenced by host apps' tests. Grep before deleting and note any hits.
+
+## REQUIRED TESTS TO WRITE
+Narrow and behavioural. Do NOT run the full suite.
+
+1. **A:** a conversation with `kind: 'broadcast'`, `title: null`, and a host `resolveManagedLabel` that
+   returns a string renders **that string**, not `MessagingList.UNTITLED`. This must **fail against
+   today's code** — prove it.
+2. **A:** a host resolver returning `null` still falls through to the existing chain unchanged
+   (regression guard for the delegation contract).
+3. **A:** the existing `managed` / `event_all` / `event_team` behaviour is unchanged.
+4. **B:** `direct` renders the two-state tick and the two states use visibly different explicit colours (assert the resolved colours differ, not just that a colour prop is set); a `group` WITH counts renders the ratio; a `group` WITHOUT counts renders **no** indicator. Assert no label containing "Zugestellt" is produced anywhere in `ReadTicks`.
+   that **no** label containing a `{{count}}`-derived number is produced anywhere in `ReadTicks`.
+5. **B:** `all_read` still renders the double check in `primary` with the unchanged label.
+
+**Non-vacuity:** tests 1 and 4 must fail on the current code. Test 1 is the one that matters — jg
+shipped a fix for this exact symptom that did nothing, because the test asserted on the wrong side of
+the boundary. Assert on the **rendered list row**, not on the resolver function in isolation.
+
+## TEST SCOPE FOR THE GATE (orchestrator)
+`ConversationList` and `ReadTicks` test files plus the messaging i18n tests. Not the full suite.
+
+## TARGET REPO
+`C:\Users\biglmi\Documents\webapps\ui-core-micha`. Branch `main` (or `develop` if present). Publish per
+the repo's release flow. jg's pin bump is a separate step; jg needs it to close its own MSG-9
+finding 4/12, which cannot be fixed from jg at all.
+
+## PROGRESS CONTRACT
+Emit `PLAN: <steps>` up front, then a single-line `PROGRESS: [<n>/<total>] <action>` before every
+relevant action and `PROGRESS: [<n>/<total>] done` on completion, spaced so no gap exceeds ~2 min,
+stdout unbuffered, and exactly one final `RESULT: DONE|BLOCKED <reason>`.