From 22067888e107f0fa9008d5cd2834459986c3f212 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Wed, 23 Sep 2026 08:14:52 +0200 Subject: [PATCH] Record the third merge gate, and delete a false argument rather than amend it Soul built the counterexample. The claim that no construction gives two edges with tied From and Role and differing To reasoned about each hop separately, and a selection carrying both hops mixes their edges into one bucket. A row that self-references through the same role it uses to cite a peer produces exactly that pair. It runs in both runtimes. Three comparator survivors the last gate named are still alive, and batch 6 added no Rust row-order test at all. Two of my own words were wrong and both are corrected here. Nested wire-type byte parity overstated evidence gathered at a single all-optionals-absent value. And calling whole-message parity blocked on an ownership move ran two independent things together: the encoders agreeing on bytes needs no ownership move, and Soul wrote it this afternoon at 376 bytes identical. Calling it blocked made the cheapest available evidence look expensive, which is how it slipped six passes while sitting there for the taking. The claim also had no home. The file section 9 names as carrying it contains no mention of typed selection and never did. Co-Authored-By: Claude Opus 5 --- docs/cultnet-selection-cut.md | 180 ++++++++++++++++++++++++++++++++-- 1 file changed, 173 insertions(+), 7 deletions(-) diff --git a/docs/cultnet-selection-cut.md b/docs/cultnet-selection-cut.md index 6f26ea17..104b9aa8 100644 --- a/docs/cultnet-selection-cut.md +++ b/docs/cultnet-selection-cut.md @@ -3189,13 +3189,19 @@ still owes its Yggdrasil run**, and Soul's pass will provide it. now unwraps. The first run failed on the wrapper text, which is precisely the bug that half of R-AM exists to fix. - **R-AN.** Two isolating Rust tests added; the previous one tied `From` and - `To` across both edges, so dropping `role` survived. **`To.SchemaId` and - `To.Key` were re-checked and the earlier "equivalent" claim holds**, with a - structural proof rather than a shrug: within a page-position bucket, `cites` - ties every edge's `To` to the query's one declared target and `cited` ties - it to the anchor row's own identity, so no construction gives two edges with - tied `From` and `Role` and differing `To`. **No artificial test was forced - onto dead comparator branches**, which is the right answer. + `To` across both edges, so dropping `role` survived. + **The `To.SchemaId`/`To.Key` equivalence argument recorded here was FALSE, + and is deleted rather than amended.** It claimed that within a page-position + bucket no construction gives two edges with tied `From` and `Role` and + differing `To`. Soul built the counterexample and ran it in both runtimes: + **a selection carrying both hops mixes their edges into one bucket**, so a + row that self-references through the same role it uses to cite a peer yields + a `cites` edge (`to` = the queried peer) and a `cited` edge (`to` = itself), + tied on `From` and `Role`, differing on `To`. A self-referencing role is a + parent or peer link — ordinary, not exotic. **This is the second + justification-from-an-unchecked-property in three batches**, and R-AL's + standing rule applies to it. + - **R-AO.** Shared-key order pinned in both runtimes, both row orders, plus a vector case regenerated into both written files. - **R-AP, half built and half stopped, correctly.** The encoding is decided @@ -3234,3 +3240,163 @@ No vector yet exercises the real message output byte for byte. whole-message byte parity is required before this cut merges, R-AR becomes a blocker and Cut 1 stays open; if it can be its own cut, Cut 1 can close on the claim above once Soul clears it. + +## Soul, the merge gate, third pass, 2026-09-23 + +Opus. **Every run went to Yggdrasil**, supplying the run batch 6 owed. +Reproduced: C# Networking 279 / 2 skipped, Mesh 255, Rust 259 across 12 +binaries. **Caching is 190 passed / 3 failed** — the three assert a write is +*refused*, which root in a container cannot produce. **Unproven, not +passing**, and Soul declined to call them environmental on its own authority. + +**Verdict: Cut 1 may not merge.** + +### SM-7, CONFIRMED, high. R-AN did not land, and its justification is false. + +Three named survivors are still alive: + +| mutation | Rust | C# | +|---|---|---| +| drop both `to.schemaId` and `to.recordKey` from the edge comparator | **survives** | **survives** | +| drop `recordKey` from the **row** comparator | **survives** | killed | + +The row survivor is the fourth line of SM-4's own table from the previous +gate, and **batch 6 added no Rust row-order test at all**. + +**Soul built the counterexample and ran it in both runtimes.** The false +argument reasoned about each hop separately; a selection carrying **both** +hops mixes their edges into one `Vec`. A row that self-references through the +same role it uses to cite a peer produces a `cites` edge (`to` = the queried +peer) and a `cited` edge (`to` = itself) in the **same page-position bucket**, +tied on `From` and `Role`, differing on `To`. Rust's fixture `peer` role and a +C# `[CultReference(typeof(Self), many: true)]` both express it. Reversing the +`to.recordKey` comparison is killed **only** by Soul's probe, so the branch is +live and decides real output. **A self-referencing role is a parent or peer +link — ordinary.** + +Both runtimes agree today only because the comparator text is duplicated — +the "coincidence of source, not a rule" that SM-4 raised and R-AN was written +to close. + +### SM-8, CONFIRMED, medium. The cut's parity claim has no home. + +Section 9 says the claim is written into `docs/runtime-parity-scope.md`, "not +here alone". **That file contains zero mentions of typed selection**, and +never did — not even the earlier overstated wording. R-AS said the target +document "is reconciled to it". It is not. + +### SM-9, CONFIRMED, low. The map's byte counts are wrong; the constants are right. + +Serialized on Yggdrasil against MessagePack C# 3.1.7: `CultNetRawDocumentHeader` +is **228 bytes**, `CultNetEdge` is **246 bytes**. The committed hex in +`selection_wire_parity.rs` matches **exactly**. The landing note recorded 86 +and 99. **The thing Self asked Soul to distrust was sound; the prose beside it +was not.** + +### Promises that held + +**R-AL is complete, including inheritance.** Seven shapes built through +`Reflection.Emit` and pushed at the real registry, all refused: data name +against reference alias, reference name against reference alias, alias against +alias, data *alias* against reference *name*, implicit many-reference through +`List>`, and **across inheritance**, where the message names +both declaring types. The one shape that still registers is two *data* members +colliding with no reference present — **not a hole**, because the index +namespace is looked up by exact `IndexAlias` and never by the name fallback; +only the reference namespace uses `IndexAlias ?? MemberName`. +`PersistedMember.IsReferenceCandidate` is a character-exact mirror of +`FromMember`'s `isReference`, so D10b cannot disagree with the descriptor it +guards. Narrowing D10b dies; weakening the restored guard dies. + +**R-AM reaches the wire, not just the log.** Real loopback UDP through +LiteNetLib with the production transport: the null-`Selection` fault arrives at +the client and decodes as `CultNetErrorMessage` with the real message. +Mutating the handler to log but answer nothing dies. + +**R-AO's vector genuinely discriminates.** Under last-wins the resolved schema +stops matching the citation's declared target and the page empties, so the +vector has real power rather than merely existing. + +**R-AP's bytes are right, and more of them than claimed.** +`SelectionDocumentRecord` is byte-identical at 269 bytes, and — the one that +matters — **the whole `cultnet.snapshot_response_raw.v1` envelope is +byte-identical at 376 bytes**, Rust's encoder against C#'s message. Nothing +broke on decode. + +### Observations, not defects + +`SelectionPage` has **no C# counterpart to be byte-identical to**; byte parity +is undefined for it. The new generic catch sends raw .NET exception text to an +unauthenticated peer — **exactly what R-AM ordered, and what the siblings do**, +so consistent rather than wrong, but worth its own ruling one day. D10b is +stricter than the restored guard needs: a data member aliased `Owner` beside a +reference member named `Owner` used to register and worked, and is now +refused — defensible, but a breaking registration change with no note. + +### Soul on the wording, and Self's correction + +Soul agrees **R-AR is its own cut**. It does not agree with how I described +the residual gap, and it is right on both counts: + +- **"Nested wire-type byte parity" overstates it.** The branch proves two + types, each at exactly one value with **every optional absent**. Nothing in + the batch touches a header with `tags` populated or an edge with a + `payload` — precisely where `string[]` versus `Vec` and `byte[]` + versus `serde_bytes` could diverge. The correct words are **"byte parity for + `RawDocumentHeader` and `Edge` at an all-optionals-absent value"**. +- **"Blocked on unbuilt page-assembly ownership" is the wrong word, and the + expensive one.** It ran two independent things together: the two *encoders* + producing identical bytes for the same page value, and the two *evaluators* + producing the same page value from the same rows. The second is what the + vectors already compare. **The first needs no ownership move at all — Soul + wrote it this afternoon and it passes at 376 bytes.** What R-AR buys is a + single test driving rows to bytes in one call rather than two halves meeting + on paper. **Calling it blocked made the cheapest available evidence look + expensive, which is how it slipped six passes while sitting there for the + taking.** + +### The rig + +`C:\Users\Meta\eureka-soul-probes\cultnet-selection-cut1-fix6\`, beside batch +5's: three C# probe classes, a Rust wire probe, the counterexample patch, +three mutation drivers, seven precomputed C# mutants, and a README carrying +the full mutation table and the two `ygg-verify.sh` rakes (now in the +script's own header, Eureka `db1c84d`). + +### What Soul could not run + +No Stryker; the C# survivor list stays untriaged. No cargo-mutants sweep — +thirteen hand-built non-revert mutations instead, all at `-j1`. +`contracts.rs` and `schema_discovery.rs` unmeasured, with batch 5's partial +`validate_*` signal still hanging. The `--since`/`GitInfoProvider` crash still +not root-caused. **Soul proved the `to` comparator branch is reachable; it did +not prove the two runtimes would disagree on it, only that nothing stops +them.** + +## Self's rulings for fix batch 7, 2026-09-23 + +- **R-AT (SM-7). Every component of both orderings dies under its own + mutation, in both runtimes** — including `to.schemaId` and `to.recordKey`, + which now have **a known construction to test against**, and Rust's row + comparator `record_key`, which SM-4 named a pass ago and batch 6 never + touched. Take Soul's counterexample from the rig rather than rebuilding it. +- **R-AU. The false equivalence argument is deleted from the map**, done + above, not amended. Standing rule reaffirmed: **an argument that a branch is + unreachable is a claim to falsify, not a reason to skip a test.** +- **R-AV (SM-8). `docs/runtime-parity-scope.md` carries the typed-selection + row**, in the corrected words. A claim whose named home does not mention it + is not recorded. +- **R-AW (SM-9). Correct the byte counts to 228 and 246.** +- **R-AX. Land the whole-message parity vector.** Soul already has it green at + 376 bytes. **This is not blocked and never was** — my wording made it look + so. Land it as a vector on both sides, and add a header with `tags` and an + edge with a `payload`, since those are the shapes where the collection and + byte-array mappings could diverge and the all-absent value proves nothing + about them. +- **R-AY. Cut 1's claim, in these words**: byte parity for the + `snapshot_response_raw.v1` envelope and its nested record types, verified at + populated and absent optional values, plus semantic parity over the named + field subset. **R-AR remains its own cut** and buys a single rows-to-bytes + path, not the claim itself. +- **D10b's strictness gets a note** in the registration error and the map: a + shape that used to register and work is now refused.