Files
MobileGL/docs/Disaggregated/notes/p1/p1-results/core-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

20 KiB

P1 package A (p1-core) — c2..c6 on top of the contract

Tree ~/w7/p1-core, branch p1/core, base feat/disaggregated @ 087685d1, contract bf86b1ed (tag p1/contract, see core-contract.md). Nothing pushed. Working tree clean apart from the three untracked build directories.

Commits (oldest first, all on p1/core after p1/contract)

sha subject
3aa4d8af1ff2ca6f95c9ab3e047e70bc0e0cf65f [Feat] (Pipe): fill PipeInputs per verb class from GLContext and stamp per-verb generations - a read of a field the verb did not fill is Fatal{UnmigratedPipeInput}
a196ada4c11b59f23587596486d265124ea06a6f [Feat] (Impl): call MGP_FILL before every GLFunctionsTable entry - 83 statements over 69 verbs, a no-op in the pull build
275dd3edb4909fe2a23af0f9a2667fb8215d24be [Feat] (Pipe): the MOBILEGL_PIPE_VERIFY shadow comparator - a per-verb entry compare over the fill set and a compare-at-read in every accessor, first differing field and verb serial, fatal by default
83b16561c20428dd15995ed3b2b4ad5496a97bab [Feat] (Pipe): give the six value structs G4 field lists and assert the lists cover their members - the memcmp fallback is now a compile error, floats in vector types compare bitwise
440d3c52534e2c227b8b4d83251d8afcb0849e3f [Test] (Pipe): pin the P1 poison and verify shapes - 63 fields, 69 verbs, the seven sticky fields, an omitted GenerateMipmap field leaves exactly that field stale, a corrupted snapshot names its field, reading an unfilled field aborts with SIGABRT

