RFM receipt: cross_type_comparison_answers_instead_of_refusing gains the prescribed-remedy specimen

dag/gunbc/recurring_failure_mode/cross_type_comparison_answers_instead_of_refusing.dag

@@ -23,6 +23,7 @@ data cross_type_comparison_answers_instead_of_refusing: RecurringFailureMode = R
     "AND A CORRECTION THAT BELONGS IN THE ROW BECAUSE IT IS THIS CLASS ONE LEVEL UP (review 65553). An earlier revision of this receipt claimed the wall covers 'one value in two encodings' and not 'two different things', citing the Present specimen as a numeric-tower straddle. That is FALSE on two counts the seed settles. `.first()` returns the BARE ELEMENT -- items.front().cloned().unwrap_or(Value::Null) -- so `ys.first() == Present { value: 1 }` compares an Int against an OPTION variant, which is two different things and not Int against Nat's Zero/Succ. And the numeric arm's predicate is free_monoid_to_vec(v).is_none(), which admits ANY non-monoid variant; the 'Nat Zero/Succ' phrasing is HARDCODED in the message and is printed whatever the variant actually was.",
     "THE SHAPE OF THAT MISTAKE IS THE ROW'S OWN SUBJECT. I read the match arm correctly and quoted it, then let the DIAGNOSTIC'S PROSE tell me what the arm meant -- asserting as deduced what was inferred from a hardcoded string, which is DESIGN section 4d's first arm and is inferred from precisely the thing that cannot refuse. The Record-versus-Variant half survived the correction because it was read from the pattern; the dual-encoding half did not because it was read from the message.",
     "REVIEW TELL, for the form a reader can catch without the wall: a comparison where exactly ONE side is unwrapped -- `x == 42` or `x == y` where only y passes through an accessor like byte_size_count or measure_count. One-sided unwrapping is where a derived quantity escaped its type. The adjacent authoring rule that produces this class: a TRANSCRIBED upstream value keeps the source's type, while a quantity DERIVED from it -- a difference of two offsets, a product of elements and width -- is this repository's to type, and leaving it bare is what forces the unwrapping in the first place.",
+    "RECEIPT THREE, CI run 37728157032 on gunbc#13573 head 2ad332de09, isolated by probe run BuildBuddy invocation b5ff3a8c-1be3-4009-85c1-04f6ed5038c4 (completed 2026-10-08T07:25:52Z, instrument claim_batch --claim-run, subject test.claim.os_install_tiebreak_probe, on tree a39504add10d9212da0a33541083630ffc0f12c1 whose gunbc.os_install_actuator_selection.dag is byte-identical to origin/main 2ef4b296d8): THE CHECKER'S OWN PRESCRIBED REMEDY FOR THIS CLASS EXECUTES FALSE AT RUNTIME. The #13179 refusal text says `==` compares an optional value with a required one and tells the author to `compare against Present { value: .. }`. That prescribed spelling -- `xs.first() == Present { value: v }` -- compiles clean and adjudicates Bool(false) on a list whose head IS v: run 37728157032 adjudicated exactly two claims Bool(false) cause=claim_failed under it (os_install_actuator_requirements_dispatch_through_kind_rows, srv3_actuator_host_selected_because_requirements_and_policy), and both were re-verified true facts. The probe run isolates the asymmetry on one tree with one operand set: `match order.first() { Present { value: host } => host == operator_host_srv1 ... }` PASSES (the spelling #13547 landed in the declaring module is sound), whole-list equality PASSES, and the equality-against-constructed-Present form FAILS. So the executing runtime lifts the bare element when MATCHING against a Present pattern and does NOT lift it for == against a constructed Optional variant. The harm is this row's inverted-visibility shape with an aggravation: an author who follows the diagnostic's remedy writes an assertion that can never be true (silent wrongness) and, in a guard, a wall that never fires -- the compiler's own message is the citation that steers them there, which is the citation-attests-a-decision-rule class applied to the checker's diagnostic prose. THE DISTINGUISHING FACT a reader can use without a wall: any == whose right side is a CONSTRUCTED variant of the left side's Optional type is suspect on this runtime, while a match against the same pattern is not; the surgical spelling for head-or-element checks is the match, not the equality.",
   ],
 
   evidence: [],