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.
22 KiB
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 ofStageAllocate'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, withSetAuditPoison(true)armed, so the second half of the finding is nailed too: with the poison on, the record must die rather than be applied withPoisonedStageBytes()at zero. Requiresis not SEG_STAGE,CreateSamplerState.blobandseg=3in the child's log.TheEncoderRefusesTheNonStageCarrierTheDecoderCallsFatal— the symmetry this file already states one arm over: underinprocaSEG_REPLYpointer 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
kSegStagerequirement. Executed twice, both recorded in~/w7/p5-w1-redcheck2.log: (a) deleting only theblob.Seg != kSegStagearm — both cases red (0% tests passed, 2 tests failed out of 2); (b) the full wave-1 revert, that arm andNoteResolvedRun's silentreturn— both cases red again, this time with the decoder child exiting 0, i.e. the verifier's exactaccepted=1 poisoned=0state. 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:
AdoptTierZeroIsFatalOnTheWirePathAndNamesP11andAdoptTierOneIsFatalOnTheWirePathAndNamesP11. Forked, notEXPECT_DEATH(the file's header forbids it:EXPECT_DEATHre-runs the whole binary and re-enters the applier's globals). The diagnostic is required, not optional —ID-46finding 10 is an empty death regex, and these are its opposite: each case requires the literalMOBILEGL_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 underInProcesstransport still answerskStatusDeclinedwith an empty payload (R-6), RAII-restored.
I made both death cases red once, by doing X: X = restoring the unconditional decline (deleting the
AdoptTierIsEmulatecall). Executed:33% tests passed, 2 tests failed out of 3— bothAdoptTier*IsFatalOnTheWirePathAndNamesP11red, andTierTwoUnderSplitTransportStillDeclinesRatherThanRefusingstill 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 isMOBILEGL_IPC_STAGE_MB(32 MiB)". Was false when written (the effective bound wasmax(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 of1a06b40a, 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.mdwas 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.