Files
MobileGL/docs/Disaggregated/notes/p3a/p3a-results/final-review-v1.md
T
swung0x48 aba329cc53 [Docs] (Disaggregated): P6's plan and contract draft; the working notes move from a local directory into the repository
Two things land together: the plan and contract draft P6 needs before it starts, and the
working notes that until now existed on exactly one machine.

1. P6's plan and contract draft (neither started; not one line of code)

     docs/Disaggregated/P6-SPAWN-PLAN.md      the package plan
     docs/Disaggregated/P6-CONTRACT-DRAFT.md  the contract draft (moves to
                                              MG_Remote/CONTRACT-P6.md when c6 lands)

   The three findings that mattered, all written into the documents:

   a. P6 is SMALLER than its roadmap cell suggests. The transport primitives are already in
      the tree and already tested: SocketDoorbell including hangup detection and the two
      lost-wakeup fences (Doorbell.cpp:211-360, four cases in FdPassingTest), SCM_RIGHTS fd
      passing, ShmSegment::Adopt, and the SurfaceOp / WindowKind schema already defined in
      protocol.fbs. inproc uses a real second shm mapping rather than an alias, and
      SessionRings.h:22-28 says that was done so today is not the first time it runs. P6 is
      assembly plus a control plane plus a process, not "write a socket transport".

   b. The evidence for "P6 is only a transport swap" has EXPIRED. It was bought by P5c, whose
      audit found 59 direct memory accesses in a tree that already looked clean. P5e changed
      the tree again. So the first package, a6, is a read-only audit that writes no code, and
      every contract row that depends on it is marked PENDING a6 rather than decided in
      advance.

   c. P6 does not get a game running on the phone. ANativeWindow* is meaningless in the child,
      and protocol.fbs:186-196's own comment says Android transfers the window out of band -
      that band is P12. P6 lands pbuffer / surfaceless / offscreen, which is what HeadlessGL,
      the split-equivalent lane and trace replay need, and which is exactly what P6's own exit
      gate measures. A real window reaching the server is a named refusal. This gets its own
      section because "P6 is done" would otherwise read as "the game runs now".

   The contract adds rule G: a role may not name a process-local handle. It extends P5c's
   rule E (a role may not name the other role's memory) from memory to identity - EGLDisplay /
   EGLSurface / EGLContext / ANativeWindow* / fd number / pid / mapped address either cross as
   a token this contract defines or they do not cross, and a descriptor crosses only through
   SCM_RIGHTS, where the kernel renumbers it.

   What P5e left for P6 gets its own section. The latch semantics are already designed
   (ARCHITECTURE.md:504) and are copied unchanged. What is new is that after run-ahead the
   client no longer waits while the peer process can DIE: the client holds records that were
   published and will never be applied, and Android's freezer suspends the child without
   closing anything. So slow and dead must be distinguishable WITHOUT a timeout threshold.
   That is P6's only new design; everything else is carriage. It shares a predicate with E1's
   outstanding re-specification (ID-122), and the two should be designed together.

   Two gates carried over from P5e's lessons: G2 requires integration-spawn's test-name set to
   match integration-split's name for name, because a differing set means the lane is quietly
   running less; and the arm-proof gate requires every entry to record the child pid and
   transport=spawn in its OWN private log - ID-124 established that this kind of false green
   really happens, and a spawn lane that actually ran monolith would pass every other gate.
   S2's shape must be settled before it is written, and the document says why: E1 is the
   cautionary case.

2. The working notes move into the repository (docs/Disaggregated/notes/, 415 .md files)

   ROADMAP / CURRENT_STAGE_PROGRESS / MEASUREMENTS cite ruling numbers, audit line numbers and
   the provenance of gate figures from ~/w7/notes/, a directory that exists on one machine and
   is under no version control. A record cited hundreds of times that lives only locally is not
   a record, so it moves in whole, with its directory structure intact.

   Only .md moves. Scripts, run logs, census and gate result JSON, patches, APKs and nm dumps
   stay where they are: they are evidence DATA rather than documents - large, regenerated per
   run, and mostly carrying absolute paths and device serials that mean something only on the
   machine that produced them. The mapping and this split are written in
   docs/Disaggregated/notes/README.md.

   Two exceptions are recorded there too: P6's BRIEF has been promoted to a first-class
   document and keeps no copy under notes/, so the two cannot drift apart; and recovered/ holds
   material salvaged from failed workflow runs, which may duplicate the like-named phase
   directories and is kept because a few of those were the only complete version at the time.

   CI's citation lint takes docs/Disaggregated/*.md only (non-recursive), and notes/ is
   deliberately outside it: those notes' file:line citations were written against their own
   code heads, and resolving them against today's HEAD would fail wholesale - which is not an
   error, it is their correct state as a historical record. To check one, use the revision it
   declares (--rev).

3. Inconsistencies fixed in passing

   - README.md's status line still said P5e was in progress while the stage table already said
     closed.
   - CURRENT_STAGE_PROGRESS's next-step item 1 still listed the exit gate as pending, though
     (a) and (b) were run in the previous commit; rewritten to closed plus the one item that
     actually remains (E1).
   - ROADMAP's P6 row still had the pre-phase plan in three of its cells; it now carries the
     package order, the scope boundary and the two new gates.

Checked with check_doc_citations.py: 125 citations across docs/Disaggregated/*.md, 0 problems.
2026-09-18 23:31:39 -04:00

402 lines
42 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# P3a final adversarial review — the integrated tree `5cb826b0..3e298c9a` on `feat/disaggregated`
Reviewer: final integrator-side review, 2026-09-08. Scope: the whole integrated diff, cross-package seams only —
each package's own review already ran. Read-only against `//wsl.localhost/Arch/home/swung/w7/pipe` (a gate is
running there; nothing was built or run in it) and the Windows worktree
`C:/Users/geekerwan/AndroidStudioProjects/FoldCraftLauncher/MobileGL-disagg` at the same commit `3e298c9a`.
Diff extraction: `<scratchpad>/wsl/review-final.sh` → `<scratchpad>/wsl/diff/` (37 files, +9273 / -230).
## VERDICT: **REWORK**
Two criticals, both of them exactly the class this review exists to find — one is a defect no per-package
reviewer could see because it only exists at the client × *non-Espryt backend* seam, and the other is a gate
that is green while protecting code the shipping build does not compile. Neither is expensive to fix (C-1 is
one line plus an integrator ruling; C-2 is a script/ID amendment plus one line of `-R`). Everything else on the
tree is in very good shape: the handle lifecycle, the base-instance path, the epoch ordering and the
serial/version coherence all hold under the adversarial sequences I could construct (§6), G13 purity is clean,
the contract payload is in the base, and CI was not narrowed.
---
## 1. Critical
### C-1 — Under any backend that does not install `StateObjectDeathOps`, every VAO leaks a `VertexElementsCso` slot **and** a ~1.3 KB applier record, for the life of the process, on the shipped default mask
**Where.**
- mint: `MobileGL/MG_Impl/Pipe/VertexInputEmit.h:171` — `MGPipeSlots().Acquire(MGPipeKind::VertexElementsCso, lifetimeId)`, called from `EmitVertexElements` at every validate point.
- record: `MobileGL/MG_Pipe/PipeApply.cpp:1202-1203` `RecordAt(g_applier.VertexElementsCsos, desc.Cso.Slot, kMGPipeMaxVertexElementsSlots)`; the record is `MobileGL/MG_Pipe/PipeApply.h:141-152` — `Array<MGPVertexAttribWire,32>` (24 B each) + `Array<MGPVertexBindingPointWire,32>` (16 B each) = **1280 B + header per slot**.
- the only free: `MobileGL/MG_Backend/DirectGLES/SlotTables.h:416-429` `OnFrontendObjectDestroyed` → `MGPipeSlots().Free(kKind, handle)`, reached from `MG_State/GLState/VertexArrayState/VertexArrayObject.cpp:53`'s `NotifyStateObjectDestroyed` **only when `g_stateObjectDeathOps` is installed**.
- the only installer: `MobileGL/MG_Backend/DirectGLES/Managers.cpp:314` `SetStateObjectDeathOps(&g_glesStateObjectDeathOps)`, inside Espryt's `EsprytSlotTablesEnabled()`. `grep -rn "SetStateObjectDeathOps" MobileGL/` returns that one call site and the declaration.
- no global escape hatch: `grep -rn "MGPipeSlots()\.Reset"` outside `MG_Test/` is **empty**.
**Failure scenario.** DirectVulkan/Magma with the new default `MOBILEGL_PIPE_PUSH = kMGPipeSubsystemsMigratedAtP3a = 0x1ff` (`MobileGL/ConfigLoader.cpp:257`, `MobileGL/MG_Pipe/MGPipe.h:95`). The client's vertex-input emission gate is backend-agnostic — `wants()` is `MGPipeSubsystemForDirty(bit) & pushMask` (`MG_Impl/Pipe/PipeFill.cpp:1462-1466`) and bits 5/9/10 now map to `kMGPipeSubsystemVertexInput` (`MG_Impl/Pipe/Tracker.h:145-148`) — so `EmitVertexElements` runs on every draw under Magma too. Each new `VertexArrayObject` takes a slot; `~VertexArrayObject` raises the death notice into a null `g_stateObjectDeathOps` and returns; the slot is never freed and `g_applier.VertexElementsCsos` never shrinks and never goes `Live = false` (there is **no** `delete_vertex_elements` producer anywhere in the library — `grep` finds only `PipeApply.cpp`'s definition and `MG_Test`). Sodium/Create churn VAOs per chunk section: 10 k VAOs ≈ 13 MB of applier records plus 10 k `SlotState` + 10 k `UnorderedMap` nodes, monotonically, on a platform with an LMK. Past 65536 slots (`kMGPipeMaxVertexElementsSlots`, `PipeApply.h:113`) `RecordAt` returns null and **every** `create_vertex_elements` trips `Fatal{ProtocolCorruption}` permanently — fatal on a verify build.
`MG_Backend/DirectVulkan/Renderer/MagmaPipeArms.h:243-250` documents this exact anti-pattern as the reason Magma built its own age-reclaimed `MagmaPipeIdentityTable` instead of using `MGPipeSlots`: *"an allocator here would grow by one `SlotState` plus one map node per object EVER created, for the life of the process, on a platform with an LMK."* P3a re-introduces precisely that, from the client side, for a kind Magma deliberately kept out of the allocator.
**Refutation attempted, three ways, all failed.**
1. *"Espryt frees it, so this is Espryt's business."* Espryt does free it, and unconditionally — `OnFrontendObjectDestroyed` returns the slot *"whether or not any holder still had a twin at it"* (`SlotTables.h:407-410`). So the client's and espryt's own note that "on this tree VAO CSO slots are never freed" (`client-v2.md:308-309`, `espryt-v3.md:605-607`) is **wrong for Espryt and right for Magma** — both packages assigned the item to package C, and package C is the one backend where it already works. Nobody looked at the backend where it does not.
2. *"Magma is untouched in P3a, so this cannot be P3a's."* The mint is not in `MG_Backend/DirectVulkan/**`; it is in the client, which runs under every backend. Before this diff `MGPipeSlots()` held **zero** `VertexElementsCso` slots under Magma.
3. *"It is bounded by a shipped A/B."* No: `0x1ff` is the push default for both backends, and `MG_IntegrationTest/CMakeLists.txt:954, :1055, :1060` now pin `0x1ff` on three DirectVulkan lane families as well (raised from `0x7f` by gates' M1).
**Fix (one of):** (a) install the death notice for the `VertexElementsCso` kind from a backend-neutral place — a `MGPipeSlots().Free` in the client, driven by a `delete_vertex_elements` the client emits from `~VertexArrayObject` (this is `client-v2.md` §6.3 / `espryt-v3.md` §8's open item, and it is also the missing producer for the applier record); or (b) gate the client's vertex-input emission on the backend actually consuming it. (a) is the right one and closes three open rows at once.
### C-2 — G5's tenth row is green while the **push build compiles no `FlushPendingRangesNow` at all**; the ladder the shipping build runs is outside the gate
**Where.** `MobileGL/MG_Backend/DirectGLES/Managers.cpp`: `#if MOBILEGL_PIPE_PUSH` at `:902`, `#else` at `:1197`, `#endif` at `:1433`.
- `FlushPendingRangesFrom(GLESBufferResource&, const Uint8* hostBase, SizeT frontendSize)` — `:1051-1125`, **push arm**, the only three-tier ladder a push build has. Both call sites in a push build reach it: `:1717-1724` (the legacy call site, `#if PUSH → FlushPendingRangesFrom`) and `:2044` (`Ops_H_Readback`).
- `FlushPendingRangesNow(GLESBufferResource&, BufferObject&)` — `:1316-1385`, **inside the `#else`**, byte-identical to `5cb826b0:1004-1073`. A push build never compiles it.
- `scripts/p3a_untouched_regions.sh:76` lists the ten names including `FlushPendingRangesNow`; the extractor is preprocessor-blind (`:180-223`) and hashes the pull-arm text.
**Why this is "green for the wrong reason", not a nit.** `BRIEF-P3A.md`'s own risk row for this function is *"`FlushPendingRangesNow`'s three-tier drain silently changes tier because its caller now supplies bytes differently … The function is in G5's byte-identical set"*, and `scripts/p3a_untouched_regions.sh:39-41` states the threat model verbatim: *"A push arm that re-spells the three tiers beside an untouched pull arm satisfies G1 and defeats this gate's reason to exist — two ladders drift."* That is exactly the shape on the tree; the defence is keyed on the **name**, so a copy that was *renamed* walks past it. A future tier-threshold or map-access-bit edit made in `FlushPendingRangesFrom` — the only ladder the shipping build runs — regresses MC 26.3's p99 with G5 still green, and ID-6 makes the perf number recorded rather than gated, so nothing catches it.
It also **violates ID-13 as written**: *"`FlushPendingRangesNow` is defined exactly once, outside any `#if`, byte-identical to 5cb826b0."* It is defined once, but inside the `#else`. `espryt-v3.md:75-106, :519-520` (D12) raised precisely this and said *"It wants an explicit integrator ruling"* — **no ruling was recorded** (confirmed against `INTEGRATOR-DECISIONS.md`, which stops at ID-13's original text).
**Refutation attempted.** The author's argument at `Managers.cpp:1127-1138` — that a push build then contains exactly one ladder and both arms call it, where a forwarder would leave two definitions and make the extractor exit 2 — is sound *as far as it goes*, and I verified the ladders are behaviourally equivalent **today**: the three textual differences are the `hostBase == nullptr` early return (`:1066`, unreachable from the legacy call site, which passes `MappedData()`), `frontendSize` vs `bufferObject.GetSize()` (`:1070` vs `:1330`, the same value at that call site), and `UploadRangeFrom(resource, hostBase, …)` vs `UploadRangeNow(resource, bufferObject, …)` — and in the push arm `UploadRangeNow` is itself a one-line forwarder onto `UploadRangeFrom` (`:993-995`). So **there is no behavioural defect on this tree.** What is broken is the gate's coverage from here on, which is what G5 exists for.
**Fix (both halves).** (1) Amend `scripts/p3a_untouched_regions.sh` so the tenth row hashes the ladder the **push** build compiles: add `FlushPendingRangesFrom` to the list and capture its baseline sha at this commit, keeping `FlushPendingRangesNow` for the pull build. (2) Record the amendment as an ID (ID-14) superseding ID-13's "outside any `#if`" sentence, since the tree deliberately chose the two-arm shape. Both are minutes of work; without them the row is decorative for every build that ships.
---
## 2. Major
### M-1 — A `BufferObject` constructed while the resource op table is unregistered never gets an applier record, and unlike the legacy arm the handle arm has no repair
`MG_State/GLState/BufferState/BufferObject.cpp:44-45`: the handle is minted unconditionally but the create is
gated on `MGPipeResourceSubsystemEnabled()` = *bit 7 **and** `MGPipeGetResourceOps() != nullptr`*
(`MG_Impl/Pipe/PipeFill.cpp:593-596`). Espryt's consumer gate is bit-7-only
(`MG_Backend/DirectGLES/Managers.h:715-718`). The two disagree across a register/unregister boundary:
`UnregisterBufferBackendOps` nulls the table (`Managers.cpp:2466-2468`), called from `OnBackendContextDestroyed`
← `DirectGLES.cpp:11104 DestroyEGLContext()`; the re-register is at `MakeCurrent` (`DirectGLES.cpp:10568`).
A buffer born in that window latches `Published = false` (`ResourceTracker.h:342-350`), so no record exists;
every later `resource_respecify` is refused (`PipeApply.cpp:967-968`, counted into `RefusedResourceCalls`), and
`EnsureBufferResourceForHandle` reads `ResourceRecordOf(res) == nullptr → size = 0 → return resource`
(`Managers.cpp:2717-2721`) with **no diagnostic** — the store stays empty for the object's whole life and the
draw fetches through `id == 0`. The legacy arm recovers from the same window: `EnsureBufferResource` twins
lazily off the frontend object and full-uploads from the shadow.
*Refutation attempted:* "no GL call happens without a current context" — `CanTouchGLNow()` exists precisely
because frontend calls reach this code with no current backend context, and D-A2 explicitly preserves
`NotifySubData` as reachable off the render thread. The window is narrow, not empty.
**Fix:** in `MGPipeEmitResourceRespecify` (`PipeFill.cpp:629`), if `!tracker.WasPublished(handle)` emit the
create first (the descriptor is already built two lines below). Three lines, and it makes the create/destroy
latch self-healing in both directions.
### M-2 — `GLESBufferResource::hostBytes` is a raw pointer written off the render thread with no synchronisation
`Managers.h:673` `const Uint8* hostBytes = nullptr;` — a plain pointer. It is written at
`Managers.cpp:1921` (`Ops_H_SubData`) and `:1969` (`Ops_H_FlushRange`) **before** the `CanTouchGLNow()` test,
i.e. on the arm D-A2 keeps reachable off the render thread, and read on the render thread at `:2005`, `:2013`,
`:2044` (`Ops_H_Readback`), `:2639`/`:2741` (the ensure path) and `:4476` (the fp64 narrowing).
Everything else on that same struct and that same path is synchronised on purpose: `pendingRanges` /
`pendingResidentWrites` under `resource->pendingMutex`, `syncedChangeSerial` an `std::atomic` read with
`memory_order_acquire` (`:2581`, `:2610`). `hostBytes` is the one member the off-thread path touches with
neither. It is new in P3a — the legacy arm never cached a base, it re-read `bufferObject->MappedData()` on the
render thread at every use. espryt-review's C-2 fixed the *lifetime* of this pointer; nobody looked at its
*visibility*.
**Fix:** write it inside the `pendingMutex` scope, or only on the `CanTouchGLNow()` arm — the ensure path
republishes it on the render thread anyway (`:2741`, the `3c55e027` fix), so the off-thread store buys nothing.
### M-3 — the handle arm **drops** one of D-N's eleven `SyncGpuWrites` sites rather than keeping it, and the deviation was never ratified
`Managers.cpp:4456-4464`, in `SyncFloat64AttributeAsFloat32ByHandle`: *"the legacy arm opens with
`bufferObject->SyncGpuWrites()` … on this arm a 64-bit array whose SOURCE buffer was written by a shader and
not yet pulled back narrows stale bytes."* D-N's wording is *"**No move** of `SyncPersistentMappedRange` /
`SyncGpuWrites` off their 8 + 3 Espryt sites"* — a site deleted on the arm that ships is not a site kept. This
is a behavioural difference between the two arms **under the default mask**, and G2 requires the push and pull
integration lanes to be green name-for-name, so it survives only because no scenario covers the shape.
The closure table confirms nothing closed it: `espryt-review-v1.md:493-495` asked package D for
`DoublePrecisionScenario` **with an adopted source** and `StorageBufferRegrow` under ASan, and said in as many
words that *"a clean run of today's `DoublePrecisionScenario` does not discharge this"* — **NO CLAIM FOUND**.
`espryt-v3.md:362-366` reports `DoublePrecisionScenario` green, which is the run the review pre-emptively
refused as evidence.
**Fix:** an explicit integrator ruling (D7 → P8, recorded in `INTEGRATOR-DECISIONS.md` and in
`MEASUREMENTS.md`'s P3a section as a known behavioural delta), plus the named case package D still owes, or a
statement that the shape is unreachable in the corpus.
### M-4 — the stale-comment promotion condition at `Managers.cpp:2276-2282` is now met and the promotion did not happen
The comment says `NoArm` stays a warning rather than a stop because *"bits 7 and 8 are clear in every `.Handles`
itest lane today (`MG_IntegrationTest/CMakeLists.txt` pins `MOBILEGL_PIPE_PUSH=0x7f` …), which is
contract-review item 11 and package D's to re-pin … the stop can be promoted the moment those lanes carry an
explicit `0x1ff` arm."* Gates' M1 did exactly that: `MG_IntegrationTest/CMakeLists.txt:930` now pins `0x1ff`
beside `MOBILEGL_PIPE_LEGACY_MEMOS=0` for the Handles-arm knobs, and the four CSO lanes went to `0x1ff` /
`0x8000000000000 1ff`. So the sentence is false and the safety promotion it gated is unmade: a build with bit 8
clear and `LEGACY_MEMOS=0` still runs with **no vertex-input arm at all**, logging once
(`Managers.cpp:2343-2350`) and drawing through an unconfigured driver VAO.
**Fix:** correct the comment and promote `PipeSubsystemArmVerdict::NoArm` to the same `std::abort()` that
`ResolveEsprytSlotTablesArm` uses for bit 5 (`Managers.cpp:294-298`) — this is also `espryt-v2` D14's
"wants an explicit integrator ruling", still unruled.
### M-5 — four cross-package rows closed by nobody, carried into the phase exit
Not defects on this tree, but they are the "left for X that nobody closed" the review was asked to name; see
§5 for the full table. In severity order:
| row | declared | owner as assigned | reality |
|---|---|---|---|
| `delete_vertex_elements` producer + VAO CSO slot free | `client-v2.md:308-309`, `espryt-v3.md:605-607` | package C | **is C-1 above**; both packages misattributed it to the one backend where it already works |
| contract-review **m4** — the three pairing `static_assert`s use inconsistent right-hand sides | `contract-review-v1.md:136-142`, re-assigned to B by `wire-v2.md:194-201` | package B | B never mentions it; I confirmed the asymmetry survives at `PipeFill.cpp:933-947` (two of the three compare against `kMGPipeSubsystemVertexInput` directly rather than against `SubsystemForEmitter(...)`). Cosmetic, but it is the trap C.5 exists to prevent |
| gates **m10** — the DirectGLES buffer ABA has no positive control | `gates-v2.md:244, :369-371` | package C | never mentioned by C. Compounded: there **is no DirectGLES `.AbaControl` lane** (`MG_IntegrationTest/CMakeLists.txt:959-1011` registers six lanes; the buffer kind's corruption evidence is Magma-only) |
| wire **n6** — which counter G10 asserts against | `wire-v2.md:383-386` | package D | no document closes it, but **the code does**: `StorageBufferRegrowScenario` reads `PipeStats`' `mpr` out of the lane log (`Harness/PipeStatsWindow.h:26-28, :62-73`), not the applier's per-context member. Close it on the record |
---
## 3. Minor
| # | finding | file:line |
|---|---|---|
| m1 | Comment says the three vertex emitters *"still resolve to false today — their dirty bits map to no subsystem"*; they are mapped. | `MG_Impl/Pipe/PipeFill.cpp:1509-1512` vs `MG_Impl/Pipe/Tracker.h:145-148` |
| m2 | G5 doc drift after the tenth function landed: *"Extract the nine bodies"*, and `test.yml`'s *"nine named bodies" / "nine bodies extracted" / "three canned controls"*. | `scripts/p3a_untouched_regions.sh:266`; `.github/workflows/test.yml` (G5 step comments) |
| m3 | G7 attributes the trip with `grep -q IsBgra` over the **whole** ctest log rather than over the failing assertion, and traps only `EXIT` (no `INT`/`TERM`), so a Ctrl-C during the rebuild re-enters `repair`'s own build. Exact today (`IsBgra` appears once, at `MG_Test/Pipe/VertexInputEmitTest.cpp:266`); brittle to a future case name. | `scripts/p3a_vertex_input_negative_control.sh:174, :219` |
| m4 | `p3a_untouched_regions.sh` exits 1 under Git Bash on Windows: Python text-mode stdout emits CRLF and the `awk -v n="$name"` lookup then misses every row. Linux CI unaffected; `newline='\n'` fixes it. | `scripts/p3a_untouched_regions.sh` (python emit block) |
| m5 | G8's DirectGLES `.Handles` arm degrades to a **SKIP**, not a red, if `MGPipeResourceOps` is renamed — the arming marker is a CMake content grep. Honest (visible skip with a reason) but not a gate. | `MG_IntegrationTest/CMakeLists.txt:459-467`; `Scenarios/HandleRecycleScenario.cpp:390-407` |
| m6 | `MGPipeApplierReset` zeroes `MapPersistentRoundtrips` at every make-current while `PipeStats`' `mpr` is process-wide; the two observables disagree across a context switch. Latent (G10/G12 read `PipeStats`'), but this is what wire n6 asked to have written down. | `MG_Pipe/PipeApply.cpp:631` vs `MG_Impl/Pipe/PipeFill.cpp:735-737` |
| m7 | `MGPipeSlots()` is now mutated from `BufferObject`'s constructor and destructor, i.e. from whatever thread issues `glGenBuffers`/`glDeleteBuffers`. The "GL thread by construction" justification is stated but not enforced; two contexts of one share group on two threads is a torn free list. New for the `Buffer` kind. | `MG_Impl/Pipe/PipeFill.cpp:603-611, :741-763`; `ResourceTracker.h:287-299` |
| m8 | `ResolvedDrawBuffers::Entry::resource` is still a raw twin pointer that can dangle after `ReleaseByHandle`; both consumers check identity through `FindByHandle` first, so nothing is dereferenced, but the invariant is not written at the member (espryt-v3 §8's own carry-forward). | `MG_Backend/DirectGLES/Managers.h:979-1019` |
---
## 4. What I attacked and found sound (so the next reviewer does not repeat it)
**Handle lifecycle, end to end.** `BufferObject` ctor mints unconditionally and latches `Published`
(`BufferObject.cpp:44-45`, `ResourceTracker.h:342-350`) → `MGPipeApplyResourceCreate` starts the record over
rather than editing it, so a recycled slot cannot inherit a field (`PipeApply.cpp:938-956`) → espryt's
`GetOrCreate(handle)` refuses a **backwards** generation and resets the twin on a **forward** one
(`SlotTables.h:315-325`), with a release-build voice at `Managers.cpp:2368-2374` because `MOBILEGL_ASSERT`
compiles out at INFO → `~BufferObject` → `MGPipeEmitResourceDestroyAndFree` emits then frees, in that order
(`PipeFill.cpp:741-763`) → `Ops_H_Destroy` takes the twin **out** of the table before deciding pool/delete/defer
(`Managers.cpp:2084-2093`, `SlotTables.h:350-361`). I walked: (a) a handle whose twin was never created —
`ReleaseByHandle` returns an empty `BackendPtr` and `Ops_OnDestroy` fast-outs on `!resource`
(`Managers.cpp:1741`); (b) destroy while the ops table is unregistered — the applier clears the record, the
backend is not called, the slot is recycled, and the next `GetOrCreate` resets the orphaned twin whose
destructor skips the driver because `g_backendContextGeneration` moved; (c) the create/destroy latch
asymmetry — that is M-1, the only hole; (d) the process-teardown sentinel — armed on the handle overload too
(`SlotTables.h:299`), and the buffer's death path is byte-for-byte the legacy `Ops_OnDestroy`, so no new
teardown hazard. **The old twin is gone before the new create lands** in every ordering I could build.
**Base instance.** Three sites, all after `ConditionalRenderDiscardsCommand()` and immediately before `MGP_FILL`
(`GL_Drawing.cpp:662, :685, :715`); `Reset()` deliberately does **not** clear the pending value
(`Tracker.h:368-392`, B-C1 fixed); the value is mixed into bit 9's shutter so a base-instance-only change still
reaches the emitter (`Tracker.h:285-286`); it is a `ContentHash` input so the suppressor cannot eat it
(`VertexInputEmit.h:123-130, :233`); and it is cleared on **both** validate-point exits — the no-live-context
early return (`PipeFill.cpp:1443`) and the end of step 3 (`:1527`), the latter unconditionally, outside every
`wants()` gate. `DrawElementsIndirect` and the multi-draw tiering never set it, so they see 0; a plain draw
after a base-instanced one sees 0 and re-fires the shutter. The server resolves the shift
(`Managers.cpp:4043-4045`, `BaseInstanceByteShiftWire` at `:3666-3669`) and the client never learns the answer.
**Persistent map / readback / epoch.** The five-step order is implemented and named in place
(`Managers.cpp:2058-2081`): writeback → unmap → `syncedChangeSerial` stamp → epoch bump in
`Ops_H_ReadbackTracked`, and `MGPipeApplyResourceReadback` moves **no** serial (`PipeApply.cpp:1051-1053`).
The `hostBytes` base-vs-base+offset mismatch (client-review B-M3, ID-12 "espryt must change") **is closed by
reading both ends**: the client sends `base + offset` (`PipeFill.cpp:651-659`, `:701`) and espryt subtracts it
back — `hostBytes = bytes - offset` at `Managers.cpp:1921` and `bytes - start` at `:1969`. `OnBufferWriteback`'s
shape agrees on both sides: espryt passes `record.Offset` as the destination and `mapped` as the address
(`:2069-2072`), the client writes `WritebackFromBackend({addr, size}, offset)` (`ResourceTracker.h:582-585`).
`OnGpuWritten` is one whole-buffer range on both sides, asserted rather than assumed (`Managers.cpp:2436-2437`,
`ResourceTracker.h:599-602`), and the client's handler sets **both** `m_hasDefinedContent` and
`m_gpuWritePending` via `MarkGpuWritten()` (espryt-review m8's contract point — holds).
`Ops_H_MapPersistent` (`Managers.cpp:2102-2181`) is D-E-conformant: the two permitted substitutions plus one
**declared** third statement (`hostBytes = nullptr` at `:2170`, because `AdoptPersistentMap` frees the shadow) —
that third change is sound and is the C-2 fix, but it is a third change against D-E's "exactly two", so it
belongs in the phase-exit record against `ARCHITECTURE.md:466`.
**Serial / version coherence — one adversarial sequence per memo, all held.**
- `m_syncedVertexBuffersSerial`: A→B→A make-current with a stable per-activation call count would land on a
stamped value if the reset zeroed the serial. `MGPipeApplierReset` does `++` (`PipeApply.cpp:645-646`). ✔
- `m_syncedElementsSerial` + `m_syncedElementsHandle`: after `MGPipeApplierReleaseObjectRecords` a re-created CSO
at the same `{slot, gen}` restarts `ContentSerial` at 1, which would match a twin that had only ever seen one
configuration. Rescued because that function **also** advances both global serials (`:658-659`), forcing
`attributesDirty`. ✔ (The rescue is stated at `Managers.cpp:4020-4034`, which correctly names the rule as
living in another package.)
- `m_syncedIndexSerial`: the two element-array restore scopes put the driver id back without touching the
serial, which is right — the serial records what the *applier* said (`Managers.cpp:4188-4194`). ✔
- The fp64 stream memo: re-keyed on `{sourceHandle, applier Serial}` and never trusted for a persistently
mapped source (`Managers.cpp:4508-4513`); a destroy drops the record whole and keeps `Gen`, and the successor
gets `Gen+1`, so the handle compare covers slot recycling. ✔
- Suppressor reserved 0: a computed 0 is remapped to 1 (`SetHashSuppressor.h:62`), `Invalidate` writes 0, and
`InvalidateAll()` is called in the `FreshlyPrimed` block **beside** `MGPipeApplierReset()` and the emitter's
own `Reset()` (`PipeFill.cpp:1479-1494`) — without that trio a make-current would suppress the re-bind and
the server would draw with no vertex elements bound. ✔
- The client's per-handle create/bind latch is keyed on `{slot, Gen, ConfigVersion}` (`VertexInputEmit.h:174-186,
:304-308`), so ping-ponging two VAOs re-binds but never re-creates. ✔
- Records survive a make-current, per-draw state does not: `MGPipeApplierReset` clears the working half and
keeps `Resources`/`VertexElementsCsos` (`PipeApply.cpp:607-631`), and the rule is stated in three places that
agree (`PipeApply.h:196-219`, `ResourceTracker.h:465-492`, `Managers.cpp:4020-4034`). ✔
**Applier window bounds.** `MGPipeApplySetVertexBuffers` polices `Start + Count` (`PipeApply.cpp:1289-1303`);
the applier deliberately does not clear entries outside the window, and espryt bounds every read by
`VertexBufferStart/Count` **and** re-checks `BindingIndex == attributeIndex`
(`Managers.cpp:3647-3661` — the `13b380fe` fix; `glVertexAttribBinding(2,3)` was fetching the wrong entry).
The 32-slot walk (not `rec->AttributeCount`) is what keeps the disable arm alive after a shrinking
configuration, and it is independent of the client because `MGPipeApplyCreateVertexElements` zeroes both arrays
before unpacking (`:1225-1226`). ✔
**Subsystem masks.** Default `0x1ff` (`ConfigLoader.cpp:257`); bit 8 requires bit 7 and is refused **by name**
with a released `MGLOG_E` at `Managers.cpp:2326-2332`; `MOBILEGL_PIPE_LEGACY_MEMOS=0` compiles and the
`SyncToBackend` armless path says so (`Managers.cpp:3746-3750`). G13 is clean: `pGLContext` appears zero times
under `MG_Backend/`, and no `MG_State` type appears in the `MGPipeResourceOps` block. The contract payload
(`MGPVertexBuffers` 24 B, `F(BaseInstance)` in `PipeFields.def:99-100`) is already in the `5cb826b0` base, so
`git diff --stat -- MG_Pipe/generated PipeCalls.def PipeFields.def` over this range is legitimately empty.
**The gates, on the finished tree** (read; the cheap ones traced, none run in the shared tree):
G5 green and *correctly* green against `44c2b5cf` for the nine original functions, with a real `--self-test`
whose negative control for the tenth entry is non-vacuous — but see **C-2** for what the tenth entry protects.
G7 patches `IsBgra` at the one site that exists, restores + rebuilds on every exit path (trap armed *before* the
patcher), keeps its logs out of the repo, and its exit codes match the brief; it must be green-before and
compile-after, so an exit 0 for a different reason is well fenced (see m3 for the residue).
G8 has five `TEST_F`s and six registered lanes, the `.AbaControl` arm asserts the corruption with an explicit
"if this ever goes green-by-being-correct the reproducer has stopped reproducing" (`:287-297`), the new buffer
case at `:767` uses different colours at the same size/layout so a broken re-key reads red, and an unknown arm
`FAIL()`s instead of falling through — the two soft spots are m5 and M-5's missing DirectGLES `.AbaControl`.
G10 asserts 3 roundtrips for 3 storage definitions against 12 for per-draw, over a real `EndFrame`-delimited
`PipeStats` window, with `found` / `>= 0` guards that separate "no stats channel" from "counter read zero", and
its sibling `LargeArenaAdoption` pins `== 1` in a different window, so a stuck-at-3 counter cannot pass both.
G12 tests both directions in one case (`on` → 2, `off` → 0) **and** asserts identical pixels on both arms —
"the counters moved and the picture did not" — with `FAIL()` on an unknown lane.
G9's scan root, the `DirtySurface.def` regeneration and the `MG_State` widening are in the diff and clean.
**CI.** The TEMPORARY `feat/disaggregated` push trigger is present and untouched (`test.yml:9-12`). Nothing was
narrowed: the only `-R` change **broadens** `'HandleRecycle|CsoContentAddressing'` to
`'HandleRecycle|CsoContentAddressing|ResourceSubsystem|MapPersistentRoundtrip'` in `build-verify` (`:614-615`),
the only job that unpacks a push build; the singular `MapPersistentRoundtrip` deliberately catches both the
lane prefix and `…AnAdoptionCostsExactlyOneMapPersistentRoundtrip`. `VertexInputEmit` is a `unit` suite and runs
via `test.yml:570` in `build-verify`, which is the only configuration where its emission cases compile. Two new
G5 steps, branch-scoped to `feat/disaggregated` or `workflow_dispatch`, so they retire with the trigger. No
`LABELS`, `add_test`, `gtest_discover` or matrix entry was removed anywhere in the diff.
**Ownership-table "nobody" files that were touched.** `MG_Impl/GLImpl/Drawing/GL_Drawing.cpp` — exactly the three
one-line `MGP_SET_BASE_INSTANCE` calls ID-10 granted and nothing else; the macro is pull-safe
(`PipeFill.h:117-123`) so the three sites compile in a pull build too. `MG_Test/Buffer/BufferTest.cpp` — the
integrator landed espryt-v3 §7's measured fix verbatim (`83302ca2`; `ScopedBackendOps` at `:1658-1675` now
scopes the pipe table alongside `BufferBackendOps`), which closes the 26 red cases; correct and minimal, and it
is itself evidence that the `Published` latch (client m12) was necessary. `MG_Test/Pipe/TrackerTest.cpp` —
touched by B with B-DEV-5's justification.
---
## 5. Closure table — every "left for X" across the ten result/review files
Legend: **CLOSED** = a later file claims it with a `file:line` I could check; **DECLINED** = declined with a
reason on the record; **DEFERRED** = explicitly a later phase's; **OPEN** = no claim found anywhere.
Rows marked ⚑ are the ones I verified against the code myself.
### 5.1 Closed, and verified where marked
| id | declared | closed at |
|---|---|---|
| contract-review **M1** (Coverage.def omits DispatchIndirect/Query) | `contract-review-v1.md:23-58` | `wire-v2.md:35, :103-111` — `Coverage.def:40-58` |
| contract-review **M2** ⚑ (`GetOrCreate(handle)` adopts a stale generation) | `:60-108` | `espryt-v2.md:126-145` → verified live at `SlotTables.h:315-325`, `Managers.cpp:2368-2374` |
| contract-review m1/m2/m3(A)/m6 | `:112-154` | `wire-v2.md:40-42`; `client-v2.md:200` |
| contract-review must-know 9 ⚑ (`Start+Count` policing) | `:337-340` | `PipeApply.cpp:1289-1303` |
| contract-review must-know 10/11 | `:341-347` | `client-v2.md:200`; `gates-v2.md:54-97` ⚑ (`CMakeLists.txt:930, 1045-1060`) |
| wire-review **C1b** ⚑ (refusals countable) | `wire-review-v1.md:496-497` | `PipeApply.h:220-229`, `PipeApply.cpp:476-490` |
| wire-review **C2** ⚑ (serials advance, never zero) | `:499-502` | `PipeApply.cpp:645-646`, `:658-659` |
| wire-review M-B/M-C/M-D/M-E, n1, n7 | `:505-514, :284-288, :304-310` | `wire-v2.md:36-44`; `client-v2.md:283-285` ⚑ (`BufferObject.cpp:435`) |
| client-review **B-C1** ⚑ (Reset ate the pending base instance) | `client-review-v1.md:22-56` | `Tracker.h:368-392`; the substitute clear at `PipeFill.cpp:1443` |
| client-review **B-C2** ⚑ (record re-publication) | `:58-97` | resolved per ID-12; rule at `ResourceTracker.h:465-492`, `PipeApply.h:196-219` |
| client-review **B-M1** ⚑ (the three ID-10 sites) | `:103-119` | `GL_Drawing.cpp:662, :685, :715` |
| client-review **B-M2** ⚑ (Acquire on content paths) | `:134-159` | `PipeFill.cpp:581-596` — content paths use `Find` |
| client-review **B-M3** ⚑ (hostBytes base vs base+offset) | `:161-178` | espryt was already conformant: `Managers.cpp:1921`, `:1969` subtract |
| client-review B-M4(a)/(b-NoteBoundAs)/secondary, m1-m6, m8-m12 | `:187-256` | `client-v2.md:151-210` |
| espryt-review **C-1** ⚑ (draw-clean vs a live host map) | `espryt-review-v1.md:38-101` | `Managers.cpp:2577` — the probe asks `frontend->IsMapped()` again |
| espryt-review **C-2** ⚑ (dangling hostBytes) | `:103-160` | `Managers.cpp:2170`, `:2637-2641`, `:2741` — **but see M-2 for the visibility half** |
| espryt-review **M-2** ⚑ (walk bounded by AttributeCount) | `:191-213` | `Managers.cpp:4054-4067` — all 32 slots |
| espryt-review **M-3** ⚑ (bit 8 without bit 7) | `:215-233` | `Managers.cpp:2326-2332` |
| espryt-review **M-5** ⚑ (memo depends on wire's C2) | `:254-281` | `Managers.cpp:4020-4034` |
| espryt-review m2 ⚑ (readback clamp past the offset) | `:291-294` | `Managers.cpp:2036-2040` |
| gates-review M1-M4, m1-m6 ⚑ | `gates-review-v1.md:25-210` | `gates-v2.md:54-210`; ID-11's ten at `scripts/p3a_untouched_regions.sh:76-77` |
| espryt-v3 §7 ⚑ (26 red `BufferTest` cases) | `espryt-v3.md:526-587` | **integrator landed it** as `83302ca2` — `MG_Test/Buffer/BufferTest.cpp:1658-1675` |
| wire **n6** (which counter G10 asserts) ⚑ | `wire-v2.md:383-386` | no document, but the code answers: `Harness/PipeStatsWindow.h:26-28` reads `PipeStats`' `mpr`. **Close it on the record** |
### 5.2 Declined with a reason (accepted)
wire n2/n3/n4/n5/n8/n9 (`wire-v2.md:393-401`); espryt-review m4 — `FlushPendingRangesFrom`'s extra null check
(`espryt-v2.md:216`, restated `espryt-v3.md:99-101`) — **note this is now one of C-2's three divergences**;
client-review B-M4(b)'s `RefreshBindMask` half and client m7 (`client-v2.md:173-181, :297-303`); gates m7/m9
(`gates-v2.md:241, :243`); contract-review m5.
### 5.3 Deferred to a later phase (accepted)
wire R1 → P5 (`MGPipeApplierReleaseObjectRecords` has no production caller); client B-M5 → the phase that gives
the backend an unmap hook (`PipeFill.cpp:718-726`) ⚑ — recorded correctly; espryt D7 → P8 (**but see M-3**);
espryt §5's three frontend reads → P5/P8; the vertex-elements CSO content-addressing → P7;
`PipeResource::m_backend` deletion → P13.
### 5.4 OPEN — no claim found anywhere in the ten
| # | row | declared | owner as assigned | my verdict |
|---|---|---|---|---|
| 1 | `delete_vertex_elements` producer + VAO CSO slot free | `client-v2.md:308-309`, `espryt-v3.md:605-607` | package C | ⚑ **This is C-1.** Misattributed: Espryt already frees; Magma does not. **Must fix** |
| 2 | espryt D12 / ID-13 — a push build has no `FlushPendingRangesNow` | `espryt-v3.md:75-106, :519-520` | integrator | ⚑ **This is C-2.** **Must rule + amend the script** |
| 3 | espryt-review post-rebase 3 — named C-2 cases (adopted `DoublePrecision`, ASan `StorageBufferRegrow`) | `espryt-review-v1.md:493-495` | package D | ⚑ still owed; the run espryt-v3 reports is the one the review pre-refused. Feeds M-3 |
| 4 | espryt-review post-rebase 2 — package D's itest for C-1 | `:489-492` | package D | still owed |
| 5 | espryt-review post-rebase 4 — `VertexArrayEnableDisableScenario` with a **shrinking** enabled set | `:496-497` | package D | the only gate that can see M-2's fix; in the lane regex but no shrinking-config claim |
| 6 | espryt-review post-rebase 6 — `LEGACY_MEMOS=0` + `PUSH=0x7f` must name a verdict | `:500-501` | integrator/D | ⚑ related to **M-4** |
| 7 | espryt D14 — the armless verdict diagnoses and does not stop | `espryt-v2.md:272-273` | integrator | ⚑ **M-4**; the promotion condition is now met |
| 8 | contract-review **m4** — the three pairing `static_assert`s | `contract-review-v1.md:136-142` → B | package B | ⚑ **M-5**; asymmetry survives at `PipeFill.cpp:933-947` |
| 9 | gates **m10** — the DirectGLES buffer ABA positive control | `gates-v2.md:244, :369-371` | package C | ⚑ **M-5**; and there is no DirectGLES `.AbaControl` lane at all |
| 10 | client §6.2 — the three `GL_Buffer.cpp` `NoteBoundAs` binder hooks | `client-v2.md:304-307` | **nobody** | ⚑ real but bounded: the two bits anything keys on are covered by `NoteBoundAs` at `VertexInputEmit.h:219, :267`. Carry to P4a |
| 11 | espryt m6 / post-rebase 10 — record the per-draw `FindByLifetimeId` cost in D.4 | `espryt-review-v1.md:306-312, :508-509` | package D | measurement, not a defect |
| 12 | espryt §4.9 — D.4.6's peak-RSS reading needs `retrace_gate.py` to grow | `espryt-v3.md:436-441` | package D | ⚑ **this is the measurement that would have caught C-1**; do it before the device runs |
| 13 | gates §5.2/§5.3/§5.4/§5.6/§5.7, gates m8, §6.10, §6.11 — re-capture `p3a-before-untouched.sha` with the ten-line listing; run G7 on a tree carrying B; the four counting entries must stop skipping; `build-bench`; `gh workflow run test.yml` | `gates-v2.md:353-371`; `gates-review-v1.md:214-216, :363-365` | integrator | ⚑ **all still owed**; G7 in particular has never been run on a tree carrying B |
| 14 | client-review §7.3 — the `Blob.Size` off-by-one control in a verify build | `client-review-v1.md:408-410` | integrator | still owed |
| 15 | client-review §7.7 — G10 non-zero and G12 behavioural on the merged tree | `:423-425` | integrator | ⚑ now provable: the lanes exist and are CI-reachable (`test.yml:614-615`). Run once and record |
| 16 | client-review §7.8 / espryt §7 — the `…ActuallyArmedWhenTheEnvironmentPinsItOn` shared-log race | `MG_IntegrationTest/CMakeLists.txt:1040` | integrator/D | still open; pre-existing, `-j 8` only |
| 17 | contract-review m3 (Magma half), m7; contract §5.5; wire §6.9; espryt §1, §2, §4.7 | various | integrator (docs/tooling) | doc + tooling corrections, none load-bearing; espryt §2's "the G5 script self-`cd`s, so a foreign-cwd run is a false pass" is worth taking |
| 18 | espryt §8 — the `ResolvedDrawBuffers::Entry::resource` invariant sentence | `espryt-v3.md:601-603` | a later pass | **m8** |
| 19 | client §6.5 — the `MOBILEGL_PIPE_POISON_OMIT` caselist sweep | `client-v2.md:311-312` | G15 | off the critical path, as declared |
| 20 | client-review §7.2 residue — `EveryAttributeFieldSurvivesTheWireConversion` as a full round trip | `:402-407` | integrator | declined with a reason by B (a second oracle would make G7's field-drop fail twice); accept |
| 21 | gates §1 — gates' own G1/G14 are measured against `5cb826b0`, not the final tree | `gates-v2.md:44-48` | integrator | ⚑ **must re-measure before the verdict**: G1 is a hard gate and the number on record predates espryt and gates |
---
## 6. The exact fix list
**Blocking (REWORK):**
1. **C-1.** Give `VertexElementsCso` a backend-neutral death path. Preferred shape: the client emits
`delete_vertex_elements` and calls `MGPipeSlots().Free(MGPipeKind::VertexElementsCso, handle)` from
`~VertexArrayObject` under `#if MOBILEGL_PIPE_PUSH`, mirroring `MGPipeEmitResourceDestroyAndFree`
(`PipeFill.cpp:741-763`) — emit first, free second, latch "was it published" the same way. That closes
`client-v2` §6.3, `espryt-v3` §8's carry-forward and the applier's missing `delete_vertex_elements` producer
in one edit, and it makes Espryt's existing death notice a redundant second path rather than the only one.
Add a case: create N VAOs, destroy them, assert `MGPipeSlots().HighWater(VertexElementsCso)` /
`LiveCount` does not grow — and run it on the DirectVulkan lane, which is where it fails today.
2. **C-2.** Add `FlushPendingRangesFrom` to `scripts/p3a_untouched_regions.sh:76`
(`EXPECTED_FUNCTION_COUNT=11`), capture its baseline sha at `3e298c9a`, and add it to
`SELF_TEST_FUNCTIONS`. Record an **ID-14** that supersedes ID-13's "outside any `#if`" sentence with the
two-arm shape the tree actually chose and the reason (`Managers.cpp:1127-1138`). Fix the "nine" wording in
the script and `test.yml` while there (m2).
3. **M-1.** In `MGPipeEmitResourceRespecify` (`PipeFill.cpp:629`), emit the create first when
`!tracker.WasPublished(handle)`.
4. **M-2.** Move the `hostBytes` store in `Ops_H_SubData` (`Managers.cpp:1921`) and `Ops_H_FlushRange`
(`:1969`) inside the `pendingMutex` scope, or restrict it to the `CanTouchGLNow()` arm.
5. **M-4.** Correct `Managers.cpp:2276-2282` and promote `NoArm` to a stop for both P3a families, now that the
lanes carry an explicit `0x1ff` arm.
6. **Re-measure G1 and G14 on `3e298c9a`** before the phase verdict (closure row 21). The numbers on record
are gates' at `5cb826b0`; G1 is a hard gate with an empty admitted-resize set and it has not been read on
the finished tree.
7. **Run G7 once on this tree** (`bash scripts/p3a_vertex_input_negative_control.sh build-push`) — closure row
13. It has never been executed on a tree carrying package B, and it is the negative control for G6.
**Non-blocking, but before the `dev` merge:**
8. **M-3.** Record the fp64 `SyncGpuWrites` arm-divergence as a ruled deviation in
`INTEGRATOR-DECISIONS.md` and `MEASUREMENTS.md`'s P3a section, or land package D's adopted-source
`DoublePrecisionScenario` case (closure rows 3-5).
9. **M-5.** Close contract-review m4 (`PipeFill.cpp:933-947`), record wire n6 as answered by the code, and
either add a DirectGLES `.AbaControl` lane or write down that the buffer ABA's corruption evidence is
Magma-only.
10. Minors m1, m3, m4, m5, m6, m7, m8 as written above; and grow `retrace_gate.py`'s peak-RSS reading
(closure row 12) — it is the measurement that would have caught C-1 on its own.
11. Remove the TEMPORARY `feat/disaggregated` trigger (`test.yml:9-12`) **at** the `dev` merge, not before —
the two G5 steps are branch-scoped to it and retire together, which is intentional
(`test.yml`, G5 step `if:`).