git diff --stat p1/contract..HEAD: 17 files changed, 1587 insertions(+), 72 deletions(-). Files touched (all inside A's ownership row of C.5): MobileGL/MG_Backend/MGPipe/PipeInputs.{h,cpp}, MobileGL/MG_Impl/Pipe/PipeFill.{h,cpp}, the seven MobileGL/MG_Impl/GLImpl/{Drawing,Framebuffer,Texture,Getter,Program,Query,Sync}/*.cpp, MobileGL/MG_Pipe/PipeFields.def, MobileGL/MG_Pipe/generated/PipeVerify.inc, scripts/gen_pipe.py, MobileGL/MG_Test/Pipe/{CMakeLists.txt, PipeCatalogueTest.cpp, PipeInputsTest.cpp}. Not touched: MG_Backend/DirectGLES/**, MG_Backend/DirectVulkan/**, PipeCalls.def, Coverage.def, FillPoints.def, PipeInputsSwitch.h, CMakeLists.txt (root), Config.h/ConfigLoader.cpp, fixtures. No signature in PipeInputs.h / PipeFill.h / PipeInputsSwitch.h that B/C/E code against changed (the accessor set, MGB_CTX, MGP_FILL, the knob names and log lines are as in the contract); the additions are listed under deviations 5-7.

What each commit does

  • c2 filler (PipeFill.cpp): MGPipeFillForVerb walks kMGPipeClassFieldMask[kMGPipeVerbClass[verb]]; MGPipeFillAccess::CopyField is one switch over the 56 stored fields, each branch calling the GLContext accessor of the same name (D4's fill column verbatim: loops of 8/16/32, GlobalBufferTargets/BufferBindPointTargets for the slot/point bases, &ctx.GetTextureUnitObject(0)/&ctx.GetImageTextureBinding(0) as array bases, Blend x8 + ScissorTest x16 for the indexed capabilities, all 35 capabilities incl. FramebufferSrgb's constant false); every copied field is stamped with the new serial; the seven sticky fields get FilledGen = 1 on the first live fill. MOBILEGL_PIPE_POISON_OMIT (<Verb>:<Field>) is parsed once at the first fill; MGPipeSetPoisonOmission(verb, field) is the programmatic form; the omitted pair keeps its value copy and loses only its stamp; unknown names are Fatal{PipeVerifyBadKnob}.
  • c3 fill points: the 83 MGP_FILL(X); statements of B.7 (36/11/8/3/1/18/6 per TU) plus #include <MG_Impl/Pipe/PipeFill.h> after each TU's last MG_State/MG_Backend include, inserted by a patcher (scratchpad/wf4/core/patch_c3.py) that refused any target line not spelling its verb.
  • c4 comparator (PipeFill.cpp, PipeInputs.{h,cpp}): entry compare at the end of every fill (SnapshotFromGLContext into a file-static second PipeInputs, MOBILEGL_PIPE_VERIFY_CORRUPT applied to the snapshot arm, MGPipeVerifyInputs over the mask, first differing field); compare-at-read through MGP_INPUT_VERIFY_READ -> MGPipeVerifyReadHook(*this, field, i0, i1) (re-reads the field from the live context into a scratch block and compares against the live block only); MGLOG_F("MGPipe: Fatal{PipeVerifyDiffer, \"%s@%s\", verb=%llu, where=%s}") + abort() unless MOBILEGL_PIPE_VERIFY_FATAL=0 (counts, MGLOG_E summary at teardown); MGLOG_I("MGPipe: verify armed - 63 fields, 69 verbs, fatal=N"), MGLOG_I("MGPipe: verify corruption armed - F"), MGLOG_I("MGPipe: poison omission armed - F@V"); a push build without the comparator answers MOBILEGL_PIPE_VERIFY=1 with one MGLOG_W_ONCE.
  • c5 G4 growth (PipeFields.def, gen_pipe.py, regenerated PipeVerify.inc): the six field lists (RenderStateParameters 65, PixelStoreParameters 8, PerBufferBlendState 7, StencilFaceState 7, DynamicBackendParameters 85, MGHostSpan 4), kMGPipeVerifiedPayloadCount 63 -> 69; MEMCMP_FALLBACK_TYPES empty and the fallback branch static_assert(sizeof(T) == 0, "no field list in PipeFields.def for this type"); Array<T,N> overload; VecBase detected by a probe and compared bitwise over data; check_field_lists_cover_struct_members(), scan_live_accessors() (both modes), --self-test with six negative controls and a positive one.
  • c6 tests: the four PipeCatalogue.* additions and the five PipeInputsTest.* cases (new unit target, own main() for MOBILEGL_LOG_FILE_PATH, fork/waitpid, never EXPECT_DEATH).

Verification (WSL, ~/w7/p1-core; logs under ~/w7/p1-core-*.log)

Every command below was run on the final tree (440d3c52) unless a commit is named.

command actual output
python3 scripts/gen_pipe.py --check gen_pipe: 71 calls (11 screen, 60 context), 69 verify payloads, 63 PipeInputs fields (7 sticky), 69 verbs, 9 classes / inventory 477 rows: ... 0 UNMAPPED / 1 accessor row(s) no backend reads: GetBoundTransformFeedbackName / generated files are up to date, rc=0
python3 scripts/gen_pipe.py --self-test six controls "tripped as expected" (struct member without F, F that is not a member, payload with no struct, verb missing from FillPoints.def, verb not in GLFunctionsTable, field row naming a non-accessor), positive control OK, rc=0. Before the whitespace-tolerant fix the three FillPoints controls reported DID NOT TRIP and the run exited 1 - the "zero trips is an error" arm was exercised.
cmake --build build-linux + ctest -L unit --no-tests=error rc=0; 100% tests passed, 0 tests failed out of 1475 (1466 before c6 + 9 additions)
python3 scripts/symbol_report.py --before ~/w7/p1-before-libMobileGL.so --after build-linux/libMobileGL.so --threshold 0 .text 10792579 -> 10792579 (+0, +0.000%), .data +0, .bss +0, .rodata +0, Total +0, 27799 -> 27799 defined symbols: 0 added, 0 removed, 0 resized, 0 renamed, 27060 normalised names unchanged. G1 holds after every commit (checked at c3, c4, c5, final). readelf -S section sizes identical. cmp -l shows 34 differing bytes: 20 in .note.gnu.build-id, 14 in .rodata = the GIT@5d99ee4 -> GIT@087685d configure stamp and glslang's Timestamp: 2026-09-05T23:14:30 -> 2026-09-06T01:32:05 string - build stamps of equal length, not code. (Markdown/JSON: ~/w7/p1-core-symbol-final.{md,json}.)
grep -rc "pGLContext" MobileGL/MG_Backend | sort | diff - ~/w7/p1-before-pglcontext.txt only the two contract files appear, both :0 (MG_Backend/MGPipe/PipeInputs.cpp:0, PipeInputs.h:0); every catalogued file's count unchanged - A converts no site
grep -c "pGLContext" MobileGL/MG_Backend/MGPipe/PipeInputs.h PipeInputs.cpp 0 0
grep -c "MGP_FILL(" MobileGL/MG_Impl/GLImpl/*/*.cpp | awk ... 83 (Drawing 36, Framebuffer 11, Texture 8, Getter 3, Program 1, Query 18, Sync 6)
cmake --build build-push + ctest -L unit --no-tests=error rc=0; 100% tests passed, 0 tests failed out of 1475; MOBILEGL_PIPE_PUSH=1 on every compile command, MOBILEGL_PIPE_VERIFY=1 on none
cmake --build build-verify + ctest -L unit --no-tests=error rc=0; 100% tests passed, 0 tests failed out of 1475; MOBILEGL_PIPE_VERIFY=1 on all 497 compile commands
ctest --test-dir build-push -L integration-gpu --no-tests=error -j 4 (at c3, a196ada4) 99% tests passed, 1 tests failed out of 868; the one failure DirectVulkan.PointSizeDemotion.PointSizeDemotionScenario.TheDemotionIsActuallyArmedWhenTheEnvironmentPinsItOn (0.23 s) passes alone in build-push AND in build-linux (100% tests passed ... out of 4) - a -j 4 flake of an env-pinned lane, the case the integrator script's --rerun-failed -j 1 exists for; zero Fatal{ lines in the log
ctest --test-dir build-push -L integration-gpu --no-tests=error -j 4 (final tree) ITEST_FINAL_PLACEHOLDER
ctest -N name diff (pull): comm -23 ~/w7/p1-before-ctest-names.txt - 2343 names, 0 removed, 9 added (PipeCatalogue.{VerbTableIsTheFunctionTable, StickyFieldsAreExactlyTheSeven, FloatVectorsCompareBitwise, SixValueStructsHaveFieldLists}, PipeInputsTest.{OmittingOneFieldForOneVerbLeavesExactlyThatFieldStale, ReadingAnOmittedFieldAbortsNamingTheVerb, ReadingAFilledFieldCompletes, CorruptedSnapshotFieldIsNamedWithItsSerial, EveryVerbFillsItsClassAndNothingElse}); the same 9 names exist in all three configurations (skips are visible, not vanishing). The padding-tolerant regex '^\s+Test\s+#[0-9]+:' is used, as in the contract report.
G4 unit (build-verify, PipeInputsTest.CorruptedSnapshotFieldIsNamedWithItsSerial) Passed: clean snapshot compares equal over kDraw's mask; MGPipeApplyVerifyCorruption(snapshot, GetRenderStateParameters) -> MGPipeVerifyInputs false naming GetRenderStateParameters, whose stamp equals the fill serial; a corruption of a field outside the mask is not seen; a forwarded field cannot be corrupted. Skips visibly in build-push ("verify not compiled in") and build-linux ("push not compiled in").
G4 lane-level smoke (build-verify, MOBILEGL_PIPE_VERIFY=1 ctest -R 'DirectGLES\..*ClearThenReadPixels') clean: 100% tests passed ... out of 5, log has MGPipe: verify armed - 63 fields, 69 verbs, fatal=1, 0 Fatal{. With MOBILEGL_PIPE_VERIFY_CORRUPT=GetRenderStateParameters: 0% tests passed, 5 tests failed out of 5 (rc=8), log has MGPipe: verify corruption armed - GetRenderStateParameters and Fatal{PipeVerifyDiffer, "GetRenderStateParameters@Clear", verb=1, where=entry}
G5 unit (build-verify, PipeInputsTest.{Omitting..., ReadingAnOmittedFieldAbortsNamingTheVerb, ReadingAFilledFieldCompletes}) all Passed: with SetPoisonOmission("GenerateMipmap","GetActiveTextureUnit") the GenerateMipmap fill leaves GetTextureUnitObject fresh and GetActiveTextureUnit stale, a following DrawArrays fill leaves it stale while GetBoundVertexArray is fresh, and a BindImageTexture fill (same class, different verb) heals it; the forked child that draws, reads a filled field, fills GenerateMipmap, reads the sibling and then the omitted field dies with WTERMSIG == SIGABRT and the log carries exactly Fatal{UnmigratedPipeInput, "GetActiveTextureUnit@GenerateMipmap"}, no @DrawArrays, no GetTextureUnitObject@; the sibling child without the omission _exit(0)s with no Fatal{. In build-push (Release/INFO, no POISON) the two poison cases skip visibly and ReadingAFilledFieldCompletes passes.
nm -D --defined-only build-verify/libMobileGL.so | grep -c MGPipeVerifyInputs / same on build-push 1 / 0 - the symbol E's retrace-verify job probes exists only in the verify library
EveryVerbFillsItsClassAndNothingElse (build-verify) Passed: after each of the 69 fills a field is fresh iff its class bit is set (sticky included); ContextIdentity() is the live context address

Not run: the 40-trace retrace under verify and the integration-verify lane (E's files; D.3 on the integrated tree). The verify-build integration-gpu was only smoked (5 ClearThenReadPixels entries) - on this tree no backend reads gPipeInputs, so its full run would only repeat build-push's proof.

Deviations from the brief (with reasons)

  1. Nine fill points precede a guarded expression rather than the bare call (D7 says "after every early return the call is behind; a verb whose table entry is null never bumps"): GL_Query.cpp 260/300 (if (handle && getQueryResult64 && !getQueryResult64(...))), 289 (outValue = (!f || f(h)) ? 1 : 0), 522/533/645 (handle = f ? f() : nullptr), 774 (supported = ... && f && f()), GL_Sync.cpp 177 (signaled = !f || !h || f(h)) and GL_Drawing.cpp 1331 (if (auto sync = backendGL.FenceSync()), inside the FenceSync && ClientWaitSync guard so this one is exact). At the other eight the fill precedes the statement that holds both the null guard and the call, so a null entry bumps the serial once with nothing to read it (kQuery fills one field; no backend read happens between two fills without a fill). Chosen over a comma-expression ((MGP_FILL(X), f(...))) or splitting the statements because either would touch the code shape of the pull build, and G1 asks for byte identity.
  2. Compare-at-read re-reads the WHOLE field, not only the indexed element (D8: "re-reads the same accessor with the same indices"). The hook copies the field from the live context into a scratch block through the same CopyField the filler uses and compares with MGPipeInputsFieldEqual; the indices decorate the report (MGLOG_E before the Fatal). A superset: a divergence in an index the backend did not ask for is still a boundary-vs-live divergence. One copy switch instead of a second 56-way index-aware switch.
  3. MGPipeVerifyReadHook takes the block as its first parameter ((const PipeInputs& self, field, i0, i1); the brief spells (f, i0, i1)): the macro expands inside member functions of any PipeInputs (the snapshot's accessors run in the tests), and only the live block is verified; without self the hook could not tell them apart. No backend code spells the hook.
  4. VecBase bitwise compare is a probe inside the generic MGPipeFieldEqual, not an overload (D8 says "two overloads ... partial ordering picks these over const T&"). For FloatVec4 the overload on const VecBase<D,T,N>& needs a derived-to-base conversion and LOSES overload resolution to the exact-match generic template before partial ordering is consulted; the Array<T,N> overload is exact and does win, and is emitted as the brief says. PipeCatalogue.FloatVectorsCompareBitwise pins the behaviour (NaN equals itself, -0.0f != 0.0f, a == b is IEEE and disagrees).
  5. MGPipeInputsFieldEqual takes const PipeInputs& (the contract had PipeInputs&), with a const VisitStorage overload added; nobody outside A calls it.
  6. MGPipeVerifyInputs carries __attribute__((visibility("default"))) (not in the brief): the library is built with hidden visibility, so without it E's nm -D build-linux/libMobileGL.so | grep -q MGPipeVerifyInputs step (C.4 (c)) could never pass. No MGPipe symbol was in the dynamic table before; this is the only one now.
  7. Pointer corruption flips the low bits instead of nulling (D8 says "swap a pointer for nullptr"): a pointer that is already null (an O-class field before the first fill, or a null GetProgramForDraw) would make the corruption invisible to the compare; a SharedPtr becomes an aliasing pointer with no control block. The snapshot is only ever compared, never dereferenced.
  8. SnapshotFromGLContext and MGPipeFillForVerb share CopyField rather than being two copies of the copy logic; the snapshot is still its own function (the branch that survives P13) with its own file-static block.
  9. CurrentVertexAttributeValue compares bitwise in PipeInputs.cpp with a sizeof == 48 static_assert: it is MG_State storage (three scalar Arrays, no padding), not a payload, so it gets no PipeFields.def row and the struct-member check does not search Core.h.
  10. PipeInputsTest is a separate unit target (the brief allowed it "if the verify-only tests need it"): the fork cases need their own main() to point MOBILEGL_LOG_FILE_PATH at a file before anything logs, and the fake-context cases need MobileGL_s; PipeCatalogueTest stays context-free. Its five cases are GTEST_SKIP in a pull build and the poison/verify cases skip in a push build without those switches.
  11. A push build without POISON acknowledges MOBILEGL_PIPE_POISON_OMIT with MGLOG_W_ONCE ("no stamp exists to omit") instead of the MGLOG_I("poison omission armed") line, which is emitted only where the omission can act.
  12. The sticky one-time stamp moved from an unconditional loop into the mask walk (every class mask carries the seven sticky bits, so the result is identical).
  13. gen_pipe.py --self-test also runs the field-list coverage check on the real inputs first (main() order: calls -> payloads -> coverage check -> coverage -> self-test), so a broken real list fails before the canned controls run.

Where the tree contradicted the brief's numbers

  • B.7 GL_Drawing.cpp:907 MemoryBarrier (TextureBarrier): line 907 is the closing brace; the memoryBarrier(GL_TEXTURE_FETCH_BARRIER_BIT | GL_FRAMEBUFFER_BARRIER_BIT); call is at 906. Every other B.7 line number held (the patcher checks each target line for its verb; the six XFB sites use abbreviated captured names beginXfb/endXfb/pauseXfb/resumeXfb/deleteXfb/bindXfb, GL_Getter.cpp:1176 spells getIntegeri().
  • B.7 continuation lines: seven listed lines are the call's continuation line of a multi-line statement (GL_Query.cpp 261, 301, 523, 534, 646, 775; GL_Sync.cpp 178 for the 177 entry) - the fill goes before the statement start (260, 300, 522, 533, 645, 774, 177).
  • D8 "all 67 members of struct RenderStateParameters": the struct has 65 direct data members (MGPipeValueTypes.h:239-387, MAX_VIEWPORTS is static). DynamicBackendParameters has 85 (brief gives no count).
  • D4 IsCapabilityEnabled "37 entries, MGPipeValueTypes.h:168-204": CapabilityInput has 35 enumerators before CapabilityInputCount; the storage is sized from the enum, so nothing depends on the number.
  • C.1 "7 files change" for c5's regeneration: only PipeVerify.inc changes at c5 (the field lists feed G4 alone); the contract commit already regenerated PipeFilled.inc and created PipeFillPoints.inc.
  • The integration-gpu count: 868 entries in build-push's integration-gpu label (the brief's "371 + 3 new cases" is E's post-integration figure).
  • ctest -N regex ('^\s+Test #', C.1): as recorded in the contract report, ctest right-aligns the test number, so the padding-tolerant regex is what produces the 2334/2343 name lists.

Unfinished / notes for the integrator

  • Nothing in A's scope is unfinished. The verify library's full integration-gpu, the integration-verify lane and the 40-trace retrace under verify are D.3 items on the integrated tree (they need B/C's sites on MGB_CTX and E's lanes to mean anything).
  • MGB_CTX_LIVE-guarded RecordError and the two InvalidateCompileEnv calls at backend init run before any fill; they are sticky and pass the poison from the first live fill on, as designed. If the verify lane finds an @<none> Fatal for any other field, the answer is a fill point at that boundary, never a sticky flag.
  • The -j 4 flake of PointSizeDemotionScenario.TheDemotionIsActuallyArmedWhenTheEnvironmentPinsItOn reproduced neither alone nor in the pull build; it is not caused by this branch but the integrator's --rerun-failed -j 1 step stays worth keeping.
  • scan_live_accessors() will start reporting MGB_CTX-> reads the day B/C land; today it reports one unread row (GetBoundTransformFeedbackName, dead by design).