Files
MobileGL/docs/Disaggregated/notes/p5/p5-results/w1-v2.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

365 lines
22 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.
# w1 — wave 1.5 (round 2): ID-48's three findings, closed
Branch `p5/w1`, range **`ce53553c..bb6ba282`** (three commits, one per finding).
Base: `git merge --no-edit feat/disaggregated` was a **fast-forward** to `ce53553c` — wave 1's
`79b78665` is already an ancestor of the integration head, so the merge added no commit of its
own and the range above is exactly this round's work.
Identity checked before the first commit (ID-40's standing rule):
`git var GIT_COMMITTER_IDENT` = `Swung0x48 <swung0x48@outlook.com>`; all three commits are that
name as author **and** committer, single-line messages, no trailer of any kind.
Files touched: `MobileGL/MG_Remote/Wire/PipeWireCodec.{h,cpp}` and
`MobileGL/MG_Test/Wire/PipeWireCodecTest.cpp` — +290 / −1, nothing else.
`PipeWireCodecTest.NoReplyIsWrittenForARowTheCatalogueGivesNoReplySlot` was not touched (c1's).
| commit | finding |
|---|---|
| `1a06b40a` | 1 — an empty `SEG_STAGE` rejects a blob that fits |
| `ba6dc4f7` | 3 — blob validation accepts any mapped segment |
| `bb6ba282` | 4 — the codec's `MapPersistent` arm never consults the adoption tier |
Each intermediate commit was **built and smoke-tested before it was made**
(`~/w7/p5-w1-commits.py`), so all three are bisect points, not just the last one.
---
## 1. Finding 1 — an empty `SEG_STAGE` now takes a blob that fits (`1a06b40a`)
**What was wrong.** `m_stageHead` / `m_stageTail` are monotonic byte counts, so "every staged
byte has retired" reads `head == tail`, **not** `head == tail == 0`, and `head % capacity` is
left wherever the last run ended. `StageAllocate` then charged a wrap skip against that offset:
with `head == tail == 64` in a 256 KiB stage the test became `2*capacity − 64 <= capacity`,
false at **every** occupancy, and `ReclaimStagedBytes()` cannot move an already-empty tail — so
the second attempt failed identically and the request aborted on
`Fatal{RingOverrun, "SEG_STAGE"}`, whose own message then printed `0 bytes still in flight`.
**What changed.** A new private `PipeWireEncoder::RebaseEmptyStage()`, called at the top of each
of `StageAllocate`'s two attempts — so it also runs *after* `ReclaimStagedBytes()`, which is the
review's scenario (8 MiB allocated, retired, then a 28 MiB request). When `head == tail != 0` it
resets both cursors to zero. **The general statement, as the verifier asked: the wrap skip may
only be charged against bytes that are actually still in flight, and when there are none the
allocator restarts at offset 0.**
**One thing the fix shape did not mention and the code needs.** The mark queue has to be rebased
with the cursors. A `StageMark` holds the **absolute** head cursor it was pushed at, and
`ReclaimStagedBytes` assigns that value straight to `m_stageTail`. Every mark not yet consumed
has `StageCursor <= head == tail` (the head is monotonic and marks are pushed in order), so each
one names a region that is already reclaimed and zero is the truthful rebasing of it. Without
that, one reclaim after a rebase would put the tail **ahead of** the head and
`StagedBytesInFlight()` would underflow to ≈2⁶⁴. `RebaseEmptyStage` rewrites them.
**Control.** The verifier's extension of
`PipeWireCodecTest.StagedBytesAreReclaimedOnlyBehindRetiredSeq`, kept: after the 64-byte
allocation retires and in-flight is zero, `StageBytes` of exactly `Wire2::kStageBytes` must land
at `Offset == 0`, in `kSegStage`, resolve back to `StageBase()`, and leave
`StagedBytesInFlight() == kStageBytes`.
> **I made it red once, by doing X: X = deleting the `RebaseEmptyStage();` call at the top of
> `StageAllocate`'s attempt loop.** Executed (`~/w7/p5-w1-redcheck2.log`):
> `1946 - PipeWireCodecTest.StagedBytesAreReclaimedOnlyBehindRetiredSeq (Subprocess aborted)`,
> `0% tests passed, 1 tests failed out of 1` — the verifier's exact outcome. Green again on
> restore.
### The exact maximum blob an empty stage takes — and the correction to `w1-v1.md:341`
`need = Align8(size)` and the first bound is `need > m_stageCapacity`, so **an empty stage takes
a blob of exactly `m_stageCapacity` bytes** (more precisely `floor(capacity / 8) * 8`; every
canonical capacity is 8-aligned, so the two are the same number).
`m_stageCapacity` is the stage `RingProducer`'s `Capacity()` when one is installed and the whole
`SEG_STAGE` view size otherwise. **In a real session there is no stage ring at all** —
`SessionRings.h:83-88`: `SEG_STAGE` is "an encoder-local LINEAR ALLOCATOR … a plain byte count:
no control page, and no rounding down to a power of two either" — so `m_stageCapacity ==
SessionSegmentSizes::StageBytes == MOBILEGL_IPC_STAGE_MB`, i.e. **33,554,432 bytes at the
default 32**. In the unit fixture it is `Wire2::kStageBytes` = 262,144, which is what the new
assertion pins.
**`w1-v1.md:341` said "The archive's bound is `MOBILEGL_IPC_STAGE_MB` (32 MiB)". The verifier
falsified it, and it was false: before this fix, the bound on an empty stage was**
```
max( head mod capacity , capacity − (head mod capacity) )
```
— i.e. anywhere from **half** the segment to all of it, equal to the full 32 MiB only on a
*fresh* encoder whose head is still 0. (The verifier's discriminator, `FINDING1B: fresh encoder
ALLOCATED offset=0 size=262144`, is exactly that boundary case.) **After this fix the sentence
is true as written**: the bound is `MOBILEGL_IPC_STAGE_MB`, 32 MiB by default, at every
occupancy at which the stage is empty.
### Does R-10's max-record counter see it? **No — and that is now pinned.**
`m_maxRecordBytes` is fed from `layout.TotalBytes` in `EncodeRecord` — header + payload + tails,
all of it `SEG_CMD` — while a staged blob leaves only `{Seg, Offset, Size}` (24 bytes) in the
record. The same control asserts `MaxRecordBytesSeen()` is **unchanged** across a
quarter-megabyte `StageBytes`. So `MaxRecordBytesSeen()` is **not** the staging bound and must
not be read as one: `SEG_STAGE` has its own bound and its own named
`Fatal{RingOverrun, "SEG_STAGE"}` (the message cites `MOBILEGL_IPC_STAGE_MB`), and `SEG_CMD`'s
`RingProducer::MaxRecordBytes()` is what R-10's counter is measured against. Both numbers are
printed live by their own Fatal; neither is a compile-time constant in this file.
---
## 2. Finding 3 — a content blob must declare `SEG_STAGE` (`ba6dc4f7`)
**What was wrong.** The only test was that the run resolved *inside some* segment, so
`CreateSamplerState.Parameters={Seg=SEG_REPLY, Offset=0, Size=sizeof(SamplerParameters)}` was
accepted by the encoder **and** the decoder, and the sampler applier received those bytes out of
a **server-owned** pool whose reuse has nothing to do with stage retirement. The audit's half
was worse: `NoteResolvedRun` opened with `if (blob.Size == 0 || blob.Seg != kSegStage) return;`,
so the run was never recorded, `PoisonedStageBytes()` stayed zero, and rule C's only mechanical
control was dark on exactly the record it exists to catch — the verifier's probe printed
`seg=3 accepted=1 poisoned=0` with the audit **on**.
**What changed, and where — this is stronger than the fix shape.** The verifier named
`RequireDeclaredBlob`. The arm went one level down, into **`CheckBlobIsHonest`**, because
`RequireDeclaredBlob` is only the "this record says it carries content" path: the **optional**
arms (`CreateRenderState`/`SetDynamicState` with `ChunkMask == 0`, `ResourceSubData` with no
content, `BufferSubDataResident`, `CreateShaderState.Spirv[i]`) and the **encoder's** per-slot
honesty loop call `CheckBlobIsHonest` directly, and a fix in `RequireDeclaredBlob` alone would
have left every one of them accepting `SEG_REPLY`. `RequireDeclaredBlob` calls
`CheckBlobIsHonest`, so it is covered too.
The arm runs **before** the resolve, deliberately: a forged `SEG_REPLY` run that happens to lie
inside a mapped reply pool must be refused for naming the wrong carrier, not left to pass or
fail on whether that pool is mapped at all.
**Which Fatal family, and why.** `Fatal{ProtocolCorruption, "<op>.blob"}`, **not** a new
`BlobNotStaged`. The families are the vocabulary the operator and the CI greps share —
`ProtocolCorruption`, `AbiMismatch`, `UnmigratedVerb`, `UnmigratedPipeInput`, `UnsetCallMask`,
`RingOverrun`, and no other appears anywhere in `MG_Remote` — and a one-off seventh name would
be a token nothing else in the tree recognises. The **segment** is in the message, which is the
part that has to be greppable: `seg=%u offset=%llu size=%llu is not SEG_STAGE(%u)`, plus the
citation of contract table 1 groups A/B/C and R-10.
**The audit's bookkeeping is now unreachable rather than load-bearing.** `NoteResolvedRun`'s
`blob.Seg != kSegStage` case was a silent `return`; it is now a named Fatal of its own, matching
the run-count overflow Fatal immediately below it, and its single caller (`ResolveOrFatal`) runs
`RequireDeclaredBlob` first — so it cannot be reached and says so if it ever is. The verifier's
"either cover the carrier or be unreachable for anything but `SEG_STAGE`" is satisfied by the
second branch.
**Controls.** Two new forked cases, both in the file's own Fatal-arm idiom (`RunInChild` +
`DiedOfAbort` + a **required diagnostic substring**, never `EXPECT_DEATH`):
- `AContentBlobCarriedOutsideSegStageIsFatalAtTheDecoder` — the verifier's perturbed sampler
fixture kept as its own case, **with `SetAuditPoison(true)` armed**, so the second half of the
finding is nailed too: with the poison on, the record must *die* rather than be applied with
`PoisonedStageBytes()` at zero. Requires `is not SEG_STAGE`, `CreateSamplerState.blob` and
`seg=3` in the child's log.
- `TheEncoderRefusesTheNonStageCarrierTheDecoderCallsFatal` — the symmetry this file already
states one arm over: under `inproc` a `SEG_REPLY` pointer resolves, so an emitter that staged
into the reply pool would get a valid seq locally and a Fatal on a peer.
> **I made them red once, by doing X: X = removing the `kSegStage` requirement.** Executed
> twice, both recorded in `~/w7/p5-w1-redcheck2.log`:
> **(a)** deleting only the `blob.Seg != kSegStage` arm — both cases red
> (`0% tests passed, 2 tests failed out of 2`);
> **(b)** the full wave-1 revert, that arm **and** `NoteResolvedRun`'s silent `return` — both
> cases red again, this time with the decoder child exiting 0, i.e. the verifier's exact
> `accepted=1 poisoned=0` state. Green again on restore.
---
## 3. Finding 4 — the codec's `MapPersistent` arm goes through the tier gate (`bb6ba282`)
**What was wrong.** `AdoptTier` had **zero** references anywhere on the codec path; the arm was
an unconditional `PostReply(..., kStatusDeclined, nullptr, 0); return true;`. `ConfigLoader.cpp`
accepts 0, 1 and 2, so `MOBILEGL_IPC_ADOPT_TIER=0` and `=1` — which contract §5 promises "parse
and are `Fatal` at use, naming P11" — decoded as an ordinary DECLINED on both forbidden tiers,
and an operator got a run that looked like a working T0.
**What changed.** The arm now asks `MG_Remote::Client::AdoptTierIsEmulate()` (b1's file,
unchanged) behind **the same conjunction the monolith applier uses**,
`MG_Config::Transport != MG_Config::TransportMode::Monolith` — `PipeApply.cpp`'s guard,
verbatim, so the two paths cannot drift. The return value is deliberately not a branch: the
helper returns `true` at T2 and **aborts** at T0/T1 on its own named diagnostic, and R-6 says P5
declines at every tier it survives.
**Controls** — three, and the third is what keeps the first two honest:
- `AdoptTierZeroIsFatalOnTheWirePathAndNamesP11` and
`AdoptTierOneIsFatalOnTheWirePathAndNamesP11`. Forked, not `EXPECT_DEATH` (the file's header
forbids it: `EXPECT_DEATH` re-runs the whole binary and re-enters the applier's globals).
**The diagnostic is required, not optional** — `ID-46` finding 10 is an empty death regex, and
these are its opposite: each case requires the literal
`MOBILEGL_IPC_ADOPT_TIER=0 names adoption tier T0, which P11 implements`
(and `=1 … T1 …`) in the child's log, and prints that log when it fails, so a crash for any
other reason fails the case.
- `TierTwoUnderSplitTransportStillDeclinesRatherThanRefusing` — the positive half. Without it
the two death cases could be satisfied by an arm that aborted on *every* tier, which is the
opposite mistake. T2 under `InProcess` transport still answers `kStatusDeclined` with an empty
payload (R-6), RAII-restored.
> **I made both death cases red once, by doing X: X = restoring the unconditional decline
> (deleting the `AdoptTierIsEmulate` call).** Executed: `33% tests passed, 2 tests failed out of
> 3` — both `AdoptTier*IsFatalOnTheWirePathAndNamesP11` red, and
> `TierTwoUnderSplitTransportStillDeclinesRatherThanRefusing` **still green**, which is exactly
> the discrimination the positive control exists for. Green again on restore.
---
## 4. The four self-tests, on `bb6ba282`
Gate script `~/w7/p5-w1-gate2.sh`, log `~/w7/p5-w1-gate2.log`. Every configure is checked for
`CMAKE_GENERATOR` + `CMAKE_CXX_COMPILER` + `CTestTestfile.cmake` out of the cache (the
verifier's C-10 trap: `CTestTestfile.cmake` alone did not catch a GCC/Makefiles tree), and **no
test runs after a failed build** — all four were `rc=0`, `Ninja`, `clang++`.
**(1) G1 — clean, as required.**
```
G1-split nm MG_Remote pull=0 (must be 0) split=346 (must be > 0)
symbol-report: .text 10806611 -> 10806611 (+0, +0.000%)
symbol-report: 27814 -> 27814 defined symbols: 0 added, 0 removed, 0 resized, 0 renamed
```
Against `~/w7/p5-before-libMobileGL.so`, `--threshold 0`, marker `.READY` =
`4595163c7c439641ddb94f8a936eb2ccd5fb8b19` (ID-44's re-taken baseline) confirmed present before
the run. Report `~/w7/p5-w1g-symbols.md`. This was never in doubt: everything this round
touches is under `MG_Remote`, which the pull build does not compile.
**(2) `ctest -L unit`, four lanes.**
| lane | result |
|---|---|
| `build-linux` (pull) | **1814 / 1814** |
| `build-push` | **1814 / 1814** |
| `build-verify` | **1814 / 1814** |
| `build-split` | **1980**, 1 failed — `PipeWireCodecTest.NoReplyIsWrittenForARowTheCatalogueGivesNoReplySlot` |
1975 → 1980 is **+5**, all of them mine and all in `build-split` only (the `MG_Test/Wire`
directory is not configured in the other three, which is why the pull/push name lists do not
move): `TierTwoUnderSplitTransportStillDeclinesRatherThanRefusing`,
`AContentBlobCarriedOutsideSegStageIsFatalAtTheDecoder`,
`TheEncoderRefusesTheNonStageCarrierTheDecoderCallsFatal`,
`AdoptTierZeroIsFatalOnTheWirePathAndNamesP11`, `AdoptTierOneIsFatalOnTheWirePathAndNamesP11`.
The one red is **the known one and is not mine** — c1's catalogue-flag conflict at
`PipeWireCodecTest.cpp:1203`, ID-48's carve-out; that case was not edited.
**(3) `ctest -L integration-gpu`.**
```
push integration-gpu: 100% tests passed, 0 tests failed out of 1128
split integration-gpu (MOBILEGL_TRANSPORT=monolith): 100% tests passed, 0 tests failed out of 1149
```
Name-for-name against `~/w7/p5-before-ctest-names.txt` with `comm`, the way
`wsl_p5_gate.sh:118-122` does, over `ctest -N` for every label:
```
pull removed: 0 added: 40
push removed: 0 added: 40
added by this package (pull): 0
```
**Removed = 0 in both**, which is the G14 assertion. The 40 additions are the merged integration
head's (b1 round 2 and `dev`), not this package's — none of them is a `PipeWireCodecTest` entry,
because that suite exists only in `build-split`.
**(4) Generators** — I touched no `.def` and no generator; run anyway.
```
gen_pipe: generated files are up to date
gen_pipe: self-test: 9 negative-control trip(s), positive control OK
gen_pipe_field_ownership: generated file is up to date
gen_pipe_dirty_surface: --check green (its long under-firing summary in the log)
```
**G5, both scripts** (run with the submodule links **off**, since they drive git):
```
bash scripts/p3a_untouched_regions.sh ff2994d9 HEAD rc=0
172b022273db01b1… FlushPendingRangesFrom
[p3a-untouched] the 11 pool / deferred-release / ring / flush-drain functions are
[p3a-untouched] byte-identical between ff2994d9 and HEAD
bash scripts/p4a_untouched_regions.sh ff2994d9 HEAD rc=0
[p4a-untouched] the 17 … regions are byte-identical between ff2994d9 and HEAD
```
b1's eleventh-row pin (`172b0222…`, ID-41 as amended) matches.
---
## 5. What needs an integrator ruling, or at least a decision recorded
**5.1 `GetCaps`'s two blobrefs are now held to `SEG_STAGE` as well, and they are the one
server→client row that owns an `MGPBlobRef`.** Contract §2 row 18 puts `MGPCaps`'s
`FormatCapabilities` and `RendererInfo` in the **server → client** direction, but they are
enumerated by `BlobSlotsFor(GetCaps)` and therefore walked by the encoder's honesty loop and by
the decoder's `GetCaps` arm, both of which call `CheckBlobIsHonest`. **This is inert in P5**: the
caps snapshot travels as a flatbuffer `CtrlEnvelope` out of `ServerSession::PublishCapsSnapshot`
(`ServerSession.cpp:380`), never as record blobrefs, so nothing declares those two and the whole
split unit lane is unaffected — verified, not assumed. But the phase that does carry caps in a
**record** will hit this arm, and at that point either `GetCaps` is exempted by name or the
catalogue grows the per-op *legal segment* column the verifier flagged as the ruling-worthy
version of this fix. **Filed, not taken** — the minimal fix needed no ruling and I did not want
a generated column landing in a rework round.
**5.2 The tier gate carries the applier's `Transport != Monolith` conjunct, including its hole.**
I mirrored `PipeApply.cpp` verbatim so the two cannot drift, which means that a decoder driven
directly under **monolith** transport still skips the tier check. In production that is
unreachable — a record only arrives at the decoder over a wire — and it is exactly ID-42's
finding that a split build under monolith transport mints like push. Only a unit test can be in
that state, and mine sets `InProcess`. If the integrator would rather the forbidden tiers die at
**parse**, that is `ConfigLoader.cpp` = **c0's** file, and `PersistentMapTracker.cpp:118`'s own
comment has already filed it; nothing in this round depends on the answer.
**5.3 No new Fatal family.** I used `ProtocolCorruption` rather than the review's suggested
`BlobNotStaged` (reasoning in §2). If the integrator wants a seventh family it is a one-line
change here plus whatever in CI greps the family names — say so and I will take it.
**5.4 No overlap with s1, ID-47 or the reply geometry.** Worth stating explicitly because
finding 3's fix mentions `SEG_REPLY`: my refusal names `kSegReply` only as an **illegal
client→server blob carrier**, and it lives in `CheckBlobIsHonest`. s1's reply-slot work writes
`SEG_REPLY` through `ReplySlot` / `ReplySink::PostReply`, which carries no `MGPBlobRef` and never
reaches any of these arms; ID-47 moves `SessionSegmentSizes::ReplyBytes` and `ReplySlotCount`,
which none of my files reads. **No shared line, no shared symbol.** The one file s1 and w1 both
have an interest in — `PipeWireCodecTest.cpp` — I touched only in my own cases.
**5.5 The pre-existing red is still there and still not a package's.**
`PipeWireCodecTest.NoReplyIsWrittenForARowTheCatalogueGivesNoReplySlot:1203` vs
`PipeCalls.def:100`'s `kReplySlot` on `ResourceCreate`. Unchanged from the verifier's §"Pre-existing
red"; ID-48 assigns the case to c1 and I left it alone. Every count above is stated with it
included.
---
## 6. Corrections to `w1-v1.md`
- **`:341`** — "The archive's bound is `MOBILEGL_IPC_STAGE_MB` (32 MiB)". **Was false when
written** (the effective bound was `max(head mod capacity, capacity − head mod capacity)`,
i.e. between half the segment and all of it, and equal to 32 MiB only on a fresh encoder).
**It is true as of `1a06b40a`**, at every occupancy at which the stage is empty. §1 above
carries the arithmetic, the exact number (33,554,432 bytes at the default knob) and the
separate answer on R-10's max-record counter, which does **not** see staged bytes.
- No other claim in `w1-v1.md` was falsified by the verifier; §10's reversal note and the
var-tail table are unaffected by this round.
---
## 7. Provenance — scripts and logs, all `~/w7/p5-w1-` prefixed
| file | what |
|---|---|
| `p5-w1-gate2.sh` / `p5-w1-gate2.log` | the gate of §4 (configure + generator/compiler proof, build, generators, G1, four unit lanes, G14 name lists, integration-gpu both arms) |
| `p5-w1-redcheck2.py` / `p5-w1-redcheck2.log` | the R-16 driver: four perturbations, each rebuilt and run, each restored and re-run green. Ends `P5_W1_REDCHECK2_ALL_WENT_RED` |
| `p5-w1-bt.sh` | build-one-target-then-test; **refuses to run any test when the build failed** (the verifier's stale-binary trap) |
| `p5-w1-commits.py` | the three-commit split; every anchor asserted unique, every intermediate state built and smoke-tested before it was committed |
| `p5-w1g-symbols.md` | the G1 symbol report |
| `p5-w1g-unit-{linux,push,verify,split}.log`, `p5-w1g-igpu-{push,split-mono}.log` | the lane logs |
| `p5-w1g-names-{linux,push}.txt` | the `ctest -N` name lists compared with `comm` |
| `p5-w1-p3a.log` / `p5-w1-p4a.log` | G5, both untouched-region scripts, `rc=0` |
| `p5-w1-final-build.log` / `p5-w1-final-unit-split.log` | the re-run on the committed tree: `1980`, the one known red |
One note on the harness, since it cost a round trip: **a `<<"EOF"` heredoc does not survive
`wsl.exe -- bash -lc '…'`** — the quoting is lost somewhere in the Windows argument path and the
body is expanded before the file is written, so the first version of the build script wrote
`cmake --build ""` and printed four empty `build rc=` lines. Every script above was written as a
**file**, never as an inline command string, which is the same conclusion the verifier reached
from the other direction.
No LFS fetch. No adb. Nothing outside `MG_Remote/Wire` and my own cases in
`MG_Test/Wire/PipeWireCodecTest.cpp`.