diff --git a/docs/archive/notes/2026-07-21-call-core-design.md b/docs/archive/notes/2026-07-21-call-core-design.md
new file mode 100644
index 000000000..01b1895f3
--- /dev/null
+++ b/docs/archive/notes/2026-07-21-call-core-design.md
@@ -0,0 +1,636 @@
+# Shared "call core" design — consolidating web + mobile `useCall`
+
+Date: 2026-07-21
+Scope: design only, no code changes. Read-only analysis of
+`surface/web/src/useCall.ts` (744 LOC) and `surface/mobile/src/lib/useCall.ts`
+(902 LOC), their consumers, and the shared wire types.
+
+---
+
+## 0. Verdict up front
+
+**Consolidate, but not into a single hooks-driven room engine.** The honest,
+high-value seam is a **pure shared module** (`@atrium/surface-client/call-core`)
+that owns the platform-independent brain — state types, participant/phase
+bookkeeping, `sortLiveCalls`/`upsert`/`remove`, the CallKit-free user enrichment,
+and above all the **`CallEvent` reducer** (`handleCallEvent`, ~100 near-identical
+lines each side) expressed as a pure `(state, event) → state` transition. The two
+`useCall` hooks stay as **thin platform drivers** that hold the LiveKit `Room`,
+own their refs, and call the shared reducer.
+
+I explicitly recommend **against** pushing the LiveKit `Room` lifecycle itself
+into shared code behind a fat platform-adapter interface. Section 9 shows why: the
+mobile side interleaves ~28 CallKit/audio-session calls at ~11 distinct lifecycle
+points, and a hook-based core would have to invent, name, and correctly order all
+11 hooks — adding indirection at exactly the seam whose regressions are most
+expensive (verified-on-real-iPhone CallKit behavior) while deleting only ~120 LOC
+of `Room` wiring that is *already* mostly parallel. The reducer + pure functions +
+types are where the duplication actually is and where unification is provably safe.
+
+The design below specifies BOTH the full adapter approach (so the tradeoff is
+concrete and the CallKit interleavings are made fully explicit, per the brief) and
+the recommended smaller consolidation, and states which parts of each are worth
+shipping.
+
+---
+
+## 1. Side-by-side inventory
+
+### 1.1 Imports
+
+| | web (`surface/web/src/useCall.ts`) | mobile (`surface/mobile/src/lib/useCall.ts`) |
+|---|---|---|
+| React | `useCallback,useEffect,useRef,useState` (L1) | same (L1) |
+| LiveKit | `Room,RoomEvent,Track,Participant,RemoteParticipant,RemoteTrack,RemoteTrackPublication` (L2-10) | `Room,RoomEvent,Track,Participant,RemoteParticipant` (L3) — **no RemoteTrack/Publication** |
+| RN audio | — | `AudioSession` from `@livekit/react-native` (L2) |
+| CallKit | — | 20 named imports from `expo-callkit-telecom` (L4-24) |
+| shared | `CallEvent,CallJoin,CallWire,UserRef` (L11) | `+ApiError,CALL_RING_TTL_MS,channelLabel,Api,AppState,Channel` (L25-36) |
+| local | `ApiError,api,Channel` from `./api`; `desktopApiOptions` from `./desktop` (L12-13) | `NATIVE_CALL_UI` from `./nativeCallUi` (L37) |
+
+Key structural difference: **web imports the `api` singleton** (L12); **mobile
+takes `api: Api` as a hook argument** (L149). The core must be the mobile shape
+(api injected); the web wrapper injects its singleton.
+
+### 1.2 `ActiveCallState` shape
+
+| field | web (L20-28) | mobile (L39-47) |
+|---|---|---|
+| `call: CallWire` | ✓ | ✓ |
+| `phase: 'connecting'|'connected'|'ended'` | ✓ | ✓ |
+| `participants: UserRef[]` | ✓ | ✓ |
+| `activeSpeakerIds: Set<string>` | ✓ | ✓ |
+| `muted: boolean` | ✓ | ✓ |
+| `error: string | null` | ✓ | ✓ |
+| `remoteAudioTracks: RemoteAudioTrackRef[]` | ✓ (web-only) | — |
+| `nativeCallId?: string` | — | ✓ (mobile-only) |
+
+`RemoteAudioTrackRef` (web L15-18): `{ key: string; track: RemoteTrack }`.
+Consumed only by `surface/web/src/components/CallUI.tsx` (the `RemoteAudio`
+component, L15-32/L205-206) to `track.attach(<audio autoPlay>)`.
+
+### 1.3 Module-level state fields (hook body)
+
+| ref/state | web | mobile | note |
+|---|---|---|---|
+| `incomingCall` state | L180 | L159 | identical role |
+| `activeCall` state | L183 | L160 | identical role |
+| live-calls list state | `liveCalls` L181 | `recoverableCalls` L161 | **renamed + divergent semantics** |
+| `dismissedCallIds` | React **state** L182 | **ref** L188 | **DIVERGENT storage** |
+| `dismissedCallChannels` | — | ref `Map` L189 | mobile-only (per-channel snapshot reconciliation) |
+| `notice` | L184 | L162 | identical |
+| `starting` | L185 | L163 | identical |
+| `answering` | L186 (plain) | L164 + `answeringRef` mirror L168 + `setAnswering` L169 | mobile mirrors to ref for CallKit listeners |
+| `roomRef` | L187 | L174 | identical |
+| `activeCallRef` | L188 | L175 | identical |
+| `incomingCallRef` | — | L176 | mobile mirrors for listeners |
+| `recoverableCallsRef` | — | L177 | mobile |
+| `channelsRef` | L172 (`channelsRef`) | L178 | identical role |
+| `connectPromiseRef` | L190 | L179 | identical |
+| `detachRoomHandlersRef` | L191 | L180 | identical |
+| `intentionalDisconnectRef` | L192 | L181 | identical |
+| `mountedRef` | — | L165 | mobile-only guard |
+| native-mapping refs (6) | — | L182-187 | **CallKit-only** (see 1.7) |
+
+Mobile's 6 native-mapping refs (L182-187): `nativeIdByCallIdRef`,
+`callIdByNativeIdRef`, `nativeEndRequestedRef`, `answeredNativeRequestsRef`,
+`nativeIncomingReportPendingRef`, `nativeIncomingReportedRef`.
+
+### 1.4 Pure helper functions
+
+| helper | web | mobile | classification |
+|---|---|---|---|
+| `AUDIO_CAPTURE_OPTIONS` | L30-34 | L49-53 | **byte-identical** |
+| `fallbackUser` | L41-43 | L56-58 | identical |
+| `upsertUser` | L57-65 (**merge-aware**) | L60-62 (**add-only**) | DIVERGENT (web is a superset) |
+| `removeUser` | L119-121 | L64-66 | **identical** |
+| `participantsFor` | L92-95 (+enrich) | L68-70 (no enrich) | web superset |
+| `sortLiveCalls` | L127-129 (**ASC** startedAt, then id) | L72-76 (**DESC** startedAt, filters ended) | **DIVERGENT sort order** |
+| `upsertLiveCall` | L142-148 (+normalize) | L78-84 | same shape, web normalizes |
+| `updateLiveCall` | L150-165 (+normalize) | L86-94 | same shape |
+| `removeLiveCall` | — (inline `.filter`) | L96-98 | trivially unifiable |
+| `isLiveCall` | L123-125 | inline `status!=='ended'` | trivial |
+| `callUnavailable` | L167-169 | L108-110 | **identical** |
+| `mergeUser`/`isFallbackUser` | L45-55 | — | web-only enrichment |
+| `dedupeUsers`/`userFromIdentity`/`enrichParticipants`/`normalizeCall`/`normalizeLiveCalls`/`upsertIdentityParticipant(s)` | L67-117,131-140 | — | web-only enrichment |
+| `userForCall` | in `callPresentation.ts` L9 (**duplicated**) | L112-118 | identical logic, two copies |
+| `labelForCallChannel` | in `callPresentation.ts` L17 (**duplicated**) | L120-124 | identical logic, two copies |
+| `ringAgeMs`/`isExpiredRing` | — | L100-106 | mobile-only (uses shared TTL) |
+| `incomingCallEventFor` | — | L126-142 | **CallKit-only** |
+| `serverCallIdFromSession` | — | L144-146 | CallKit-only |
+| `RING_TIMEOUT_MS`/`CALL_REFRESH_INTERVAL_MS` | `RING_TIMEOUT_MS=45_000` L35 | `CALL_REFRESH_INTERVAL_MS=45_000` L54; ring TTL from shared `CALL_RING_TTL_MS=60_000` | **DIVERGENT ring timeout: 45s web vs 60s mobile** |
+
+> Note the duplication is worse than 2 files: web's `userForCall`/`labelForCallChannel`
+> live in a third file, `surface/web/src/callPresentation.ts` (L9, L17), imported by
+> `Chat.tsx` (L35). Mobile keeps them in `useCall.ts` and exports `labelForCallChannel`.
+
+### 1.5 Exported functions (hook return)
+
+| export | web (L725-743) | mobile (L884-901) |
+|---|---|---|
+| `incomingCall` | ✓ | ✓ |
+| `activeCall` | ✓ | ✓ |
+| `notice` | ✓ | ✓ |
+| `starting` | ✓ | ✓ |
+| `answering` | ✓ | ✓ |
+| `handleCallEvent` | ✓ | ✓ |
+| `refreshActiveCalls` | ✓ (no args) | ✓ (`{channelId?}`) |
+| `startCall` | ✓ | ✓ |
+| `acceptIncomingCall` | ✓ | ✓ |
+| `declineIncomingCall` | ✓ | ✓ |
+| `toggleMute` | ✓ | ✓ |
+| `leaveActiveCall` | ✓ | ✓ |
+| `clearNotice` | ✓ | ✓ |
+| `liveCalls` | ✓ | — |
+| `liveCallForChannel` | ✓ | — |
+| `joinCall` | ✓ | — |
+| `declineCall(callId)` | ✓ | — |
+| `recoverableCall` / `recoverableCalls` | — | ✓ |
+| `joinRecoverableCall(callId?)` | — | ✓ |
+| `acceptCallById` (internal, not returned) | — | ✓ (L512) |
+
+### 1.6 Effects
+
+| effect | web | mobile |
+|---|---|---|
+| re-enrich on `[channels,me]` | L197-208 | — (mobile does not re-enrich on channel change) |
+| ring-timeout on active call | L707-721 (45s) | L773-787 (60s TTL) |
+| incoming-ring TTL expiry | — | L793-807 (remaining-TTL) |
+| `pagehide`/`sendBeacon` leave | **L676-705 (web-only)** | — |
+| WS-down poll interval | — | **L811-817 (mobile-only)** |
+| CallKit listener subscription | — | **L831-878 (mobile-only)** |
+| `mountedRef` set/unset | — | L191-196 |
+| unmount → `clearRoom` | L723 | L880 |
+
+### 1.7 RoomEvent handlers (`setRoomHandlers`)
+
+| RoomEvent | web (L256-319) | mobile (L268-327) |
+|---|---|---|
+| `ParticipantConnected` | upsert (enriched) L258-263 | upsert (simple) L270-278 |
+| `ParticipantDisconnected` | remove + speaker + **drop remoteAudioTracks** L264-271 | remove + speaker L279-285 |
+| `TrackSubscribed` | **✓ addRemoteAudioTrack L272-276 (web-only)** | — |
+| `TrackUnsubscribed` | **✓ removeRemoteAudioTrack L277-281 (web-only)** | — |
+| `ActiveSpeakersChanged` | upsert speakers + set L282-289 | set only L286-291 |
+| `Disconnected` | leaveCall + notice L290-300 | **+ AudioSession.stop/restore + reportNativeEnded('failed')** L292-312 |
+
+Web additionally, inside `connectToCall` (L358-369), walks existing
+`remoteParticipants` and `addRemoteAudioTrack` for already-published audio; mobile
+instead calls `publication.setSubscribed(true)` (L389) and relies on native
+autosubscribe/AudioSession for playback (no track state kept).
+
+### 1.8 The ~28 CallKit / native-audio call sites (mobile, exhaustive)
+
+Every `expo-callkit-telecom` / `AudioSession` invocation, with the lifecycle
+moment it fires at. This is the table the implementation must not silently drop.
+
+| # | call | file:line | lifecycle moment |
+|---|---|---|---|
+| 1 | `AudioSession.stopAudioSession()` | L235 | `clearRoom` (intentional teardown) |
+| 2 | `restoreAudioSession()` | L237 / L240 | after (1) settles |
+| 3 | `reportCallEnded(nativeId, reason)` | L262 | `reportNativeEnded` |
+| 4 | `AudioSession.stopAudioSession()` | L297 | `onDisconnected` (unexpected drop) |
+| 5 | `restoreAudioSession()` | L299 / L302 | after (4) settles |
+| 6 | `setNativeMuted(nativeCallId, muted)` | L335 | `applyNativeMute` (app→CallKit mirror) |
+| 7 | `prepareAudioSessionForCall(false)` | L356 | `connectToCall`, before `new Room()` |
+| 8 | `AudioSession.startAudioSession()` | L375 | `connectToCall` work, before `room.connect` |
+| 9 | `fulfillIncomingCallConnected(incomingRequestId)` | L399 | connect success, incoming path |
+| 10 | `reportOutgoingCallConnected(native.id)` | L401 | connect success, outgoing path |
+| 11 | `failIncomingCallConnected(id, requestId)` | L409 | connect failure, incoming path |
+| 12 | `reportCallEnded(id, 'failed')` | L411 | connect failure, outgoing/other |
+| 13 | `getActiveCallSession()` | L439 | `reportIncomingToNative` pre-check (dedupe) |
+| 14 | `reportIncomingCall(incomingCallEventFor(...))` | L445 | `reportIncomingToNative` |
+| 15 | `getActiveCallSession()` | L447 | `reportIncomingToNative` post (capture session id) |
+| 16 | `failIncomingCallConnected(id, requestId)` | L533 | `acceptCallById` catch |
+| 17 | `startOutgoingCall({id:channelId,...})` | L657 | `startCall`, before connect (handle = channelId!) |
+| 18 | `answerCall(nativeId)` | L688 | `acceptIncomingCall` (route accept via CallKit) |
+| 19 | `endCall(nativeId)` | L706 | `declineIncomingCall` |
+| 20 | `endCall(nativeCallId)` | L744 | `leaveActiveCall` |
+| 21 | `addCallSessionAddedListener` | L833 | listener effect → `rememberNativeSession` |
+| 22 | `addCallSessionUpdatedListener` | L834 | listener effect → `rememberNativeSession` |
+| 23 | `addCallAnsweredListener` | L835 | listener effect → `acceptCallById` |
+| 24 | `getActiveCallSession()` | L839 | answered-listener fallback (map recovery) |
+| 25 | `failIncomingCallConnected(id, requestId)` | L844 | answered-listener, no serverCallId |
+| 26 | `addCallEndedListener` | L850 | listener effect → clearRoom/leave/decline |
+| 27 | `addSetMutedActionListener` | L865 | listener effect → `applyNativeMute` (CallKit→app) |
+| 28 | `getActiveCallSession()` | L868 | listener-effect init (adopt in-flight session) |
+
+Plus `startOutgoingCall`'s **channelId-as-handle** subtlety (L654-660 comment):
+the CallKit handle is the *channelId*, not the per-call id, so native "recents"
+group by conversation. Any refactor that plumbs `call.id` here is a silent
+regression to call-back behavior.
+
+---
+
+## 2. Consumer inventory
+
+### 2.1 Web
+
+- **`surface/web/src/Chat.tsx`** — the sole hook host. `const calls = useCall(me, state.channels)` (L406). Wires `onCall: calls.handleCallEvent` into the WS frame handler (L1146), chains `calls.refreshActiveCalls()` after reconnect sync (L1110-1113). Reads `calls.starting`, `calls.activeCall`, `calls.incomingCall`, `calls.notice`, `calls.answering`, and **`calls.liveCallForChannel(active.id)`** (L2255) to render the per-channel "join live call" banner. Calls `calls.declineCall(activeChannelLiveCall.id)` (L2539). Also imports `labelForCallChannel`/`userForCall` from the **separate `callPresentation.ts`**, not from the hook.
+- **`surface/web/src/components/CallUI.tsx`** — imports `ActiveCallState` type (L6) and `RemoteTrack` (L3). Owns the `RemoteAudio` `<audio autoPlay playsInline>` element that `track.attach()`es each `call.remoteAudioTracks[]` (L15-32, L205-206). This is the **web autoplay-policy seam** and the reason `remoteAudioTracks` exists in web state at all.
+
+### 2.2 Mobile
+
+- **`surface/mobile/src/lib/chat.tsx`** — hook host inside the chat context. `useCall({ api, me, channels, wsStatus })` (L304-309), passing `wsStatus: wsStatusKind(...) === 'open' ? 'open' : 'closed'` (L308). Exposes the whole `calls` object on context (`calls: ReturnType<typeof useCall>`, L112). Triggers `refreshActiveCalls()` once channels load (L862).
+- **`surface/mobile/src/components/GlobalCallUI.tsx`** — renders banners from `calls.incomingCall / activeCall / recoverableCall / notice`, wires `acceptIncomingCall / declineIncomingCall / joinRecoverableCall(recoverableCall?.id) / toggleMute / leaveActiveCall` (L88-113). Imports `labelForCallChannel` from `../lib/useCall` (L7).
+- **`surface/mobile/src/components/CallUI.tsx`** — renders `call.participants`, `call.activeSpeakerIds`, `call.muted` (L132-303). No native track element — playback is via AudioSession.
+- **`surface/mobile/test/useCall.test.tsx`** — the existing safety net: mocks `@livekit/react-native`, `livekit-client`, `expo-callkit-telecom`, and `nativeCallUi` (`NATIVE_CALL_UI:false`), and asserts stale-ring drop / dismissed-persistence / ring-TTL / WS-down poll gating. Any core refactor must keep these green and should grow (Section 8).
+
+### 2.3 Server interplay (`surface/shared/src/calls.ts`)
+
+- Actions are HTTP (`startCall`/`acceptCall`/`declineCall`/`leaveCall`/`activeCalls`, `surface/shared/src/api.ts` L864-890). `activeCalls` takes `{channelId?}` — **mobile uses it, web calls it argless**.
+- Lifecycle is WS: 6 `call.*` frames (`CallEvent`, L84-90), routed by `isCallEvent` (L93). Both hooks' `handleCallEvent` are the client half of this contract.
+- TTL policy constants (`CALL_RING_TTL_MS=60_000`, L20) are shared. **Web's local `RING_TIMEOUT_MS=45_000` diverges from this and should be reconciled to the shared constant during consolidation** (behavior change, flag it — see risk R5).
+- LiveKit media path never touches these hooks beyond `join.{token,url}`. The webhook reaper is server-side and out of scope; clients only observe its effects as `call.ended`/`participant_left` frames, which the shared reducer already handles.
+
+---
+
+## 3. Classification of every piece
+
+**SHARED-IDENTICAL** (byte-same or trivially unifiable): `AUDIO_CAPTURE_OPTIONS`,
+`fallbackUser`, `removeUser`, `callUnavailable`, `participantsFor` (mobile form),
+`updateLiveCall`/`upsertLiveCall`/`removeLiveCall` shapes, `activeCallRef`/
+`roomRef`/`connectPromiseRef`/`detachRoomHandlersRef`/`intentionalDisconnectRef`
+patterns, the ring-timeout effect body, `clearNotice`, and the six-branch
+`handleCallEvent` skeleton (ringing/accepted+joined/declined/left/ended).
+
+**SHARED-WITH-PARAM** (same logic, platform value injected): `api` (singleton vs
+injected — inject always), `channels` access (`channelsRef`), `sortLiveCalls`
+(inject sort direction — see R4), live-list state (`liveCalls`/`recoverableCalls`
+unify to one, expose both names via wrapper aliases), user enrichment (adopt web's
+richer `mergeUser`/`userFromIdentity`/`enrichParticipants` as the core; mobile's
+`userForCall`/`labelForCallChannel` become the same shared functions), ring
+timeout constant (adopt shared `CALL_RING_TTL_MS`).
+
+**PLATFORM-HOOK** (behavior only one platform has → lifecycle hook point):
+
+- web-only: `RemoteAudioTrackRef` + `remoteAudioTracks` slice + `TrackSubscribed`/
+  `TrackUnsubscribed` handlers + existing-track walk (the *audio-attachment* model);
+  `pagehide`/`sendBeacon` tab-lifecycle leave; `desktopApiOptions` token plumbing.
+- mobile-only: every row in the Section 1.8 table (28 sites) — CallKit report/
+  answer/end/fail/fulfill/mute-mirror, `AudioSession` start/stop/restore/prepare,
+  the CallKit listener effect, native-mapping bookkeeping, `reportIncomingToNative`,
+  `incomingCallEventFor`; the WS-down poll interval; `mountedRef`.
+
+**GENUINELY-DIVERGENT** (same event, different response — each needs a decision):
+
+| # | divergence | web | mobile | decision |
+|---|---|---|---|---|
+| D1 | live-list sort order | ASC startedAt+id (L128) | DESC startedAt (L75) | **Pick one.** `recoverableCall` selection (mobile L882) and web's per-channel `.find` are both order-tolerant *today*, but if the core exposes an ordered `liveCalls`, the visible order changes on one platform. Recommend ASC (stable, web's) + document mobile banner picks "first non-incoming" regardless. |
+| D2 | `dismissedCallIds` storage | React **state** (drives L197 re-enrich + `liveCallForChannel` memo dep L448) | **refs** + channel `Map` (L188-189) | Core keeps it as **state** (web needs reactivity); mobile's per-channel `Map` becomes an optional companion the mobile driver owns for its channel-scoped `refreshActiveCalls`. |
+| D3 | `refreshActiveCalls` scoping | argless, replaces whole list (L393) | `{channelId?}` merge (L483) | Core takes optional `{channelId?}`; web wrapper never passes it. |
+| D4 | ring timeout | 45s (L35) | 60s shared (L784) | Reconcile to shared 60s (web change — R5). |
+| D5 | `onDisconnected` unexpected-drop | leave + notice (L290-300) | + audio restore + `reportNativeEnded('failed')` (L292-312) | The extra work is a PLATFORM-HOOK (`onUnexpectedDisconnect`), not divergent logic. |
+| D6 | second incoming while active | `setNotice('Leave the current call…')` on join attempt (L327-330) | suppress incoming banner + guard native report (L465, L431) | Both refuse a second concurrent call; keep both behaviors (they are the same intent expressed at different layers). |
+| D7 | `upsertUser` semantics | merge-aware (L57) | add-only (L60) | Adopt web's merge-aware (superset). Mobile gains fallback→real upgrades — an improvement, low risk. |
+| D8 | accept routing | `joinCall`→`api.acceptCall` directly | `acceptIncomingCall`→`answerCall(nativeId)`→ CallKit `addCallAnsweredListener`→`acceptCallById` (indirect) | PLATFORM-HOOK: accept must be **interceptable** by the mobile adapter so CallKit drives the actual join. |
+
+---
+
+## 4. The seam — two designs
+
+### 4.1 Where it lives
+
+`shared/` (`@atrium/surface-client`) already depends on `react` (peer) and
+`@atrium/centaur-client`, and already owns `calls.ts`. New module:
+`surface/shared/src/call-core.ts`, exported as `@atrium/surface-client/call-core`.
+
+**`livekit-client` dependency implication.** This is the load-bearing packaging
+decision:
+
+- The two apps pin **different** `livekit-client` majors/minors: web `^2.15.13`
+  (`surface/web/package.json` L24), mobile `2.19.1` (`surface/mobile/package.json`
+  L38, exact). A shared module that *imports* `livekit-client` would force a single
+  version across both apps (or rely on peer-dep resolution), and would drag the
+  full LiveKit client type/runtime surface into `shared`'s dependency graph —
+  including for `shared` consumers that never touch calls (it is tree-shakeable at
+  the bundler level only if the import lives in a leaf module the app doesn't pull).
+- **Therefore the shared core must not import `livekit-client` at runtime.** It may
+  import *types only* (`import type { Room } from 'livekit-client'`) if we accept a
+  `devDependency`/`peerDependency` on it in `shared/package.json`; even that couples
+  versions for typechecking. The clean answer for the **recommended (pure) design**
+  is that the core touches **no LiveKit type at all** — the `Room` and its events
+  stay entirely in each app's driver. `RemoteAudioTrackRef` (which embeds a
+  `RemoteTrack`) is web-only state and stays in web.
+
+This constraint is the strongest single argument for the pure-module design over
+the fat-adapter design: the fat adapter would have to pass `Room`/`RemoteTrack`
+across the seam and thus put `livekit-client` into `shared`.
+
+### 4.2 Design A (recommended) — pure core + thin drivers
+
+`call-core.ts` exports, all **LiveKit-free and CallKit-free**:
+
+- Types: `CallPhase`, `BaseActiveCallState` (the 6 common fields; each app
+  intersects it with its extra field), `LiveCallList` helpers.
+- Pure functions: `fallbackUser`, `mergeUser`, `isFallbackUser`, `upsertUser`,
+  `removeUser`, `dedupeUsers`, `userFromIdentity`, `enrichParticipants`,
+  `participantsFor`, `normalizeCall`, `normalizeLiveCalls`, `sortLiveCalls(dir)`,
+  `upsertLiveCall`, `updateLiveCall`, `removeLiveCall`, `isLiveCall`,
+  `isExpiredRing`, `callUnavailable`, `userForCall`, `labelForCallChannel`.
+- **`callEventReducer(state, event, ctx) → { active, incoming, live, effects }`** —
+  a pure transition over the three state atoms, returning a small list of
+  **intent effects** (`{kind:'reportIncoming',call}`, `{kind:'reportEnded',callId,
+  reason}`, `{kind:'endedByLastLeave',callId}`, `{kind:'clearRoom'}`, …). The
+  driver interprets effects; web ignores the CallKit ones, mobile acts on them.
+  This is where the ~100-line-each `handleCallEvent` duplication actually dies.
+
+Each app keeps its `useCall` hook (~250-350 LOC), but the hook now: holds refs +
+`Room`, calls `callEventReducer` from `handleCallEvent`, and interprets the
+returned effects. No LiveKit or CallKit type crosses into `shared`.
+
+### 4.3 Design B (documented, not recommended) — `useCallCore(adapter)`
+
+A shared hook owns the `Room` and calls a `CallPlatform` adapter at every
+lifecycle point. This forces `livekit-client` into `shared` (4.1) and requires the
+full hook table below. Presented so the CallKit interleavings are explicit and so
+the reject decision is grounded, not hand-waved.
+
+`interface CallPlatform` (every method, its trigger, and the CallKit site it
+subsumes):
+
+| adapter method | trigger point in Room lifecycle | web impl | mobile impl → CallKit site(s) |
+|---|---|---|---|
+| `beginOutgoing(call, channelName): Promise<NativeHandle?>` | in `startCall`, before `connectToCall` | `undefined` | `startOutgoingCall` **#17** (channelId handle) |
+| `prepareForConnect(native)` | in `connectToCall`, before `new Room()` | no-op | `prepareAudioSessionForCall(false)` **#7** |
+| `beginAudio()` | connect work, before `room.connect` | no-op | `AudioSession.startAudioSession()` **#8** |
+| `onConnected(kind, native)` | after mic enabled, phase→connected | no-op | `fulfillIncomingCallConnected` **#9** / `reportOutgoingCallConnected` **#10** |
+| `onConnectFailed(kind, native)` | connect catch | no-op | `failIncomingCallConnected` **#11** / `reportCallEnded('failed')` **#12** |
+| `attachRemoteAudio(track,pub,part)` / `detachRemoteAudio(pub,part)` | `TrackSubscribed`/`TrackUnsubscribed` | update `remoteAudioTracks` | no-op (autosubscribe; `setSubscribed(true)` in connect loop) |
+| `onUnexpectedDisconnect(callId)` | `RoomEvent.Disconnected`, not intentional | `notice` only | `AudioSession.stop`+`restoreAudioSession` **#4/#5** + `reportNativeEnded('failed')` **#3** |
+| `onTeardown()` | `clearRoom` | no-op | `AudioSession.stop`+`restoreAudioSession` **#1/#2** |
+| `applyMute(native, muted)` | `toggleMute` / CallKit mute action | `room.setMic` only | `room.setMic` + `setNativeMuted` **#6** |
+| `reportEnded(callId, reason)` | reducer `reportEnded` effect / participant-left last leave | no-op | `reportCallEnded` **#3** (via mapping) |
+| `reportIncoming(call, caller, channelName)` | reducer `reportIncoming` effect | no-op | `getActiveCallSession`+`reportIncomingCall`+`getActiveCallSession` **#13/#14/#15** |
+| `interceptAccept(call): 'handled'|'proceed'` | `acceptIncomingCall` | `'proceed'` | `answerCall(nativeId)` **#18** → returns `'handled'`, CallKit re-enters via listener |
+| `requestEnd(callId, native)` | `declineIncomingCall` / `leaveActiveCall` | no-op | `endCall` **#19/#20** |
+| `subscribeNativeEvents({onAnswered,onEnded,onMuted,onSession})` | mount effect | no-op | `addCall*Listener` **#21-27**, `getActiveCallSession` init **#28** |
+
+Even in Design B the **native-mapping bookkeeping** (the 6 refs, `rememberNativeSession`,
+`clearNativeMapping`, `serverCallIdFromSession`, dedupe sets) stays entirely inside
+the mobile adapter — it never generalizes. That is ~150 LOC of mobile-only state the
+adapter can't delete, which is most of why B doesn't pay off (Section 8/9).
+
+---
+
+## 5. Lifecycle hand-computations
+
+Notation: **W** = web today, **M** = mobile today, **A** = Design A (pure core),
+**B** = Design B (adapter). "→" = ordered steps. CallKit sites cited by # from 1.8.
+
+### (a) Outgoing: start → connected → peer joins → hangup
+
+- **W**: `startCall`→`api.startCall`→`connectToCall`: `new Room`→`setRoomHandlers`
+  →`setActiveCall(connecting)`→`room.connect`→`setMic(true)`→walk remote parts +
+  `addRemoteAudioTrack`→phase=connected. Peer joins: `ParticipantConnected`→upsert;
+  `TrackSubscribed`→add audio. Hangup: `leaveActiveCall`→`clearRoom`→`setActiveCall
+  (null)`→`updateLiveCall(remove me)`→`api.leaveCall`.
+- **M**: `startCall`→`api.startCall`→**#17 startOutgoingCall**→`connectToCall`:
+  **#7 prepare**→`new Room`→handlers→`setActiveCall`→**#8 startAudioSession**→
+  `room.connect`→`setMic(true)`→walk remotes `setSubscribed(true)`→phase=connected→
+  **#10 reportOutgoingCallConnected**. Peer joins: `ParticipantConnected`→upsert.
+  Hangup: `leaveActiveCall`→**#20 endCall**→`clearRoom`(**#1/#2 stop+restore**)→
+  `setActiveCall(null)`→`updateLiveCall`→`api.leaveCall`.
+- **A**: identical firing order to M on mobile / W on web — the driver still owns
+  the `Room` and calls the effects at the same points; only the reducer/pure calls
+  move. **No reordering.**
+- **B**: order preserved *iff* `beginOutgoing`(#17) fires in `startCall` before
+  `connectToCall`, `prepareForConnect`(#7) before `new Room`, `beginAudio`(#8)
+  before `room.connect`, `onConnected`(#10) strictly after phase=connected. All
+  expressible; no forced reorder.
+
+### (b) Incoming: ring → answer → connected → remote hangup
+
+- **W**: WS `call.ringing`→`handleCallEvent`→`setIncomingCall`. User taps accept→
+  `acceptIncomingCall`→`joinCall`→`api.acceptCall`→`connectToCall`(as (a) inbound).
+  Remote hangs up → `call.ended` or last `participant_left`→`clearRoom`+null.
+- **M**: `call.ringing`→`handleCallEvent`→`setIncomingCall`+**#14 reportIncoming**
+  (preceded by **#13**, followed by **#15**). Accept: `acceptIncomingCall`→
+  **#18 answerCall(nativeId)** → CallKit fires `addCallAnsweredListener`(**#23**)→
+  `acceptCallById`→`api.acceptCall`→`connectToCall`(**#7,#8**, then **#9
+  fulfillIncomingCallConnected**). Remote hangup: `call.ended`→**#3 reportNativeEnded
+  ('remoteEnded')**→`clearRoom`(**#1/#2**)+null.
+- **A**: same order. The reducer emits `reportIncoming`/`reportEnded` effects at
+  exactly the points M calls them; accept still routes through the mobile driver's
+  `answerCall`→listener→`acceptCallById`. **No reorder.**
+- **B**: **watch item** — `reportIncoming` must fire as a reducer effect *after*
+  `setIncomingCall`, matching M (#14 currently runs inside `handleCallEvent` after
+  `setIncomingCall`, L553-554). And `interceptAccept` must return `'handled'` so the
+  core does *not* call `api.acceptCall` directly — the CallKit listener does, later.
+  If B's core naively awaited accept inline, it would **reorder** (join before
+  CallKit `answerCall` acknowledges), which is a regression. Flagged.
+
+### (c) Incoming: ring → decline
+
+- **W**: `declineIncomingCall`→`declineCall`→`setIncomingCall(null)`→
+  `setDismissedCallIds.add`→`api.declineCall`.
+- **M**: `declineIncomingCall`→`setIncomingCall(null)`→`removeLiveCall`→
+  **#19 endCall(nativeId)**→`clearNativeMapping`→`api.declineCall` (on
+  `calls_unconfigured`, fall back to dismissed refs L712-717).
+- **A/B**: same order; decline is a `requestEnd` hook (#19) on mobile, no-op on web.
+  No reorder.
+
+### (d) Network drop mid-call → reconnect
+
+- LiveKit auto-reconnect is internal to `Room`; neither hook subscribes to
+  `Reconnecting`/`Reconnected` today — so from the hook's view a transient drop is
+  invisible unless it terminates as `RoomEvent.Disconnected`.
+- **On a terminal `Disconnected`** (unintentional): **W** → `onDisconnected`
+  (L290) → `api.leaveCall` + `notice`. **M** → `onDisconnected` (L292) →
+  **#4/#5 AudioSession.stop+restore** → `setActiveCall(null)` + notice →
+  **#3 reportNativeEnded('failed')** → `api.leaveCall`.
+- **A**: driver keeps its `onDisconnected`; effects unchanged. No reorder.
+- **B**: `onUnexpectedDisconnect` must run stop/restore (#4/#5) **before**
+  `reportEnded('failed')` (#3), matching M's L297-311 order. Expressible; call it
+  out as an ordering contract in the adapter doc or it *will* be gotten wrong.
+- Separately, mobile's **WS-down poll** (L811-817) is the real reconnect-recovery
+  path: while `wsStatus!=='open'` and chrome is visible it polls `refreshActiveCalls`
+  every 45s and reconciles. Web has **no** interval — it relies on `pagehide` +
+  post-reconnect `refreshActiveCalls()` chained in `Chat.tsx` (L1110). Both stay as
+  PLATFORM-HOOKs; no shared behavior to reorder.
+
+### (e) Mute toggle — from app UI, and (mobile) from CallKit system UI
+
+- **App UI, W**: `toggleMute`→`room.setMic(!next)`→`setActiveCall(muted=next)`;
+  on failure re-sync to real mic state + notice.
+- **App UI, M**: `toggleMute`→`applyNativeMute(nativeCallId,next)`:
+  `room.setMic(!next)`→`setActiveCall(muted=next)`→**#6 setNativeMuted**.
+- **CallKit UI, M only**: `addSetMutedActionListener`(**#27**)→`applyNativeMute`:
+  `room.setMic`→`setActiveCall`→**#6 setNativeMuted** (mirrors back — idempotent).
+- **A**: same. `applyMute` is a driver method; core doesn't touch the `Room`.
+- **B**: `applyMute` hook does `room.setMic`+`setNativeMuted`(#6). The CallKit path
+  enters via `subscribeNativeEvents.onMuted`→core `setMuted`→`applyMute`. Ordering
+  identical. No reorder. (One subtlety: today `applyNativeMute` sets `room.setMic`
+  *then* mirrors #6; a naive B that mirrored first would loop through the listener —
+  keep set-mic-first.)
+
+### (f) Second incoming call while one is active
+
+- **W**: an active call is present; `call.ringing` handler (L456) requires
+  `!activeCallRef.current` to set `incomingCall`, so the second ring is **not**
+  surfaced as a banner. If the user somehow calls `joinCall` for it,
+  `connectToCall` (L327) refuses with `notice('Leave the current call…')`. No
+  second `Room`.
+- **M**: `call.ringing` (L552) also requires `!activeCallRef.current` — banner
+  suppressed. `reportIncomingToNative` (L431) additionally guards on
+  `getActiveCallSession()`(**#13**) so it will **not** post a second CallKit
+  incoming while one session is live. `connectToCall` refuses (L346). No second
+  `Room`, no second CallKit call.
+- **A/B**: reducer preserves the `!active` guard; mobile adapter keeps the
+  `getActiveCallSession` guard inside `reportIncoming`. No reorder. **Neither
+  platform truly "handles" call-waiting today; the core must preserve the refusal,
+  not accidentally enable a second Room.**
+
+**Reorder-risk summary:** Design A introduces **no** reordering on any of (a)-(f).
+Design B introduces potential reordering in **(b)** (accept must be `'handled'`,
+not inline-awaited) and **(d)** (stop/restore before reportEnded) — both are
+adapter-contract ordering constraints that today are guaranteed by inline code and
+would become invariants a future edit could break.
+
+---
+
+## 6. LOC estimate
+
+Today: **744 (web) + 902 (mobile) = 1,646**, plus ~30 LOC duplicated in
+`callPresentation.ts`.
+
+**Design A (recommended):**
+
+| unit | est. LOC |
+|---|---|
+| `call-core.ts` (types + pure fns + `callEventReducer` + effects) | ~430 |
+| web `useCall.ts` driver (Room + refs + effect interpretation + pagehide + remoteAudioTracks) | ~300 |
+| mobile `useCall.ts` driver (Room + refs + all CallKit + native mapping + listeners + poll) | ~430 |
+| delete `callPresentation.ts` (folds into core) | −30 |
+| **total** | **~1,160** |
+
+Net: **~−490 LOC (~30%)**, concentrated in the reducer + pure-function dedupe.
+The mobile driver barely shrinks (CallKit is irreducible); the win is web +
+mobile *both* stop carrying their own copy of the reducer and enrichment.
+
+**Design B (adapter):**
+
+| unit | est. LOC |
+|---|---|
+| `useCallCore` shared hook (Room + reducer + adapter dispatch) | ~380 |
+| `CallPlatform` interface + shared types | ~80 |
+| web adapter | ~140 |
+| mobile adapter (all CallKit + native mapping + listeners) | ~360 |
+| web wrapper + mobile wrapper | ~60 |
+| **total** | **~1,020** |
+
+Net: **~−620 LOC**, but see Section 9 — the extra ~130 LOC saved buys a
+`livekit-client` dependency in `shared`, two new ordering invariants ((b),(d)),
+and indirection through 14 adapter methods at the most regression-sensitive seam.
+
+---
+
+## 7. Risk register (top 5)
+
+| # | risk | why | catch |
+|---|---|---|---|
+| R1 | A CallKit interleaving silently dropped in the refactor (e.g. #10 `reportOutgoingCallConnected` or #6 mute mirror) → CallKit shows call stuck "connecting" or mute desyncs | 28 sites, several fire only on real device (`NATIVE_CALL_UI=Device.isDevice`) and are `.catch(()=>{})`-swallowed | Real-iPhone QA of every row in the 1.8 table; a CI checklist mapping each # to a code site; unit test asserting the mobile driver calls each mocked CallKit fn on the right transition (extend `useCall.test.tsx`). |
+| R2 | Design B reorders accept (case (b)): core awaits `api.acceptCall` inline instead of letting CallKit `answerCall`→listener drive it → double-join or CallKit "answer" with no media | inline-await is the intuitive adapter shape; today's indirection is load-bearing | Unit test: `acceptIncomingCall` with `NATIVE_CALL_UI=true`+mapped nativeId calls `answerCall` and does **not** call `api.acceptCall` synchronously (only via the answered listener). Real-iPhone answer-from-lock-screen QA. |
+| R3 | `livekit-client` pulled into `shared` (Design B) forces a single version; web `^2.15.13` vs mobile `2.19.1` drift causes type or runtime skew, and non-call `shared` consumers bloat | packaging coupling described in 4.1 | Design A avoids entirely (no LiveKit in core). If B: `pnpm --filter @atrium/web build:ci` + mobile typecheck + bundle-size check; verify tree-shaking of the call module. |
+| R4 | Live-list sort flip (D1): unifying `sortLiveCalls` changes which recoverable/live call surfaces first on one platform | web ASC vs mobile DESC (L128 vs L75) | Unit test pinning order for both directions; mobile QA that `recoverableCall` still picks the intended call after multiple concurrent calls. |
+| R5 | Ring-timeout reconciliation (D4): moving web from 45s→60s shared TTL changes "No answer" timing; or a missed reconcile leaves web at 45s while server sweeps at 60s | web hardcodes `RING_TIMEOUT_MS=45_000` (L35) vs shared `CALL_RING_TTL_MS=60_000` | Unit test on the ring-timeout effect using fake timers at the shared constant; web browser-QA of an unanswered outgoing call. |
+
+Runner-up risks: web `remoteAudioTracks`/autoplay attachment lost if the web
+driver stops walking existing `remoteParticipants` on connect (silent no-audio for
+already-published tracks); `dismissedCallIds` reactivity (D2) — if core stores it
+as refs, web's `liveCallForChannel` memo (L448) and re-enrich effect (L197) stop
+updating.
+
+---
+
+## 8. Validation plan
+
+**Unit tests (extend `surface/mobile/test/useCall.test.tsx` + add a shared
+`call-core.test.ts`):**
+
+- Pure `call-core`: property tests for `upsertUser` merge (fallback never
+  overwrites real, D7), `enrichParticipants` dedupe, `sortLiveCalls` both
+  directions (R4), `isExpiredRing` at the shared TTL boundary.
+- `callEventReducer`: table-driven over all 6 `CallEvent` types × {active/incoming/
+  neither present}, asserting the returned state atoms **and** the emitted effect
+  list (e.g. `participant_left` last-leave emits `endedByLastLeave` — mobile L611-624).
+- Mobile driver with mocked `expo-callkit-telecom` (`NATIVE_CALL_UI=true`): assert
+  each CallKit fn from the 1.8 table is invoked on its transition, and **not**
+  invoked when `NATIVE_CALL_UI=false`. Assert accept routes via `answerCall` not
+  `api.acceptCall` (R2). Keep the four existing tests green (stale-ring, dismissed
+  persistence, ring TTL, WS-down poll gating).
+- Web driver: `toggleMute` failure re-syncs to real mic state; `onDisconnected`
+  unintentional path calls `api.leaveCall` + sets notice; `remoteAudioTracks`
+  add/remove on Track events.
+
+**Web browser-QA (local LiveKit from `surface/docker compose up -d --wait`, then
+`pnpm dev`; two browser profiles as two users, or the demo stream):**
+
+- Outgoing call: start from channel header, second profile sees ring, accept,
+  confirm two-way audio (the `<audio autoPlay>` attach path), mute toggles both
+  ways, hang up from each side, "No answer" after the (now 60s) timeout.
+- Reconnect: kill/restore the WS; confirm `refreshActiveCalls` reconciles and no
+  phantom active call. `pagehide`: close the tab mid-call, confirm the beacon
+  `leave` fires (server shows participant left).
+- Per-channel live-call banner (`liveCallForChannel`) still renders and
+  `declineCall` dismisses it.
+
+**Cannot be validated without a real iPhone (residual risk Gary must accept):**
+the entire CallKit surface only runs when `NATIVE_CALL_UI` (`Device.isDevice`) is
+true — the simulator and unit mocks exercise our *call sites*, not iOS's CallKit
+behavior. Specifically unverifiable off-device: answer-from-lock-screen and
+answer-from-CallKit-UI (#18/#23), decline/end from the system call UI (#19/#20/#26),
+system mute mirroring both directions (#6/#27), `AudioSession` route/restore
+correctness (#1/#2/#4/#5/#8) so audio still plays after a call, VoIP-push→
+`reportIncomingCall` interplay (#14), and outgoing-call "recents" grouping by
+channelId handle (#17). Every one of these is `.catch(()=>{})`-swallowed, so a
+regression is **silent** in logs. The verification matrix for a real-device pass is
+exactly the 28-row table in Section 1.8.
+
+---
+
+## 9. Verdict and recommended cut
+
+**Ship Design A (pure core + thin drivers). Do not ship Design B.**
+
+Reasoning:
+
+1. The duplication that actually hurts is the **reducer + enrichment + pure
+   helpers + duplicated `callPresentation.ts`** — ~450 LOC of near-identical logic
+   that A deletes with zero LiveKit/CallKit coupling and zero new ordering
+   invariants. This is the ">34% identical" the verification found, plus the
+   SHARED-WITH-PARAM tier.
+2. Design B saves only ~130 LOC *more* than A, and buys three concrete liabilities:
+   `livekit-client` in `shared` across two diverging versions (R3/4.1), and two new
+   correctness invariants at the CallKit seam ((b) accept-routing, (d) stop-before-
+   report) that inline code guarantees today and an adapter would leave to a future
+   edit to break (R1/R2). The mobile native-mapping bookkeeping (~150 LOC, 6 refs,
+   `rememberNativeSession`/`clearNativeMapping`/dedupe sets) does **not** generalize
+   into the adapter regardless — so B's own core still can't touch the gnarliest
+   mobile-only state. The indirection lands exactly where regressions are most
+   expensive and least observable (real-iPhone, error-swallowed).
+3. Put bluntly: the CallKit mirroring is entangled enough that a hook-based core
+   adds indirection without deleting much of it. The room drivers should stay
+   separate.
+
+**Recommended concrete cut (Design A), in priority order:**
+
+1. Create `surface/shared/src/call-core.ts` (`@atrium/surface-client/call-core`),
+   LiveKit-free and CallKit-free: state types (`BaseActiveCallState`, `CallPhase`),
+   all pure helpers, and `callEventReducer(state,event,ctx) → {state, effects}`.
+   Adopt web's merge-aware enrichment and the shared `CALL_RING_TTL_MS`.
+2. Delete `surface/web/src/callPresentation.ts`; re-export `userForCall`/
+   `labelForCallChannel` from the core; repoint `Chat.tsx` (L35).
+3. Rewrite both `useCall` hooks as thin drivers over the core: each keeps its
+   `Room`, refs, and effects, and interprets the reducer's effect list (web ignores
+   CallKit effects; mobile acts on them via its unchanged native code).
+4. Reconcile the four documented divergences during the move: D1 sort (pick ASC),
+   D2 dismissed-storage (state in core, mobile keeps its channel `Map` companion),
+   D3 refresh scoping (optional `channelId`), D4/R5 ring timeout (shared 60s).
+5. Land with the Section 8 unit tests **plus a real-iPhone pass over the full 1.8
+   table** before it reaches the deploy branch — the mobile driver's public
+   behavior must be byte-for-byte the same, and only a device proves it.
+
+If even Design A feels too broad for one PR, the **minimum worth-it slice** is
+steps 1-2 (types + pure helpers + `callEventReducer` + kill `callPresentation.ts`)
+while leaving both `handleCallEvent` bodies calling the shared reducer but the rest
+of each hook untouched. That captures the bulk of the real duplication with the
+mobile `Room`/CallKit driver entirely unmoved — the lowest-risk high-value cut.
diff --git a/surface/mobile/src/components/GlobalCallUI.tsx b/surface/mobile/src/components/GlobalCallUI.tsx
index 18dd44b1e..166768898 100644
--- a/surface/mobile/src/components/GlobalCallUI.tsx
+++ b/surface/mobile/src/components/GlobalCallUI.tsx
@@ -2,9 +2,8 @@ import type { ReactNode } from 'react';
 import { View } from 'react-native';
 import { SafeAreaInsetsContext, useSafeAreaInsets } from 'react-native-safe-area-context';
 import { useSegments } from 'expo-router';
-import type { CallWire, Channel, UserRef } from '@atrium/surface-client';
 import { useChat } from '../lib/chat';
-import { labelForCallChannel } from '../lib/useCall';
+import { labelForCallChannel, userForCall } from '../lib/useCall';
 import { CallNotice, InCallPanel, IncomingCallBanner, JoinCallStrip } from './CallUI';
 
 type CallState = ReturnType<typeof useChat>['calls'];
@@ -48,18 +47,6 @@ export function CallBannerLayout({ children }: { children: ReactNode }) {
   );
 }
 
-function fallbackUser(id: string): UserRef {
-  return { id, handle: id, displayName: id };
-}
-
-function userForCall(call: CallWire, channels: Channel[], userId: string): UserRef {
-  return (
-    call.participants.find((u) => u.id === userId) ??
-    channels.find((c) => c.id === call.channelId)?.members?.find((u) => u.id === userId) ??
-    fallbackUser(userId)
-  );
-}
-
 /**
  * App-wide call surfaces — the incoming-ring banner, the in-call panel, and the
  * transient notice — rendered once at the layout root so a call shows on ANY
diff --git a/surface/mobile/src/lib/useCall.ts b/surface/mobile/src/lib/useCall.ts
index e232019c5..feccc18a8 100644
--- a/surface/mobile/src/lib/useCall.ts
+++ b/surface/mobile/src/lib/useCall.ts
@@ -24,8 +24,25 @@ import {
 } from 'expo-callkit-telecom';
 import {
   ApiError,
+  AUDIO_CAPTURE_OPTIONS,
+  type BaseActiveCallState,
+  CALL_ORDER_DESC,
   CALL_RING_TTL_MS,
-  channelLabel,
+  type CallContext,
+  callEventReducer,
+  type CallListContext,
+  isExpiredRing,
+  isLiveCall,
+  labelForCallChannel,
+  MOBILE_CALL_POLICY,
+  removeLiveCall,
+  removeUser,
+  sortLiveCalls,
+  updateLiveCall,
+  upsertLiveCall,
+  upsertUser,
+  userForCall,
+  withSelf,
   type Api,
   type AppState,
   type CallEvent,
@@ -36,93 +53,27 @@ import {
 } from '@atrium/surface-client';
 import { NATIVE_CALL_UI } from './nativeCallUi';
 
-export interface ActiveCallState {
-  call: CallWire;
-  phase: 'connecting' | 'connected' | 'ended';
-  participants: UserRef[];
-  activeSpeakerIds: Set<string>;
-  muted: boolean;
-  error: string | null;
-  nativeCallId?: string;
-}
-
-const AUDIO_CAPTURE_OPTIONS = {
-  echoCancellation: true,
-  noiseSuppression: true,
-  autoGainControl: true,
-};
-const CALL_REFRESH_INTERVAL_MS = 45_000;
-
-function fallbackUser(id: string): UserRef {
-  return { id, handle: id, displayName: id };
-}
-
-function upsertUser(users: UserRef[], user: UserRef): UserRef[] {
-  return users.some((u) => u.id === user.id) ? users : [...users, user];
-}
-
-function removeUser(users: UserRef[], userId: string): UserRef[] {
-  return users.filter((u) => u.id !== userId);
-}
-
-function participantsFor(call: CallWire, me: UserRef): UserRef[] {
-  return call.participants.some((u) => u.id === me.id) ? call.participants : [me, ...call.participants];
-}
-
-function sortLiveCalls(calls: CallWire[]): CallWire[] {
-  return [...calls]
-    .filter((call) => call.status !== 'ended')
-    .sort((a, b) => Date.parse(b.startedAt) - Date.parse(a.startedAt));
-}
+// Re-exported for the mobile call banners (GlobalCallUI); the implementations
+// now live in the shared, platform-independent call-core.
+export { labelForCallChannel, userForCall } from '@atrium/surface-client';
 
-function upsertLiveCall(calls: CallWire[], call: CallWire): CallWire[] {
-  if (call.status === 'ended') return calls.filter((existing) => existing.id !== call.id);
-  const index = calls.findIndex((existing) => existing.id === call.id);
-  if (index === -1) return sortLiveCalls([call, ...calls]);
-  const next = calls.map((existing, i) => (i === index ? call : existing));
-  return sortLiveCalls(next);
-}
-
-function updateLiveCall(calls: CallWire[], callId: string, update: (call: CallWire) => CallWire): CallWire[] {
-  let changed = false;
-  const next = calls.map((call) => {
-    if (call.id !== callId) return call;
-    changed = true;
-    return update(call);
-  });
-  return changed ? sortLiveCalls(next) : calls;
-}
-
-function removeLiveCall(calls: CallWire[], callId: string): CallWire[] {
-  return calls.filter((call) => call.id !== callId);
+// Mobile adds the CallKit session handle (`nativeCallId`) to the shared
+// six-field base; the shared reducer preserves it untouched.
+export interface ActiveCallState extends BaseActiveCallState {
+  nativeCallId?: string;
 }
 
-function ringAgeMs(call: CallWire): number {
-  return Date.now() - Date.parse(call.startedAt);
-}
+// Mobile keeps its newest-first order and stores calls raw (no channel-member
+// enrichment) — see design D1. This context feeds the shared list helpers and
+// reducer.
+const MOBILE_LIST: CallListContext = { order: CALL_ORDER_DESC, normalizeCall: (call) => call };
 
-function isExpiredRing(call: CallWire): boolean {
-  return call.status === 'ringing' && ringAgeMs(call) >= CALL_RING_TTL_MS;
-}
+const CALL_REFRESH_INTERVAL_MS = 45_000;
 
 function callUnavailable(err: unknown): boolean {
   return err instanceof ApiError && err.status === 503 && err.code === 'calls_unconfigured';
 }
 
-function userForCall(call: CallWire, channels: Channel[], userId: string): UserRef {
-  return (
-    call.participants.find((u) => u.id === userId) ??
-    channels.find((c) => c.id === call.channelId)?.members?.find((u) => u.id === userId) ??
-    fallbackUser(userId)
-  );
-}
-
-export function labelForCallChannel(call: CallWire, channels: Channel[], meId: string): string {
-  const channel = channels.find((c) => c.id === call.channelId);
-  if (!channel) return 'Unknown channel';
-  return channel.kind === 'private' ? `#${channel.name}` : channelLabel(channel, meId);
-}
-
 function incomingCallEventFor(call: CallWire, caller: UserRef, channelName: string): IncomingCallEvent {
   return {
     eventId: call.id,
@@ -359,11 +310,11 @@ export function useCall({
       setRoomHandlers(room);
       setIncomingCall((call) => (call?.id === join.call.id ? null : call));
       setNotice(null);
-      setRecoverableCalls((calls) => upsertLiveCall(calls, join.call));
+      setRecoverableCalls((calls) => upsertLiveCall(calls, join.call, MOBILE_LIST));
       setActiveCall({
         call: join.call,
         phase: 'connecting',
-        participants: participantsFor(join.call, me),
+        participants: withSelf(join.call, me),
         activeSpeakerIds: new Set(),
         muted: false,
         error: null,
@@ -494,11 +445,17 @@ export function useCall({
           }
         }
         const liveCalls = sortLiveCalls(
-          snapshot.calls.filter((call) => !isExpiredRing(call) && !dismissedCallIdsRef.current.has(call.id)),
+          snapshot.calls.filter(
+            (call) => isLiveCall(call) && !isExpiredRing(call) && !dismissedCallIdsRef.current.has(call.id),
+          ),
+          CALL_ORDER_DESC,
         );
         setRecoverableCalls((current) =>
           opts.channelId
-            ? sortLiveCalls([...current.filter((call) => call.channelId !== opts.channelId), ...liveCalls])
+            ? sortLiveCalls(
+                [...current.filter((call) => call.channelId !== opts.channelId), ...liveCalls],
+                CALL_ORDER_DESC,
+              )
             : liveCalls,
         );
         applyIncomingSnapshot(liveCalls, opts.channelId);
@@ -539,105 +496,54 @@ export function useCall({
     [api, connectToCall, setAnswering],
   );
 
+  const buildContext = useCallback(
+    (): CallContext => ({
+      me,
+      list: MOBILE_LIST,
+      participantsFor: (call) => withSelf(call, me),
+      policy: MOBILE_CALL_POLICY,
+    }),
+    [me],
+  );
+
   const handleCallEvent = useCallback(
     (event: CallEvent) => {
-      if (event.type === 'call.ringing') {
-        if (dismissedCallIdsRef.current.has(event.call.id) || isExpiredRing(event.call)) {
-          setIncomingCall((call) => (call?.id === event.call.id ? null : call));
-          setRecoverableCalls((calls) => removeLiveCall(calls, event.call.id));
-          reportNativeEnded(event.call.id, 'unanswered');
-          return;
-        }
-        setRecoverableCalls((calls) => upsertLiveCall(calls, event.call));
-        if (event.call.initiatorId !== me.id && !activeCallRef.current) {
-          setIncomingCall(event.call);
-          reportIncomingToNative(event.call);
-        }
-        setActiveCall((current) =>
-          current?.call.id === event.call.id
-            ? {
-                ...current,
-                call: event.call,
-                participants: participantsFor(event.call, me),
-              }
-            : current,
-        );
-        return;
-      }
-
-      if (event.type === 'call.accepted' || event.type === 'call.participant_joined') {
-        setIncomingCall((call) =>
-          call?.id === event.callId
-            ? event.user.id === me.id
-              ? null
-              : { ...call, status: 'active', participants: upsertUser(call.participants, event.user) }
-            : call,
-        );
-        setRecoverableCalls((calls) =>
-          updateLiveCall(calls, event.callId, (call) => ({
-            ...call,
-            status: 'active',
-            participants: upsertUser(call.participants, event.user),
-          })),
-        );
-        setActiveCall((current) =>
-          current?.call.id === event.callId
-            ? {
-                ...current,
-                call: { ...current.call, status: 'active' },
-                participants: upsertUser(current.participants, event.user),
-              }
-            : current,
-        );
-        return;
-      }
-
-      if (event.type === 'call.declined') {
-        setIncomingCall((call) => (call?.id === event.callId && event.userId === me.id ? null : call));
-        if (event.userId === me.id) {
-          setRecoverableCalls((calls) => removeLiveCall(calls, event.callId));
+      const prev = {
+        active: activeCallRef.current,
+        incoming: incomingCallRef.current,
+        live: recoverableCallsRef.current,
+        dismissed: dismissedCallIdsRef.current,
+      };
+      const { state: next, effects } = callEventReducer<ActiveCallState>(prev, event, buildContext());
+
+      // Advance the refs before React renders: a second CallEvent arriving
+      // before the re-render would otherwise read a stale snapshot and drop
+      // this transition.
+      activeCallRef.current = next.active;
+      incomingCallRef.current = next.incoming;
+      recoverableCallsRef.current = next.live;
+
+      if (next.active !== prev.active) setActiveCall(next.active);
+      if (next.incoming !== prev.incoming) setIncomingCall(next.incoming);
+      if (next.live !== prev.live) setRecoverableCalls(next.live);
+      if (next.dismissed !== prev.dismissed) {
+        // Mobile keeps `dismissed` in a ref (plus a per-channel companion map).
+        // Prune the companion map to the surviving ids — byte-equivalent to the
+        // explicit deletions the inline `call.ended` branch performed.
+        dismissedCallIdsRef.current = next.dismissed;
+        for (const key of [...dismissedCallChannelsRef.current.keys()]) {
+          if (!next.dismissed.has(key)) dismissedCallChannelsRef.current.delete(key);
         }
-        if (event.userId === me.id) reportNativeEnded(event.callId, 'declinedElsewhere');
-        return;
       }
 
-      if (event.type === 'call.participant_left') {
-        setRecoverableCalls((calls) =>
-          updateLiveCall(calls, event.callId, (call) => ({
-            ...call,
-            participants: removeUser(call.participants, event.userId),
-          })),
-        );
-        let endedByLastLeave = false;
-        setActiveCall((current) => {
-          if (current?.call.id !== event.callId) return current;
-          const participants = removeUser(current.participants, event.userId);
-          const remoteCount = participants.filter((p) => p.id !== me.id).length;
-          if (current.call.status === 'active' && remoteCount === 0) endedByLastLeave = true;
-          return {
-            ...current,
-            participants,
-            activeSpeakerIds: new Set([...current.activeSpeakerIds].filter((id) => id !== event.userId)),
-          };
-        });
-        // Side effect outside the (possibly double-invoked) updater.
-        if (endedByLastLeave) reportNativeEnded(event.callId, 'remoteEnded');
-        return;
-      }
-
-      if (event.type === 'call.ended') {
-        dismissedCallIdsRef.current.delete(event.callId);
-        dismissedCallChannelsRef.current.delete(event.callId);
-        setIncomingCall((call) => (call?.id === event.callId ? null : call));
-        setRecoverableCalls((calls) => removeLiveCall(calls, event.callId));
-        reportNativeEnded(event.callId, 'remoteEnded');
-        if (activeCallRef.current?.call.id === event.callId) {
-          clearRoom();
-          setActiveCall(null);
-        }
+      for (const effect of effects) {
+        if (effect.kind === 'reportIncoming') reportIncomingToNative(effect.call);
+        else if (effect.kind === 'reportEnded') reportNativeEnded(effect.callId, effect.reason);
+        else if (effect.kind === 'clearActiveRoom') clearRoom();
+        // activeParticipantLeft is a web-only audio-track concern, ignored here.
       }
     },
-    [clearRoom, me, reportIncomingToNative, reportNativeEnded],
+    [buildContext, clearRoom, reportIncomingToNative, reportNativeEnded],
   );
 
   const startCall = useCallback(
@@ -747,10 +653,15 @@ export function useCall({
     clearRoom();
     setActiveCall(null);
     setRecoverableCalls((calls) =>
-      updateLiveCall(calls, callId, (call) => ({
-        ...call,
-        participants: removeUser(call.participants, me.id),
-      })),
+      updateLiveCall(
+        calls,
+        callId,
+        (call) => ({
+          ...call,
+          participants: removeUser(call.participants, me.id),
+        }),
+        MOBILE_LIST,
+      ),
     );
     try {
       await api.leaveCall(callId);
diff --git a/surface/shared/package.json b/surface/shared/package.json
index ad93aa997..938bbe488 100644
--- a/surface/shared/package.json
+++ b/surface/shared/package.json
@@ -13,6 +13,7 @@
     "./reactions": "./src/reactions.ts",
     "./prefs": "./src/prefs.ts",
     "./calls": "./src/calls.ts",
+    "./call-core": "./src/call-core.ts",
     "./sessions": "./src/sessions.ts",
     "./agentProfiles": "./src/agentProfiles.ts",
     "./effort": "./src/effort.ts",
diff --git a/surface/shared/src/call-core.ts b/surface/shared/src/call-core.ts
new file mode 100644
index 000000000..9dc36c530
--- /dev/null
+++ b/surface/shared/src/call-core.ts
@@ -0,0 +1,459 @@
+// @atrium/surface-client/call-core — the platform-independent brain for voice
+// calls, shared by the web and mobile `useCall` drivers.
+//
+// This module is deliberately **LiveKit-free and CallKit-free**: it never
+// imports `livekit-client`, `@livekit/react-native`, or `expo-callkit-telecom`.
+// The two platform drivers own the LiveKit `Room` and (on mobile) the CallKit /
+// AudioSession call sites; they translate `RoomEvent`s into `CallEvent`s and
+// interpret the pure `callEventReducer`'s state + effect output. See
+// docs/archive/notes/2026-07-21-call-core-design.md (Design A).
+//
+// Two behaviour changes were made deliberately during consolidation and are
+// documented at their call sites below:
+//  1. `upsertUser` is merge-aware on BOTH platforms (previously mobile was
+//     add-only). Fallback identities never overwrite real users; real users
+//     upgrade fallbacks. (design D7)
+//  2. The ring TTL is unified on the shared `CALL_RING_TTL_MS` (60s). Web
+//     previously hard-coded a 45s outgoing "No answer" timeout that disagreed
+//     with the server sweeper — the drivers now import the shared constant.
+//     (design D4/R5) — the constant lives in ./calls; this module re-uses it.
+
+import { CALL_RING_TTL_MS } from './calls';
+import type { CallEvent, CallWire } from './calls';
+import type { Channel } from './api';
+import type { UserRef } from './timeline';
+import { channelLabel } from './util';
+
+// ---------------------------------------------------------------------------
+// State types
+// ---------------------------------------------------------------------------
+
+export type CallPhase = 'connecting' | 'connected' | 'ended';
+
+/**
+ * The six fields common to both platforms' active-call state. Each app
+ * intersects this with its own extra field: web adds `remoteAudioTracks`
+ * (its autoplay-attachment slice), mobile adds `nativeCallId` (the CallKit
+ * session handle). The reducer is generic over `A extends BaseActiveCallState`
+ * and only ever touches the common fields — it preserves the extra fields by
+ * spreading the current active object.
+ */
+export interface BaseActiveCallState {
+  call: CallWire;
+  phase: CallPhase;
+  participants: UserRef[];
+  activeSpeakerIds: Set<string>;
+  muted: boolean;
+  error: string | null;
+}
+
+/** Shared capture constraints for the local mic track. */
+export const AUDIO_CAPTURE_OPTIONS = {
+  echoCancellation: true,
+  noiseSuppression: true,
+  autoGainControl: true,
+};
+
+// ---------------------------------------------------------------------------
+// User helpers (enrichment)
+// ---------------------------------------------------------------------------
+
+export function fallbackUser(identity: string): UserRef {
+  return { id: identity, handle: identity, displayName: identity };
+}
+
+export function isFallbackUser(user: UserRef): boolean {
+  return user.handle === user.id && user.displayName === user.id;
+}
+
+export function mergeUser(existing: UserRef, next: UserRef): UserRef {
+  if (isFallbackUser(next) && !isFallbackUser(existing)) return existing;
+  if (existing.handle === next.handle && existing.displayName === next.displayName && existing.id === next.id) {
+    return existing;
+  }
+  return next;
+}
+
+/**
+ * Merge-aware upsert (adopted on BOTH platforms — design D7). A fallback
+ * identity never clobbers an already-resolved user; a real user upgrades a
+ * fallback. Returns the same array reference when nothing changed.
+ */
+export function upsertUser(users: UserRef[], user: UserRef): UserRef[] {
+  const index = users.findIndex((u) => u.id === user.id);
+  if (index === -1) return [...users, user];
+  const existing = users[index];
+  if (!existing) return users;
+  const next = mergeUser(existing, user);
+  if (next === existing) return users;
+  return users.map((u, i) => (i === index ? next : u));
+}
+
+export function removeUser(users: UserRef[], userId: string): UserRef[] {
+  return users.filter((u) => u.id !== userId);
+}
+
+export function dedupeUsers(users: UserRef[]): UserRef[] {
+  return users.reduce<UserRef[]>((acc, user) => upsertUser(acc, user), []);
+}
+
+/**
+ * Resolve a single identity to the richest known `UserRef`, preferring a
+ * non-fallback record from the call participants, channel membership, or the
+ * already-known users, and falling back to an identity-shaped user.
+ */
+export function userFromIdentity(
+  identity: string,
+  call: CallWire,
+  me: UserRef,
+  channels: Channel[],
+  knownUsers: UserRef[] = [],
+): UserRef {
+  if (identity === me.id) return me;
+  const channelMember = channels
+    .find((channel) => channel.id === call.channelId)
+    ?.members?.find((u) => u.id === identity);
+  const callParticipant = call.participants.find((u) => u.id === identity);
+  const knownUser = knownUsers.find((u) => u.id === identity);
+  const candidates = [channelMember, callParticipant, knownUser].filter((user): user is UserRef => user != null);
+  return candidates.find((user) => !isFallbackUser(user)) ?? candidates[0] ?? fallbackUser(identity);
+}
+
+export function enrichParticipants(users: UserRef[], call: CallWire, me: UserRef, channels: Channel[]): UserRef[] {
+  return dedupeUsers(users.map((user) => userFromIdentity(user.id, call, me, channels, users)));
+}
+
+/** The participants array with `me` prepended when not already present. */
+export function withSelf(call: CallWire, me: UserRef): UserRef[] {
+  return call.participants.some((u) => u.id === me.id) ? call.participants : [me, ...call.participants];
+}
+
+// ---------------------------------------------------------------------------
+// Presentation helpers (formerly duplicated in web/callPresentation.ts and
+// mobile/useCall.ts — one copy now).
+// ---------------------------------------------------------------------------
+
+/**
+ * The simplest caller/participant resolution used by the banners: call
+ * participants first, then channel membership, then an identity-shaped
+ * fallback. (This is the presentation-layer resolver, distinct from the
+ * richer `userFromIdentity` used inside the active-call enrichment.)
+ */
+export function userForCall(call: CallWire, channels: Channel[], userId: string): UserRef {
+  return (
+    call.participants.find((u) => u.id === userId) ??
+    channels.find((c) => c.id === call.channelId)?.members?.find((u) => u.id === userId) ??
+    fallbackUser(userId)
+  );
+}
+
+export function labelForCallChannel(call: CallWire, channels: Channel[], meId: string): string {
+  const channel = channels.find((c) => c.id === call.channelId);
+  if (!channel) return 'Unknown channel';
+  return channel.kind === 'private' ? `#${channel.name}` : channelLabel(channel, meId);
+}
+
+// ---------------------------------------------------------------------------
+// Ring lifetime
+// ---------------------------------------------------------------------------
+
+export function ringAgeMs(call: CallWire): number {
+  return Date.now() - Date.parse(call.startedAt);
+}
+
+/** A ringing call older than the shared TTL is dead and must never surface. */
+export function isExpiredRing(call: CallWire): boolean {
+  return call.status === 'ringing' && ringAgeMs(call) >= CALL_RING_TTL_MS;
+}
+
+export function isLiveCall(call: CallWire): boolean {
+  return call.status !== 'ended';
+}
+
+// ---------------------------------------------------------------------------
+// Live-call list bookkeeping
+// ---------------------------------------------------------------------------
+
+export type CallComparator = (a: CallWire, b: CallWire) => number;
+
+/**
+ * Web's stable total order: ascending `startedAt`, id tiebreak. Because it is a
+ * total order the pre-sort insertion position is irrelevant.
+ */
+export const CALL_ORDER_ASC: CallComparator = (a, b) =>
+  a.startedAt.localeCompare(b.startedAt) || a.id.localeCompare(b.id);
+
+/**
+ * Mobile's order: descending `startedAt` (newest first), no tiebreak. This is
+ * NOT a total order, so ties preserve input order under a stable sort — new
+ * calls must be inserted at the front to reproduce mobile's behaviour.
+ */
+export const CALL_ORDER_DESC: CallComparator = (a, b) => Date.parse(b.startedAt) - Date.parse(a.startedAt);
+
+/**
+ * Sort a live-call list. The comparator is a parameter so each UI keeps its
+ * existing order: web passes `CALL_ORDER_ASC`, mobile passes `CALL_ORDER_DESC`
+ * — the consolidation must not silently flip either. (design D1/R4)
+ */
+export function sortLiveCalls(calls: CallWire[], compare: CallComparator): CallWire[] {
+  return [...calls].sort(compare);
+}
+
+/**
+ * Context the live-list helpers and the reducer need: the platform's sort
+ * order and how it normalizes a call before storing it. Web enriches
+ * participants (`normalizeCall`); mobile stores raw (identity `normalizeCall`).
+ */
+export interface CallListContext {
+  order: CallComparator;
+  /** Enrich (web) or identity (mobile). Applied whenever a call enters state. */
+  normalizeCall: (call: CallWire) => CallWire;
+}
+
+export function normalizeLiveCalls(calls: CallWire[], ctx: CallListContext): CallWire[] {
+  return sortLiveCalls(calls.filter(isLiveCall).map(ctx.normalizeCall), ctx.order);
+}
+
+export function upsertLiveCall(calls: CallWire[], call: CallWire, ctx: CallListContext): CallWire[] {
+  if (!isLiveCall(call)) return calls.filter((current) => current.id !== call.id);
+  const next = ctx.normalizeCall(call);
+  const index = calls.findIndex((current) => current.id === next.id);
+  // Prepend on insert: byte-identical to mobile's newest-first list, and
+  // irrelevant to web's total-order sort.
+  if (index === -1) return sortLiveCalls([next, ...calls], ctx.order);
+  return sortLiveCalls(
+    calls.map((current, i) => (i === index ? next : current)),
+    ctx.order,
+  );
+}
+
+export function updateLiveCall(
+  calls: CallWire[],
+  callId: string,
+  update: (call: CallWire) => CallWire,
+  ctx: CallListContext,
+): CallWire[] {
+  let found = false;
+  const next = calls.flatMap((call) => {
+    if (call.id !== callId) return [call];
+    found = true;
+    const updated = update(call);
+    return isLiveCall(updated) ? [ctx.normalizeCall(updated)] : [];
+  });
+  return found ? sortLiveCalls(next, ctx.order) : calls;
+}
+
+export function removeLiveCall(calls: CallWire[], callId: string): CallWire[] {
+  return calls.filter((call) => call.id !== callId);
+}
+
+// ---------------------------------------------------------------------------
+// The CallEvent reducer
+// ---------------------------------------------------------------------------
+
+/** Reasons the mobile driver reports a call ended to CallKit. */
+export type NativeEndReason = 'remoteEnded' | 'failed' | 'declinedElsewhere' | 'unanswered';
+
+/**
+ * Intent effects the reducer emits. Each driver interprets the subset it cares
+ * about and ignores the rest: web acts on `clearActiveRoom` /
+ * `activeParticipantLeft`; mobile acts on `clearActiveRoom` / `reportIncoming`
+ * / `reportEnded`.
+ */
+export type CallEffect =
+  | { kind: 'reportIncoming'; call: CallWire }
+  | { kind: 'reportEnded'; callId: string; reason: NativeEndReason }
+  | { kind: 'clearActiveRoom'; callId: string }
+  | { kind: 'activeParticipantLeft'; userId: string };
+
+/**
+ * Platform policy pinning the branches where web and mobile legitimately
+ * diverge today (design §3). Characterization tests fix each platform's
+ * expected value through these flags rather than silently unifying behaviour.
+ */
+export interface CallPolicy {
+  /** mobile: drop an already-dismissed/expired ring (and report `unanswered`). */
+  guardStaleRing: boolean;
+  /** web: also require not-dismissed before surfacing the incoming banner. */
+  suppressDismissedIncoming: boolean;
+  /** mobile: keep (and update) the incoming banner when someone else accepts. */
+  keepIncomingOnOtherAccept: boolean;
+  /** web `dismiss` (add to dismissed set) vs mobile `removeLive` (+ report). */
+  declineByMe: 'dismiss' | 'removeLive';
+  /** web: a self-accept clears the call from the dismissed set. */
+  clearDismissedOnSelfAccept: boolean;
+  /** mobile: report `remoteEnded` when the last remote participant leaves. */
+  reportLastLeave: boolean;
+}
+
+export const WEB_CALL_POLICY: CallPolicy = {
+  guardStaleRing: false,
+  suppressDismissedIncoming: true,
+  keepIncomingOnOtherAccept: false,
+  declineByMe: 'dismiss',
+  clearDismissedOnSelfAccept: true,
+  reportLastLeave: false,
+};
+
+export const MOBILE_CALL_POLICY: CallPolicy = {
+  guardStaleRing: true,
+  suppressDismissedIncoming: false,
+  keepIncomingOnOtherAccept: true,
+  declineByMe: 'removeLive',
+  clearDismissedOnSelfAccept: false,
+  reportLastLeave: true,
+};
+
+/**
+ * Everything the reducer needs beyond the atoms: the local user, the live-list
+ * context (order + normalize), a participant resolver for the active call, and
+ * the platform policy.
+ */
+export interface CallContext {
+  me: UserRef;
+  list: CallListContext;
+  /** web enriches + prepends self; mobile prepends self only. */
+  participantsFor: (call: CallWire) => UserRef[];
+  policy: CallPolicy;
+}
+
+/** The three reactive atoms plus the dismissed-id set. */
+export interface CallReducerState<A extends BaseActiveCallState> {
+  active: A | null;
+  incoming: CallWire | null;
+  live: CallWire[];
+  dismissed: Set<string>;
+}
+
+export interface CallReducerResult<A extends BaseActiveCallState> {
+  state: CallReducerState<A>;
+  effects: CallEffect[];
+}
+
+/**
+ * Pure `(state, event, ctx) → { state, effects }` transition. Returns the same
+ * atom references when unchanged so drivers can skip needless `setState`s. All
+ * platform-specific side effects (LiveKit room teardown, CallKit reports, web
+ * audio-track pruning) are expressed as `effects` the driver interprets.
+ */
+export function callEventReducer<A extends BaseActiveCallState>(
+  state: CallReducerState<A>,
+  event: CallEvent,
+  ctx: CallContext,
+): CallReducerResult<A> {
+  const { me, policy } = ctx;
+  let { active, incoming, live, dismissed } = state;
+  const effects: CallEffect[] = [];
+
+  const done = (): CallReducerResult<A> => ({ state: { active, incoming, live, dismissed }, effects });
+
+  if (event.type === 'call.ringing') {
+    const call = event.call;
+    if (policy.guardStaleRing && (dismissed.has(call.id) || isExpiredRing(call))) {
+      if (incoming?.id === call.id) incoming = null;
+      live = removeLiveCall(live, call.id);
+      effects.push({ kind: 'reportEnded', callId: call.id, reason: 'unanswered' });
+      return done();
+    }
+    const normalized = ctx.list.normalizeCall(call);
+    live = upsertLiveCall(live, call, ctx.list);
+    const surfaceIncoming =
+      normalized.initiatorId !== me.id &&
+      !active &&
+      (!policy.suppressDismissedIncoming || !dismissed.has(normalized.id));
+    if (surfaceIncoming) {
+      incoming = normalized;
+      effects.push({ kind: 'reportIncoming', call: normalized });
+    }
+    if (active && active.call.id === normalized.id) {
+      active = { ...active, call: normalized, participants: ctx.participantsFor(normalized) };
+    }
+    return done();
+  }
+
+  if (event.type === 'call.accepted' || event.type === 'call.participant_joined') {
+    if (policy.clearDismissedOnSelfAccept && event.user.id === me.id && dismissed.has(event.callId)) {
+      const next = new Set(dismissed);
+      next.delete(event.callId);
+      dismissed = next;
+    }
+    if (incoming && incoming.id === event.callId) {
+      if (event.user.id === me.id) {
+        incoming = null;
+      } else if (policy.keepIncomingOnOtherAccept) {
+        incoming = { ...incoming, status: 'active', participants: upsertUser(incoming.participants, event.user) };
+      } else {
+        incoming = null;
+      }
+    }
+    live = updateLiveCall(
+      live,
+      event.callId,
+      (call) => ({ ...call, status: 'active', participants: upsertUser(call.participants, event.user) }),
+      ctx.list,
+    );
+    if (active && active.call.id === event.callId) {
+      active = {
+        ...active,
+        call: { ...active.call, status: 'active' },
+        participants: upsertUser(active.participants, event.user),
+      };
+    }
+    return done();
+  }
+
+  if (event.type === 'call.declined') {
+    if (incoming && incoming.id === event.callId && event.userId === me.id) incoming = null;
+    if (event.userId === me.id) {
+      if (policy.declineByMe === 'dismiss') {
+        dismissed = new Set(dismissed).add(event.callId);
+      } else {
+        live = removeLiveCall(live, event.callId);
+        effects.push({ kind: 'reportEnded', callId: event.callId, reason: 'declinedElsewhere' });
+      }
+    }
+    return done();
+  }
+
+  if (event.type === 'call.participant_left') {
+    live = updateLiveCall(
+      live,
+      event.callId,
+      (call) => ({ ...call, participants: removeUser(call.participants, event.userId) }),
+      ctx.list,
+    );
+    if (active && active.call.id === event.callId) {
+      const participants = removeUser(active.participants, event.userId);
+      const remoteCount = participants.filter((p) => p.id !== me.id).length;
+      const endedByLastLeave = active.call.status === 'active' && remoteCount === 0;
+      active = {
+        ...active,
+        participants,
+        activeSpeakerIds: new Set([...active.activeSpeakerIds].filter((id) => id !== event.userId)),
+      };
+      effects.push({ kind: 'activeParticipantLeft', userId: event.userId });
+      if (policy.reportLastLeave && endedByLastLeave) {
+        effects.push({ kind: 'reportEnded', callId: event.callId, reason: 'remoteEnded' });
+      }
+    }
+    return done();
+  }
+
+  if (event.type === 'call.ended') {
+    if (dismissed.has(event.callId)) {
+      const next = new Set(dismissed);
+      next.delete(event.callId);
+      dismissed = next;
+    }
+    if (incoming && incoming.id === event.callId) incoming = null;
+    live = removeLiveCall(live, event.callId);
+    effects.push({ kind: 'reportEnded', callId: event.callId, reason: 'remoteEnded' });
+    if (active && active.call.id === event.callId) {
+      effects.push({ kind: 'clearActiveRoom', callId: event.callId });
+      active = null;
+    }
+    return done();
+  }
+
+  return done();
+}
diff --git a/surface/shared/src/index.ts b/surface/shared/src/index.ts
index 9f058fce3..db0fbba46 100644
--- a/surface/shared/src/index.ts
+++ b/surface/shared/src/index.ts
@@ -12,6 +12,7 @@ export * from './criticmarkup';
 export * from './api';
 export * from './activity';
 export * from './calls';
+export * from './call-core';
 export * from './sync';
 export * from './opQueue';
 export * from './chatQueuedOverlays';
diff --git a/surface/shared/test/callCore.test.ts b/surface/shared/test/callCore.test.ts
new file mode 100644
index 000000000..26bd113ca
--- /dev/null
+++ b/surface/shared/test/callCore.test.ts
@@ -0,0 +1,397 @@
+// Characterization tests for the shared call-core reducer + pure helpers.
+//
+// These pin BOTH platforms' behaviour through the policy/context parameters,
+// derived by reading the pre-consolidation inline `handleCallEvent` bodies in
+// web/src/useCall.ts and mobile/src/lib/useCall.ts. Where web and mobile
+// legitimately diverge (design §3), each platform's expectation is asserted
+// separately so the consolidation cannot silently flip either.
+
+import { describe, expect, it, vi } from 'vitest';
+import type { CallEvent, CallWire } from '../src/calls';
+import { CALL_RING_TTL_MS } from '../src/calls';
+import type { UserRef } from '../src/timeline';
+import type { Channel } from '../src/api';
+import {
+  type BaseActiveCallState,
+  type CallContext,
+  CALL_ORDER_ASC,
+  CALL_ORDER_DESC,
+  callEventReducer,
+  type CallReducerState,
+  enrichParticipants,
+  isExpiredRing,
+  MOBILE_CALL_POLICY,
+  ringAgeMs,
+  sortLiveCalls,
+  upsertUser,
+  WEB_CALL_POLICY,
+  withSelf,
+} from '../src/call-core';
+
+const me: UserRef = { id: 'me', handle: 'me', displayName: 'Me' };
+const ada: UserRef = { id: 'ada', handle: 'ada', displayName: 'Ada' };
+const bo: UserRef = { id: 'bo', handle: 'bo', displayName: 'Bo' };
+
+function call(overrides: Partial<CallWire> = {}): CallWire {
+  return {
+    id: 'call-1',
+    channelId: 'ch-1',
+    initiatorId: ada.id,
+    status: 'ringing',
+    // Fresh by default so a ring is never treated as expired under real timers;
+    // tests that need a specific age pass `startedAt` explicitly.
+    startedAt: new Date().toISOString(),
+    participants: [ada],
+    ...overrides,
+  };
+}
+
+// Active-state shapes matching each driver (extra fields the reducer preserves).
+interface WebActive extends BaseActiveCallState {
+  remoteAudioTracks: { key: string }[];
+}
+interface MobileActive extends BaseActiveCallState {
+  nativeCallId?: string;
+}
+
+function webCtx(channels: Channel[] = []): CallContext {
+  return {
+    me,
+    list: {
+      order: CALL_ORDER_ASC,
+      normalizeCall: (c) => ({ ...c, participants: enrichParticipants(c.participants, c, me, channels) }),
+    },
+    participantsFor: (c) => enrichParticipants(withSelf(c, me), c, me, channels),
+    policy: WEB_CALL_POLICY,
+  };
+}
+
+function mobileCtx(): CallContext {
+  return {
+    me,
+    list: { order: CALL_ORDER_DESC, normalizeCall: (c) => c },
+    participantsFor: (c) => withSelf(c, me),
+    policy: MOBILE_CALL_POLICY,
+  };
+}
+
+function emptyState<A extends BaseActiveCallState>(over: Partial<CallReducerState<A>> = {}): CallReducerState<A> {
+  return { active: null, incoming: null, live: [], dismissed: new Set(), ...over };
+}
+
+function webActive(c: CallWire, over: Partial<WebActive> = {}): WebActive {
+  return {
+    call: c,
+    phase: 'connected',
+    participants: withSelf(c, me),
+    activeSpeakerIds: new Set(),
+    muted: false,
+    error: null,
+    remoteAudioTracks: [],
+    ...over,
+  };
+}
+
+function mobileActive(c: CallWire, over: Partial<MobileActive> = {}): MobileActive {
+  return {
+    call: c,
+    phase: 'connected',
+    participants: withSelf(c, me),
+    activeSpeakerIds: new Set(),
+    muted: false,
+    error: null,
+    ...over,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Pure helpers
+// ---------------------------------------------------------------------------
+
+describe('upsertUser (merge-aware, adopted on both platforms — D7)', () => {
+  it('adds an unknown user', () => {
+    expect(upsertUser([ada], bo)).toEqual([ada, bo]);
+  });
+  it('does not let a fallback overwrite a resolved user', () => {
+    const fallback: UserRef = { id: 'ada', handle: 'ada', displayName: 'ada' };
+    const users = [ada];
+    const result = upsertUser(users, fallback);
+    expect(result).toBe(users); // unchanged reference — fallback rejected
+    expect(result[0]).toEqual(ada);
+  });
+  it('upgrades a fallback to a resolved user', () => {
+    const fallback: UserRef = { id: 'ada', handle: 'ada', displayName: 'ada' };
+    expect(upsertUser([fallback], ada)).toEqual([ada]);
+  });
+  it('returns the same reference when nothing changes', () => {
+    const users = [ada];
+    expect(upsertUser(users, ada)).toBe(users);
+  });
+});
+
+describe('sortLiveCalls order is a parameter (R4)', () => {
+  const a = call({ id: 'a', startedAt: '2026-07-21T12:00:00.000Z' });
+  const b = call({ id: 'b', startedAt: '2026-07-21T12:00:05.000Z' });
+  const c = call({ id: 'c', startedAt: '2026-07-21T12:00:10.000Z' });
+  it('web ASC = oldest first, id tiebreak', () => {
+    expect(sortLiveCalls([c, a, b], CALL_ORDER_ASC).map((x) => x.id)).toEqual(['a', 'b', 'c']);
+  });
+  it('mobile DESC = newest first', () => {
+    expect(sortLiveCalls([a, c, b], CALL_ORDER_DESC).map((x) => x.id)).toEqual(['c', 'b', 'a']);
+  });
+});
+
+describe('isExpiredRing at the shared TTL boundary', () => {
+  it('is false just under the TTL and true at/over it', () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2026-07-21T12:00:00.000Z'));
+    const fresh = call({ startedAt: new Date(Date.now() - CALL_RING_TTL_MS + 1).toISOString() });
+    const dead = call({ startedAt: new Date(Date.now() - CALL_RING_TTL_MS).toISOString() });
+    expect(isExpiredRing(fresh)).toBe(false);
+    expect(isExpiredRing(dead)).toBe(true);
+    expect(ringAgeMs(dead)).toBeGreaterThanOrEqual(CALL_RING_TTL_MS);
+    expect(isExpiredRing(call({ status: 'active', startedAt: dead.startedAt }))).toBe(false);
+    vi.useRealTimers();
+  });
+});
+
+describe('enrichParticipants dedupes and resolves via channel membership', () => {
+  it('resolves a fallback identity to the channel member and dedupes', () => {
+    const channels: Channel[] = [
+      {
+        id: 'ch-1',
+        workspaceId: 'ws',
+        name: 'general',
+        createdAt: '2026-07-21T12:00:00.000Z',
+        archivedAt: null,
+        pinned: false,
+        kind: 'dm',
+        members: [me, ada],
+      },
+    ];
+    const c = call({ participants: [ada] });
+    const fallbackAda: UserRef = { id: 'ada', handle: 'ada', displayName: 'ada' };
+    const result = enrichParticipants([fallbackAda, fallbackAda], c, me, channels);
+    expect(result).toEqual([ada]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Reducer — the six lifecycles (design §5). Each divergent branch asserts web
+// and mobile separately.
+// ---------------------------------------------------------------------------
+
+describe('call.ringing (b/f: incoming ring, overlapping ring)', () => {
+  it('surfaces an incoming ring from someone else and emits reportIncoming (both)', () => {
+    const ringing = call();
+    for (const ctx of [webCtx(), mobileCtx()]) {
+      const r = callEventReducer(emptyState(), { type: 'call.ringing', call: ringing }, ctx);
+      expect(r.state.incoming?.id).toBe('call-1');
+      expect(r.state.live.map((c) => c.id)).toEqual(['call-1']);
+      expect(r.effects).toContainEqual({ kind: 'reportIncoming', call: r.state.incoming });
+    }
+  });
+
+  it('does not surface a self-initiated ring (both) but still tracks it live', () => {
+    const own = call({ initiatorId: me.id, participants: [me] });
+    for (const ctx of [webCtx(), mobileCtx()]) {
+      const r = callEventReducer(emptyState(), { type: 'call.ringing', call: own }, ctx);
+      expect(r.state.incoming).toBeNull();
+      expect(r.state.live.map((c) => c.id)).toEqual(['call-1']);
+      expect(r.effects).toEqual([]);
+    }
+  });
+
+  it('f: a ring arriving while a call is active is not surfaced (both)', () => {
+    const active = mobileActive(call({ id: 'active-call', status: 'active' }));
+    const second = call({ id: 'call-2' });
+    const rM = callEventReducer(
+      emptyState<MobileActive>({ active }),
+      { type: 'call.ringing', call: second },
+      mobileCtx(),
+    );
+    expect(rM.state.incoming).toBeNull();
+
+    const wActive = webActive(call({ id: 'active-call', status: 'active' }));
+    const rW = callEventReducer(
+      emptyState<WebActive>({ active: wActive }),
+      { type: 'call.ringing', call: second },
+      webCtx(),
+    );
+    expect(rW.state.incoming).toBeNull();
+  });
+
+  it('web: an already-dismissed ring is tracked live but not surfaced (suppressDismissedIncoming)', () => {
+    const ringing = call();
+    const r = callEventReducer(
+      emptyState({ dismissed: new Set(['call-1']) }),
+      { type: 'call.ringing', call: ringing },
+      webCtx(),
+    );
+    expect(r.state.incoming).toBeNull();
+    expect(r.state.live.map((c) => c.id)).toEqual(['call-1']);
+    expect(r.effects).toEqual([]);
+  });
+
+  it('mobile: an already-dismissed ring is dropped from live and reported unanswered (guardStaleRing)', () => {
+    const ringing = call();
+    const r = callEventReducer(
+      emptyState({ dismissed: new Set(['call-1']), live: [ringing] }),
+      { type: 'call.ringing', call: ringing },
+      mobileCtx(),
+    );
+    expect(r.state.incoming).toBeNull();
+    expect(r.state.live).toEqual([]);
+    expect(r.effects).toEqual([{ kind: 'reportEnded', callId: 'call-1', reason: 'unanswered' }]);
+  });
+
+  it('mobile: an expired ring is dropped and reported unanswered', () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2026-07-21T12:10:00.000Z'));
+    const stale = call({ startedAt: '2026-07-21T12:00:00.000Z' });
+    const r = callEventReducer(emptyState({ live: [stale] }), { type: 'call.ringing', call: stale }, mobileCtx());
+    expect(r.state.live).toEqual([]);
+    expect(r.effects).toEqual([{ kind: 'reportEnded', callId: 'call-1', reason: 'unanswered' }]);
+    vi.useRealTimers();
+  });
+});
+
+describe('call.accepted / participant_joined (a/b: happy path, answer)', () => {
+  const accepted: CallEvent = { type: 'call.accepted', callId: 'call-1', user: bo };
+
+  it('marks the live + active call active and adds the joiner (both)', () => {
+    for (const [ctx, mk] of [[webCtx(), webActive] as const, [mobileCtx(), mobileActive] as const]) {
+      const active = mk(call({ status: 'ringing', participants: [me] }));
+      const r = callEventReducer(emptyState({ active, live: [call({ status: 'ringing' })] }), accepted, ctx);
+      expect(r.state.active?.call.status).toBe('active');
+      expect(r.state.active?.participants.map((p) => p.id)).toContain('bo');
+      expect(r.state.live[0]?.status).toBe('active');
+    }
+  });
+
+  it('web: clears the incoming banner when ANYONE accepts a matching call', () => {
+    const r = callEventReducer(emptyState({ incoming: call() }), accepted, webCtx());
+    expect(r.state.incoming).toBeNull();
+  });
+
+  it('mobile: keeps (updates) the incoming banner when someone ELSE accepts', () => {
+    const r = callEventReducer(emptyState({ incoming: call() }), accepted, mobileCtx());
+    expect(r.state.incoming?.status).toBe('active');
+    expect(r.state.incoming?.participants.map((p) => p.id)).toContain('bo');
+  });
+
+  it('both: clear the incoming banner when I accept', () => {
+    const selfAccept: CallEvent = { type: 'call.accepted', callId: 'call-1', user: me };
+    for (const ctx of [webCtx(), mobileCtx()]) {
+      const r = callEventReducer(emptyState({ incoming: call() }), selfAccept, ctx);
+      expect(r.state.incoming).toBeNull();
+    }
+  });
+
+  it('web: a self-accept clears the call from the dismissed set (clearDismissedOnSelfAccept)', () => {
+    const selfAccept: CallEvent = { type: 'call.accepted', callId: 'call-1', user: me };
+    const rW = callEventReducer(emptyState({ dismissed: new Set(['call-1']) }), selfAccept, webCtx());
+    expect(rW.state.dismissed.has('call-1')).toBe(false);
+    const rM = callEventReducer(emptyState({ dismissed: new Set(['call-1']) }), selfAccept, mobileCtx());
+    expect(rM.state.dismissed.has('call-1')).toBe(true);
+  });
+});
+
+describe('call.declined (c: decline)', () => {
+  const declineMe: CallEvent = { type: 'call.declined', callId: 'call-1', userId: me.id };
+
+  it('web: clears incoming and adds to the dismissed set', () => {
+    const r = callEventReducer(emptyState({ incoming: call(), live: [call()] }), declineMe, webCtx());
+    expect(r.state.incoming).toBeNull();
+    expect(r.state.dismissed.has('call-1')).toBe(true);
+    expect(r.state.live.map((c) => c.id)).toEqual(['call-1']); // web declined does NOT touch live
+    expect(r.effects).toEqual([]);
+  });
+
+  it('mobile: clears incoming, drops from live, reports declinedElsewhere', () => {
+    const r = callEventReducer(emptyState({ incoming: call(), live: [call()] }), declineMe, mobileCtx());
+    expect(r.state.incoming).toBeNull();
+    expect(r.state.dismissed.has('call-1')).toBe(false);
+    expect(r.state.live).toEqual([]);
+    expect(r.effects).toEqual([{ kind: 'reportEnded', callId: 'call-1', reason: 'declinedElsewhere' }]);
+  });
+
+  it('both: a decline by someone else does not clear my incoming banner', () => {
+    const declineOther: CallEvent = { type: 'call.declined', callId: 'call-1', userId: 'someone' };
+    for (const ctx of [webCtx(), mobileCtx()]) {
+      const r = callEventReducer(emptyState({ incoming: call() }), declineOther, ctx);
+      expect(r.state.incoming?.id).toBe('call-1');
+    }
+  });
+});
+
+describe('call.participant_left (d/e: leave, last-leave)', () => {
+  const left: CallEvent = { type: 'call.participant_left', callId: 'call-1', userId: bo.id };
+
+  it('removes the participant + speaker and emits activeParticipantLeft (both)', () => {
+    const wActive = webActive(call({ status: 'active', participants: [me, bo] }), {
+      participants: [me, bo],
+      activeSpeakerIds: new Set(['bo']),
+    });
+    const rW = callEventReducer(emptyState<WebActive>({ active: wActive }), left, webCtx());
+    expect(rW.state.active?.participants.map((p) => p.id)).toEqual(['me']);
+    expect([...(rW.state.active?.activeSpeakerIds ?? [])]).toEqual([]);
+    expect(rW.effects).toContainEqual({ kind: 'activeParticipantLeft', userId: 'bo' });
+    // web NEVER reports the last leave
+    expect(rW.effects.some((e) => e.kind === 'reportEnded')).toBe(false);
+  });
+
+  it('mobile: reports remoteEnded when the last remote participant leaves (reportLastLeave)', () => {
+    const mActive = mobileActive(call({ status: 'active', participants: [me, bo] }), { participants: [me, bo] });
+    const rM = callEventReducer(emptyState<MobileActive>({ active: mActive }), left, mobileCtx());
+    expect(rM.state.active?.participants.map((p) => p.id)).toEqual(['me']);
+    expect(rM.effects).toContainEqual({ kind: 'reportEnded', callId: 'call-1', reason: 'remoteEnded' });
+  });
+
+  it('mobile: does NOT report remoteEnded while other remotes remain', () => {
+    const mActive = mobileActive(call({ status: 'active', participants: [me, ada, bo] }), {
+      participants: [me, ada, bo],
+    });
+    const rM = callEventReducer(emptyState<MobileActive>({ active: mActive }), left, mobileCtx());
+    expect(rM.effects.some((e) => e.kind === 'reportEnded')).toBe(false);
+  });
+});
+
+describe('call.ended (d: drop/hangup terminal)', () => {
+  const ended: CallEvent = { type: 'call.ended', callId: 'call-1' };
+
+  it('clears incoming/live/dismissed and tears down the active room (both)', () => {
+    for (const [ctx, mk] of [[webCtx(), webActive] as const, [mobileCtx(), mobileActive] as const]) {
+      const active = mk(call({ status: 'active' }));
+      const r = callEventReducer(
+        emptyState({ active, incoming: call(), live: [call()], dismissed: new Set(['call-1']) }),
+        ended,
+        ctx,
+      );
+      expect(r.state.active).toBeNull();
+      expect(r.state.incoming).toBeNull();
+      expect(r.state.live).toEqual([]);
+      expect(r.state.dismissed.has('call-1')).toBe(false);
+      expect(r.effects).toContainEqual({ kind: 'clearActiveRoom', callId: 'call-1' });
+      expect(r.effects).toContainEqual({ kind: 'reportEnded', callId: 'call-1', reason: 'remoteEnded' });
+    }
+  });
+
+  it('reportEnded is emitted before clearActiveRoom (ordering the mobile driver relies on)', () => {
+    const r = callEventReducer(
+      emptyState<MobileActive>({ active: mobileActive(call({ status: 'active' })) }),
+      ended,
+      mobileCtx(),
+    );
+    const reportIdx = r.effects.findIndex((e) => e.kind === 'reportEnded');
+    const clearIdx = r.effects.findIndex((e) => e.kind === 'clearActiveRoom');
+    expect(reportIdx).toBeGreaterThanOrEqual(0);
+    expect(reportIdx).toBeLessThan(clearIdx);
+  });
+
+  it('ending a non-active call does not emit clearActiveRoom', () => {
+    const r = callEventReducer(emptyState({ live: [call()] }), ended, webCtx());
+    expect(r.effects.some((e) => e.kind === 'clearActiveRoom')).toBe(false);
+    expect(r.state.live).toEqual([]);
+  });
+});
diff --git a/surface/web/src/Chat.tsx b/surface/web/src/Chat.tsx
index 826ff6e58..d99f4ea25 100644
--- a/surface/web/src/Chat.tsx
+++ b/surface/web/src/Chat.tsx
@@ -32,7 +32,7 @@ import {
 import { useWs } from '@atrium/surface-client';
 import { Avatar } from './components/Avatar';
 import { ActivityView } from './components/ActivityView';
-import { labelForCallChannel, userForCall } from './callPresentation';
+import { labelForCallChannel, userForCall } from '@atrium/surface-client';
 import { notificationForWireEvent } from './chatNotifications';
 import { ChannelMembersMenu } from './components/ChannelMembersMenu';
 import { CallNotice, ChannelCallStrip, InCallPanel, IncomingCallBanner } from './components/CallUI';
diff --git a/surface/web/src/callPresentation.ts b/surface/web/src/callPresentation.ts
deleted file mode 100644
index 83ff13644..000000000
--- a/surface/web/src/callPresentation.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import type { CallWire, UserRef } from '@atrium/surface-client';
-import { channelLabel } from '@atrium/surface-client';
-import type { Channel } from './api';
-
-function fallbackUser(id: string): UserRef {
-  return { id, handle: id, displayName: id };
-}
-
-export function userForCall(call: CallWire, channels: Channel[], userId: string): UserRef {
-  return (
-    call.participants.find((u) => u.id === userId) ??
-    channels.find((c) => c.id === call.channelId)?.members?.find((u) => u.id === userId) ??
-    fallbackUser(userId)
-  );
-}
-
-export function labelForCallChannel(call: CallWire, channels: Channel[], meId: string): string {
-  const channel = channels.find((c) => c.id === call.channelId);
-  if (!channel) return 'Unknown channel';
-  return channel.kind === 'private' ? `#${channel.name}` : channelLabel(channel, meId);
-}
diff --git a/surface/web/src/useCall.ts b/surface/web/src/useCall.ts
index 74bb63267..0cf60c0b5 100644
--- a/surface/web/src/useCall.ts
+++ b/surface/web/src/useCall.ts
@@ -8,7 +8,29 @@ import {
   type RemoteTrack,
   type RemoteTrackPublication,
 } from 'livekit-client';
-import type { CallEvent, CallJoin, CallWire, UserRef } from '@atrium/surface-client';
+import {
+  AUDIO_CAPTURE_OPTIONS,
+  type BaseActiveCallState,
+  CALL_ORDER_ASC,
+  CALL_RING_TTL_MS,
+  type CallContext,
+  type CallEvent,
+  callEventReducer,
+  type CallJoin,
+  type CallListContext,
+  type CallWire,
+  enrichParticipants,
+  isLiveCall,
+  normalizeLiveCalls,
+  removeUser,
+  updateLiveCall,
+  upsertLiveCall,
+  upsertUser,
+  type UserRef,
+  userFromIdentity,
+  WEB_CALL_POLICY,
+  withSelf,
+} from '@atrium/surface-client';
 import { ApiError, api, type Channel } from './api';
 import { desktopApiOptions } from './desktop';
 
@@ -17,153 +39,16 @@ export interface RemoteAudioTrackRef {
   track: RemoteTrack;
 }
 
-export interface ActiveCallState {
-  call: CallWire;
-  phase: 'connecting' | 'connected' | 'ended';
-  participants: UserRef[];
+// Web adds its autoplay-attachment slice (`remoteAudioTracks`) to the shared
+// six-field base; the shared reducer preserves it untouched.
+export interface ActiveCallState extends BaseActiveCallState {
   remoteAudioTracks: RemoteAudioTrackRef[];
-  activeSpeakerIds: Set<string>;
-  muted: boolean;
-  error: string | null;
 }
 
-const AUDIO_CAPTURE_OPTIONS = {
-  echoCancellation: true,
-  noiseSuppression: true,
-  autoGainControl: true,
-};
-const RING_TIMEOUT_MS = 45_000;
-
 function callLeavePath(callId: string): string {
   return `/api/calls/${encodeURIComponent(callId)}/leave`;
 }
 
-function fallbackUser(identity: string): UserRef {
-  return { id: identity, handle: identity, displayName: identity };
-}
-
-function isFallbackUser(user: UserRef): boolean {
-  return user.handle === user.id && user.displayName === user.id;
-}
-
-function mergeUser(existing: UserRef, next: UserRef): UserRef {
-  if (isFallbackUser(next) && !isFallbackUser(existing)) return existing;
-  if (existing.handle === next.handle && existing.displayName === next.displayName && existing.id === next.id) {
-    return existing;
-  }
-  return next;
-}
-
-function upsertUser(users: UserRef[], user: UserRef): UserRef[] {
-  const index = users.findIndex((u) => u.id === user.id);
-  if (index === -1) return [...users, user];
-  const existing = users[index];
-  if (!existing) return users;
-  const next = mergeUser(existing, user);
-  if (next === existing) return users;
-  return users.map((u, i) => (i === index ? next : u));
-}
-
-function dedupeUsers(users: UserRef[]): UserRef[] {
-  return users.reduce<UserRef[]>((acc, user) => upsertUser(acc, user), []);
-}
-
-function userFromIdentity(
-  identity: string,
-  call: CallWire,
-  me: UserRef,
-  channels: Channel[],
-  knownUsers: UserRef[] = [],
-): UserRef {
-  if (identity === me.id) return me;
-  const channelMember = channels
-    .find((channel) => channel.id === call.channelId)
-    ?.members?.find((u) => u.id === identity);
-  const callParticipant = call.participants.find((u) => u.id === identity);
-  const knownUser = knownUsers.find((u) => u.id === identity);
-  const candidates = [channelMember, callParticipant, knownUser].filter((user): user is UserRef => user != null);
-  return candidates.find((user) => !isFallbackUser(user)) ?? candidates[0] ?? fallbackUser(identity);
-}
-
-function enrichParticipants(users: UserRef[], call: CallWire, me: UserRef, channels: Channel[]): UserRef[] {
-  return dedupeUsers(users.map((user) => userFromIdentity(user.id, call, me, channels, users)));
-}
-
-function participantsFor(call: CallWire, me: UserRef, channels: Channel[]): UserRef[] {
-  const participants = call.participants.some((u) => u.id === me.id) ? call.participants : [me, ...call.participants];
-  return enrichParticipants(participants, call, me, channels);
-}
-
-function upsertIdentityParticipant(
-  current: ActiveCallState,
-  identity: string,
-  me: UserRef,
-  channels: Channel[],
-): UserRef[] {
-  return upsertUser(current.participants, userFromIdentity(identity, current.call, me, channels, current.participants));
-}
-
-function upsertIdentityParticipants(
-  current: ActiveCallState,
-  identities: string[],
-  me: UserRef,
-  channels: Channel[],
-): UserRef[] {
-  return identities.reduce(
-    (participants, identity) =>
-      upsertUser(participants, userFromIdentity(identity, current.call, me, channels, participants)),
-    current.participants,
-  );
-}
-
-function removeUser(users: UserRef[], userId: string): UserRef[] {
-  return users.filter((u) => u.id !== userId);
-}
-
-function isLiveCall(call: CallWire): boolean {
-  return call.status !== 'ended';
-}
-
-function sortLiveCalls(calls: CallWire[]): CallWire[] {
-  return [...calls].sort((a, b) => a.startedAt.localeCompare(b.startedAt) || a.id.localeCompare(b.id));
-}
-
-function normalizeCall(call: CallWire, me: UserRef, channels: Channel[]): CallWire {
-  return {
-    ...call,
-    participants: enrichParticipants(call.participants, call, me, channels),
-  };
-}
-
-function normalizeLiveCalls(calls: CallWire[], me: UserRef, channels: Channel[]): CallWire[] {
-  return sortLiveCalls(calls.filter(isLiveCall).map((call) => normalizeCall(call, me, channels)));
-}
-
-function upsertLiveCall(calls: CallWire[], call: CallWire, me: UserRef, channels: Channel[]): CallWire[] {
-  if (!isLiveCall(call)) return calls.filter((current) => current.id !== call.id);
-  const next = normalizeCall(call, me, channels);
-  const index = calls.findIndex((current) => current.id === next.id);
-  if (index === -1) return sortLiveCalls([...calls, next]);
-  return sortLiveCalls(calls.map((current, i) => (i === index ? next : current)));
-}
-
-function updateLiveCall(
-  calls: CallWire[],
-  callId: string,
-  update: (call: CallWire) => CallWire,
-  me: UserRef,
-  channels: Channel[],
-): CallWire[] {
-  let found = false;
-  const next = calls.flatMap((call) => {
-    if (call.id !== callId) return [call];
-    found = true;
-    const updated = update(call);
-    return isLiveCall(updated) ? [normalizeCall(updated, me, channels)] : [];
-  });
-  return found ? sortLiveCalls(next) : calls;
-}
-
 function callUnavailable(err: unknown): boolean {
   return err instanceof ApiError && err.status === 503 && err.code === 'calls_unconfigured';
 }
@@ -173,9 +58,26 @@ export function useCall(me: UserRef, channels: Channel[]) {
 
   channelsRef.current = channels;
 
-  function currentChannels(): Channel[] {
-    return channelsRef.current;
-  }
+  // Live channels + `me` drive the enrichment the web UI wants. Built fresh per
+  // call so the reducer/helpers always see the current channel roster.
+  const listContext = useCallback(
+    (): CallListContext => ({
+      order: CALL_ORDER_ASC,
+      normalizeCall: (call) => ({
+        ...call,
+        participants: enrichParticipants(call.participants, call, me, channelsRef.current),
+      }),
+    }),
+    [me],
+  );
+  const participantsForCall = useCallback(
+    (call: CallWire): UserRef[] => enrichParticipants(withSelf(call, me), call, me, channelsRef.current),
+    [me],
+  );
+  const buildContext = useCallback(
+    (): CallContext => ({ me, list: listContext(), participantsFor: participantsForCall, policy: WEB_CALL_POLICY }),
+    [listContext, me, participantsForCall],
+  );
 
   const [incomingCall, setIncomingCall] = useState<CallWire | null>(null);
   const [liveCalls, setLiveCalls] = useState<CallWire[]>([]);
@@ -186,12 +88,16 @@ export function useCall(me: UserRef, channels: Channel[]) {
   const [answering, setAnswering] = useState(false);
   const roomRef = useRef<Room | null>(null);
   const activeCallRef = useRef<ActiveCallState | null>(null);
+  const incomingCallRef = useRef<CallWire | null>(null);
+  const liveCallsRef = useRef<CallWire[]>([]);
   const dismissedCallIdsRef = useRef(dismissedCallIds);
   const connectPromiseRef = useRef<Promise<void> | null>(null);
   const detachRoomHandlersRef = useRef<(() => void) | null>(null);
   const intentionalDisconnectRef = useRef(false);
 
   activeCallRef.current = activeCall;
+  incomingCallRef.current = incomingCall;
+  liveCallsRef.current = liveCalls;
   dismissedCallIdsRef.current = dismissedCallIds;
 
   useEffect(() => {
@@ -203,9 +109,9 @@ export function useCall(me: UserRef, channels: Channel[]) {
           }
         : current,
     );
-    setIncomingCall((current) => (current ? normalizeCall(current, me, channels) : current));
-    setLiveCalls((current) => normalizeLiveCalls(current, me, channels));
-  }, [channels, me]);
+    setIncomingCall((current) => (current ? listContext().normalizeCall(current) : current));
+    setLiveCalls((current) => normalizeLiveCalls(current, listContext()));
+  }, [channels, me, listContext]);
 
   const updateActiveCall = useCallback((fn: (current: ActiveCallState) => ActiveCallState) => {
     setActiveCall((current) => (current ? fn(current) : current));
@@ -258,7 +164,10 @@ export function useCall(me: UserRef, channels: Channel[]) {
       const onParticipantConnected = (participant: RemoteParticipant) => {
         updateActiveCall((current) => ({
           ...current,
-          participants: upsertIdentityParticipant(current, participant.identity, me, currentChannels()),
+          participants: upsertUser(
+            current.participants,
+            userFromIdentity(participant.identity, current.call, me, channelsRef.current, current.participants),
+          ),
         }));
       };
       const onParticipantDisconnected = (participant: RemoteParticipant) => {
@@ -283,7 +192,11 @@ export function useCall(me: UserRef, channels: Channel[]) {
         const speakerIds = speakers.map((speaker) => speaker.identity);
         updateActiveCall((current) => ({
           ...current,
-          participants: upsertIdentityParticipants(current, speakerIds, me, currentChannels()),
+          participants: speakerIds.reduce(
+            (participants, id) =>
+              upsertUser(participants, userFromIdentity(id, current.call, me, channelsRef.current, participants)),
+            current.participants,
+          ),
           activeSpeakerIds: new Set(speakerIds),
         }));
       };
@@ -335,7 +248,7 @@ export function useCall(me: UserRef, channels: Channel[]) {
         next.delete(join.call.id);
         return next;
       });
-      setLiveCalls((calls) => upsertLiveCall(calls, join.call, me, currentChannels()));
+      setLiveCalls((calls) => upsertLiveCall(calls, join.call, listContext()));
       const room = new Room();
       roomRef.current = room;
       setRoomHandlers(room);
@@ -344,7 +257,7 @@ export function useCall(me: UserRef, channels: Channel[]) {
       setActiveCall({
         call: join.call,
         phase: 'connecting',
-        participants: participantsFor(join.call, me, currentChannels()),
+        participants: participantsForCall(join.call),
         remoteAudioTracks: [],
         activeSpeakerIds: new Set(),
         muted: false,
@@ -358,7 +271,10 @@ export function useCall(me: UserRef, channels: Channel[]) {
           for (const participant of room.remoteParticipants.values()) {
             updateActiveCall((active) => ({
               ...active,
-              participants: upsertIdentityParticipant(active, participant.identity, me, currentChannels()),
+              participants: upsertUser(
+                active.participants,
+                userFromIdentity(participant.identity, active.call, me, channelsRef.current, active.participants),
+              ),
             }));
             for (const publication of participant.trackPublications.values()) {
               const track = publication.track;
@@ -387,13 +303,13 @@ export function useCall(me: UserRef, channels: Channel[]) {
       });
       return connectPromiseRef.current;
     },
-    [addRemoteAudioTrack, clearRoom, me, setRoomHandlers, updateActiveCall],
+    [addRemoteAudioTrack, clearRoom, listContext, me, participantsForCall, setRoomHandlers, updateActiveCall],
   );
 
   const refreshActiveCalls = useCallback(async () => {
     try {
       const snapshot = await api.activeCalls();
-      const refreshed = normalizeLiveCalls(snapshot.calls, me, currentChannels());
+      const refreshed = normalizeLiveCalls(snapshot.calls, listContext());
       const refreshedIds = new Set(refreshed.map((call) => call.id));
 
       setLiveCalls(refreshed);
@@ -428,7 +344,7 @@ export function useCall(me: UserRef, channels: Channel[]) {
           ? {
               ...active,
               call: next,
-              participants: participantsFor(next, me, currentChannels()),
+              participants: participantsForCall(next),
             }
           : active,
       );
@@ -439,7 +355,7 @@ export function useCall(me: UserRef, channels: Channel[]) {
         setNotice("Couldn't refresh active calls.");
       }
     }
-  }, [clearRoom, me]);
+  }, [clearRoom, listContext, me, participantsForCall]);
 
   const liveCallForChannel = useCallback(
     (channelId: string): CallWire | null =>
@@ -450,109 +366,45 @@ export function useCall(me: UserRef, channels: Channel[]) {
 
   const handleCallEvent = useCallback(
     (event: CallEvent) => {
-      if (event.type === 'call.ringing') {
-        const nextCall = normalizeCall(event.call, me, currentChannels());
-        setLiveCalls((calls) => upsertLiveCall(calls, nextCall, me, currentChannels()));
-        if (nextCall.initiatorId !== me.id && !activeCallRef.current && !dismissedCallIdsRef.current.has(nextCall.id)) {
-          setIncomingCall(nextCall);
-        }
-        setActiveCall((current) =>
-          current?.call.id === nextCall.id
-            ? {
-                ...current,
-                call: nextCall,
-                participants: participantsFor(nextCall, me, currentChannels()),
-              }
-            : current,
-        );
-        return;
-      }
-
-      if (event.type === 'call.accepted' || event.type === 'call.participant_joined') {
-        if (event.user.id === me.id) {
-          setDismissedCallIds((ids) => {
-            if (!ids.has(event.callId)) return ids;
-            const next = new Set(ids);
-            next.delete(event.callId);
-            return next;
-          });
-        }
-        setIncomingCall((call) => (call?.id === event.callId ? null : call));
-        setLiveCalls((calls) =>
-          updateLiveCall(
-            calls,
-            event.callId,
-            (call) => ({
-              ...call,
-              status: 'active',
-              participants: upsertUser(call.participants, event.user),
-            }),
-            me,
-            currentChannels(),
-          ),
-        );
-        setActiveCall((current) =>
-          current?.call.id === event.callId
-            ? {
-                ...current,
-                call: { ...current.call, status: 'active' },
-                participants: upsertUser(current.participants, event.user),
-              }
-            : current,
-        );
-        return;
-      }
-
-      if (event.type === 'call.declined') {
-        setIncomingCall((call) => (call?.id === event.callId && event.userId === me.id ? null : call));
-        if (event.userId === me.id) {
-          setDismissedCallIds((ids) => new Set(ids).add(event.callId));
+      const prev = {
+        active: activeCallRef.current,
+        incoming: incomingCallRef.current,
+        live: liveCallsRef.current,
+        dismissed: dismissedCallIdsRef.current,
+      };
+      const { state: next, effects } = callEventReducer<ActiveCallState>(prev, event, buildContext());
+
+      // Fold web's remoteAudioTracks pruning into the single active update.
+      let nextActive = next.active;
+      for (const effect of effects) {
+        if (effect.kind === 'activeParticipantLeft' && nextActive) {
+          nextActive = {
+            ...nextActive,
+            remoteAudioTracks: nextActive.remoteAudioTracks.filter((t) => !t.key.startsWith(`${effect.userId}:`)),
+          };
         }
-        return;
       }
 
-      if (event.type === 'call.participant_left') {
-        setLiveCalls((calls) =>
-          updateLiveCall(
-            calls,
-            event.callId,
-            (call) => ({
-              ...call,
-              participants: removeUser(call.participants, event.userId),
-            }),
-            me,
-            currentChannels(),
-          ),
-        );
-        setActiveCall((current) =>
-          current?.call.id === event.callId
-            ? {
-                ...current,
-                participants: removeUser(current.participants, event.userId),
-                activeSpeakerIds: new Set([...current.activeSpeakerIds].filter((id) => id !== event.userId)),
-                remoteAudioTracks: current.remoteAudioTracks.filter((t) => !t.key.startsWith(`${event.userId}:`)),
-              }
-            : current,
-        );
-        return;
-      }
-
-      if (event.type === 'call.ended') {
-        setIncomingCall((call) => (call?.id === event.callId ? null : call));
-        setLiveCalls((calls) => calls.filter((call) => call.id !== event.callId));
-        setDismissedCallIds((ids) => {
-          if (!ids.has(event.callId)) return ids;
-          const next = new Set(ids);
-          next.delete(event.callId);
-          return next;
-        });
-        if (activeCallRef.current?.call.id === event.callId) {
-          clearRoom();
-          setActiveCall(null);
-        }
+      // Advance the refs before React renders: a second CallEvent can arrive
+      // before the re-render syncs them, and reading stale refs would drop
+      // this transition (the old functional-updater form was immune to that).
+      activeCallRef.current = nextActive;
+      incomingCallRef.current = next.incoming;
+      liveCallsRef.current = next.live;
+      dismissedCallIdsRef.current = next.dismissed;
+
+      if (nextActive !== prev.active) setActiveCall(nextActive);
+      if (next.incoming !== prev.incoming) setIncomingCall(next.incoming);
+      if (next.live !== prev.live) setLiveCalls(next.live);
+      if (next.dismissed !== prev.dismissed) setDismissedCallIds(next.dismissed);
+
+      for (const effect of effects) {
+        // Web only cares about room teardown; reportIncoming/reportEnded are
+        // CallKit intents the mobile driver acts on.
+        if (effect.kind === 'clearActiveRoom') clearRoom();
       }
     },
-    [clearRoom, me],
+    [buildContext, clearRoom],
   );
 
   const startCall = useCallback(
@@ -656,8 +508,7 @@ export function useCall(me: UserRef, channels: Channel[]) {
         calls,
         callId,
         (call) => ({ ...call, participants: removeUser(call.participants, me.id) }),
-        me,
-        currentChannels(),
+        listContext(),
       ),
     );
     try {
@@ -665,7 +516,7 @@ export function useCall(me: UserRef, channels: Channel[]) {
     } catch {
       setNotice("Couldn't leave the call cleanly.");
     }
-  }, [clearRoom, me]);
+  }, [clearRoom, listContext, me]);
 
   const activeCallId = activeCall?.call.id ?? null;
   const activeCallStatus = activeCall?.call.status ?? null;
@@ -707,6 +558,8 @@ export function useCall(me: UserRef, channels: Channel[]) {
   useEffect(() => {
     if (!activeCallId || activeCallStatus !== 'ringing' || activeRemoteCount !== 0) return;
 
+    // Unified on the shared server-agreed TTL (60s). Web previously used a 45s
+    // local constant that disagreed with the sweeper — see design D4/R5.
     const timeout = window.setTimeout(() => {
       const current = activeCallRef.current;
       const remoteCount = current ? current.participants.filter((participant) => participant.id !== me.id).length : 0;
@@ -715,7 +568,7 @@ export function useCall(me: UserRef, channels: Channel[]) {
       }
       setNotice('No answer.');
       void leaveActiveCall();
-    }, RING_TIMEOUT_MS);
+    }, CALL_RING_TTL_MS);
 
     return () => window.clearTimeout(timeout);
   }, [activeCallId, activeCallStatus, activeRemoteCount, leaveActiveCall, me.id]);
diff --git a/surface/web/test/callPresentation.test.ts b/surface/web/test/callPresentation.test.ts
index 731365570..4e4b922e8 100644
--- a/surface/web/test/callPresentation.test.ts
+++ b/surface/web/test/callPresentation.test.ts
@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import type { CallWire, UserRef } from '@atrium/surface-client';
+import { labelForCallChannel, userForCall } from '@atrium/surface-client';
 import type { Channel } from '../src/api';
-import { labelForCallChannel, userForCall } from '../src/callPresentation';
 
 const me: UserRef = { id: 'u-me', handle: 'me', displayName: 'Me User' };
 const ada: UserRef = { id: 'u-ada', handle: 'ada', displayName: 'Ada Lovelace' };