You are package **v1 — the server role, the apply thread, and the EGL context migration** of phase P5 on the MobileGL disaggregation project. This is the phase's highest-risk package: you and package c1 (running in parallel) jointly own the milestone, "the first IPC frame on the reduced path". **Read first, in this order:** `~/w7/notes/p5/PACKAGE-PREAMBLE.md` (worktree setup, the two day-one traps, build recipe, the four self-tests every package owes, the iron rules), then `MobileGL/MG_Remote/CONTRACT-P5.md` in the tree (**authoritative — it outranks the brief**), then `~/w7/notes/p5/BRIEF-P5.md` §2 (R-1, R-9, R-11, R-12), §4, §5 "v1", **§13 (R-16 — read this one twice)**, then `~/w7/notes/p5/scout-backend-install-and-thread.md` — your subject's 601-line survey, every line number opened. Then skim `~/w7/notes/p5/INTEGRATOR-DECISIONS.md` for the rulings that bind you, and the wave-1 package reports under `~/w7/notes/p5/p5-results/` (w1, s1, p1, b1 landed the machinery you are about to drive). Base: `feat/disaggregated @ 32563993` — wave 1 (c0, w1, s1, p1, b1, t1) is **merged**. Slug `v1`; worktree `~/w7/p5-v1`, branch `p5/v1`. The full five-part gate is running on that commit right now; if it turns up breakage I will tell you. # What you own `MG_Remote/Server/*`, `MG_Backend/Init.cpp`, and the server-side edits in `MG_Backend/DirectGLES/Managers.cpp` (b1's file — coordinate through me for anything beyond the R-11 copy below). # What you build 1. **`ServerLoop` + the `mgl-srv-apply` thread.** No `mgl-srv-io` in P5 — inproc's control plane is in the same process; P6 splits it. Park through `Doorbell::Wait(control.consumerParked, …, kWaitForever)` and treat `Wait == false && Dead()` as shutdown. **`CondVarDoorbell::Kill()` is the only thing that can un-park a `kWaitForever` waiter**: a parked thread never killed hangs `Shutdown`; one killed but not joined returns into memory the client has freed. Bind the thread with `MOBILEGL_IPC_SERVER_AFFINITY` (default auto, reuse `ShaderCompilePool`'s big-core probe) and **log the resolved mask**. 2. **The EGL context migration — the part that can sink the phase.** The server role privately holds a `BackendObject_DirectGLES`; the apply thread runs `eglMakeCurrent` **once** and holds the context for life, so `g_backendContextOwnerThread` is written once, `DirectGLES.cpp:11933-11953`'s six cache invalidations become a one-off, and the **16** `IsBackendContextCurrentOnThisThread()` sites in `DirectGLES.cpp` plus the 16 `CanTouchGLNow()` sites in `Managers.cpp` answer *true on the server* instead of silently degrading. The client's EGL lifecycle calls (`InitializeEGLDisplay`, `CreateEGLWindowSurface`, `MakeEGLCurrent`, `SwapEGLBuffers`, `SetEGLSwapInterval`, `ReleaseEGLSurface`, `ReleaseEGLResources`) become **blocking** control requests executed on the apply thread. `ReleaseEGLResources` and `~BackendObject_DirectGLES` **must** block, or `MobileGL::Destroy()` proceeds while the server still holds the context. 3. **The `Init.cpp` hook** at `MG_Backend/Init.cpp:50`, before the `switch`. Note `:43-44` also fills `gBackendFunctionsTable` from the object — that table is c1's emit table, so coordinate rather than inventing one. 4. **`Server/PipeApplier`**: drive w1's decoder into the existing `MGPipeApply*` free functions; `ApplyOne` = decode → stamp → apply → reply → advance `appliedSeq` by **one**. `appliedSeq` has exactly one writer, s1's `SessionConsumer::ApplyOne` — drive it, do not poke `RingControl` yourself. **The 64-record batching is banned while the verb barrier exists.** 5. **p1's stamp rule, exactly as p1 specified it** (`~/w7/notes/p5/p5-results/p1-v1.md`; its §7 supersedes parts of its own §2, so read §7): `StampVerbBoundary(op)` → `MGPipeVerbForWireOp(op)`, `kVerbCount` ⇒ stamp nothing; otherwise call `MG_Pipe::MGPipeServerStampVerbBoundary(verb)` once per record **before** its applier. It bumps the serial, stamps the verb class mask's supplied/derived fields and **zeroes everything else** — the zeroing is load-bearing, because the client stamps all 63 and without it `rsp` is identically zero. Four boundary ops: `Clear`, `DrawVbo`, `ReadPixels`, `Blit`; **`Present` is not one**. Two things p1 flagged for you: **`MGPipeServerClearVerbBoundary()` is MANDATORY on leaving the applier** (without it a spawned server latches the stamp for life and the sticky-exemption cases start aborting under strict), and **`PipeApplier::m_residualPulls` is vestigial — delete the member** rather than wiring both it and the process-wide counter. 6. **R-11 in `Managers.cpp`**: `Ops_H_SubData` / `Ops_H_FlushRange` must copy the bytes into **server-owned** storage instead of leaving `GLESBufferResource::hostBytes` pointing into the client's shadow. w1's `MOBILEGL_IPC_AUDIT=1` fills retired `SEG_STAGE` bytes with `0xDD`, so a retained pointer shows up as 0xDD in the next frame — run with it on. **Integrator ruling on b1's open M-6 half (the flush-ladder snapshot):** the snapshot extent is exactly the range the record declares, **never widened**. The server's ladder operates only on staged bytes; if it ever needs bytes outside a staged range that is a **Fatal**, not a silent re-read. Tier 1's `INVALIDATE_RANGE` is an assertion that the old bytes are dead, and widening it has already clobbered GPU-written data silently once (`Managers.cpp:1126-1129`). 7. **Confirm s1's caps defaults.** `ServerSession::SetConsumedSubsystems` / `SetCapabilityBits` now **`Fatal{UnsetCallMask}`** if nobody sets them — that was s1's BLOCKER fix, and you are the "somebody". Set them from what the server's backend actually registered, and make sure a wrong answer fails loudly rather than silently disabling a family (a silently-wrong consumer mask is ID-39's 66 lost uploads). 8. **Teardown**, per `ARCHITECTURE.md:537` plus the contract's table 3: publish → server drains and acks → stop the apply thread (Kill, then join) → close transport → client drains the compile pool → `MobileGL::Destroy()` → release sync/query handles. Nothing added in P5 may start a destructor chain that runs after the transport closes. # Acceptance - `DirectGLES.Split.ClearThenReadPixelsScenario.*` green under `MOBILEGL_TRANSPORT=inproc`. That lane exists and currently **skips by name**; t1's arming condition is behavioural (transport not monolith, a live client session, a non-zero implemented-verb count, **and the client encoder's record ordinal actually moved during the case**), so it arms only when the path really runs. You and c1 jointly flip it. - The four self-tests in the preamble on all four build dirs, plus the split build. **G1 must not move.** - Teardown clean under `GLIBC_TUNABLES=glibc.malloc.tcache_count=0`; no hang, no UAF; the shutdown test bounded (5 s join), so a lost wakeup fails red rather than wedging CI. - Run the reduced path with `MOBILEGL_IPC_AUDIT=1` and report that no 0xDD reaches a draw. # The discipline this wave produced — R-16, and it is not optional Five packages each shipped at least one check that could not fail for the reason it existed: a self-test control that tripped on another control's message; a persistent-map test that wrote the record field by hand so deleting the producer still passed; a lane probe that armed against stub source text (the reviewer renamed one string and **8 of 11 split lanes went green having run monolith**). So: **no test may construct the state it is meant to observe; every control asserts its own failure string, not merely that something failed; every gate ships with one line saying "I made it red once, by doing X".** For each thing you build, break it, watch the check fail, restore it — and put that evidence in your report. w1's `~/w7/p5-w1-redcheck.py` is a working example of automating exactly this. Write `~/w7/notes/p5/p5-results/v1-v1.md` and return ≤200 words: commit range, acceptance numbers, whether the first inproc frame renders, and the three things c1 and the integrator most need to know.