Pkg11c: lower variant and record fields into declared field identities on the native route, and bind match-arm binders

dag/gunbc/recurring_failure_mode/call_expression_erased_at_v2_body_lowering.dag

@@ -27,6 +27,8 @@ data call_expression_erased_at_v2_body_lowering: RecurringFailureMode = Recurrin
 
     "CONSUMER-SIDE RECEIPT AND A SECOND SHAPE, 2026-09-13 (deep-newt-301, dispatched on `fold_shape_visible_to_no_lens`). The same route (tokenize, parse_module, normalize) was dumped for fold-family calls, which this class also erases, and for a body that is a `let` followed by a call. `{ fold(xs, init: 0, f: step) }` and `{ g(xs, init: 0, f: step) }` both become `Transform [ Atom dag_token_lbrace, Atom dag_token_int_literal, Atom step ]`: the named-argument VALUES survive as positional operands with their labels and the callee and positional `xs` dropped, which refines the earlier receipt's `a second named argument adds one node` -- what is kept is the value atom of each named argument, not the argument. The let form is a DIFFERENT erasure shape under the same class: `{ let seed = 0 \n fold(xs, init: seed, f: fn(acc, x) { .. }) }` lowers to a Bind whose body is a bare left/right sequence spine with `fold` as its leftmost atom and every right projection an empty Conj -- here the callee SURVIVES and the arguments, including an fn literal, do not, with the production shells stripped. So the two shapes lose complementary halves and neither carries a call. THE CONSUMER THIS SILENCES beyond resolve: `v2.lens.complexity_accumulator_copy.analyze`, a required root lens at the compile door, enumerates fold sites by seam Loop or by surface fold call, and both are produced only where fold_lowering runs BEFORE this erasure -- the sole-body position. A planted quadratic after a let, in a match arm or in an if branch is Accepted with no finding, in every step spelling; enrolled RED at `gunbc.explicit_witness_admission` as `let_prefixed_fold_copy_is_caught`, `match_arm_fold_copy_is_caught` and `declared_named_step_fold_copy_is_caught` in `src/v2/test/claim/long/accumulator_copy_fold_analysis_test.dag`, each dissolving on this row's trigger. The trigger's clause (iii) gains a shape: the controls must cover the let-prefixed body, whose loss is the argument half rather than the callee half.",
 
+    "THE ARGUMENT HALF, READ WHOLE FOR THE PLAIN SHAPES (2026-09-22, gunbc#12033), AND THE TRIGGER IS STILL NOT FIRED. Chain re-derivation of `{ step(a: x) }` -> Transform(step) found the earliest unjustified boundary one link above the operand readers: v2.compiler.body_lowering_fold body_lower_call_args_from_capture received the comma list INSIDE the parens and ran body_lower_param_list_comma_spine_optional over it, a walk shaped for a capture that still carries its `(` -- on a bare comma list its skip-the-paren step skipped the FIRST ITEM, so `f(x)` kept no argument and `f(x, y)` kept y. The list is now read as the dag_grammar_comma_list_expr it is (body_lower_comma_list_items_optional, the one reader field declarations, field patterns and field initializers share) and each `arg` value goes through body_lower_value_lowered, the body walker's own entry, so `f(h(x))` carries Transform(h, x) rather than the callee atom h. Two adjacent readers were repaired on the same walk because they rebuilt an int literal without its magnitude child (body_lower_operand_ref_optional and body_lower_pattern_leaf_atom_optional's branded-atom arm), and the deep literal probe at the head of body_lower_primary_expr, which answered `f(1)`, `A(1)` and `R { v: 1 }` with the literal 1, is now shallow. MEASURED on the seed-run normalize route: `{ f(x) }` -> Transform(f, x); `{ f(x, y) }` -> Transform(f, x, y); `{ f(h(x)) }` -> Transform(f, Transform(h, x)); `{ f(1) }` -> Transform(f, 1 with magnitude); `{ A(x) }` -> Transform(A, x). WHAT IS CARRIED AND COUNTED, NOT LOWERED: a value the reader cannot lower -- a function value (`c => ..`, `fn(..) {..}`) outside a fold-family call is the named case -- is carried as its shell under the located advisory body_lowering_reason_value_carried_unlowered (v2.workflow.compile_door_cause_ownership, head grain), so the mention survives and the population is a count rather than a silence. STILL WRONG AND UNCHANGED, stated so the row is not read one rung high: a call whose argument list contains an infix (`f(x, x + 1)`) or three or more items with an operator anywhere inside is still claimed by the deep infix search of the body walker BEFORE the call arm is reached (`{ f(x, x + 1) }` -> Transform(plus, ..); `{ f(h(x), x + 1, a: 1) }` -> Transform(comma, comma, a)), the let-prefixed shape and the method-on-a-value shape are as the receipts above state, no native execution of an argument-dependent result is delivered here, and no resolve-stage refusal for an undeclared callee is claimed. The row stays open at its stated rung.",
+
     "PARTIAL REPAIR OF ONE SHAPE, AND THE TRIGGER IS NOT FIRED BY IT (2026-09-19, gunbc#11683, superseding gunbc#11612). A call whose CALLEE is a dotted chain -- `wall.peer.peer_leaf()`, in an expression body or a brace body -- previously lowered to the chain's FIRST ATOM with the remaining segments and the call itself dropped, so it lost both halves at once; the bare value chain `= wall.peer.peer_leaf` lost the same way even after gunbc#11582 built the spine, because the bottom-up reduce built the spine and the expression-body readers then decomposed it to its first atom, the spine not being recognised as lowered substrate. v2.compiler.body_lowering_fold body_lower_dotted_chain_lowered_optional now reads both shapes off one walk (DottedChainTailRead) at the three expression sites ABOVE the first-atom fallback, and body_lower_is_core_substrate admits the spine; a call on a non-final segment (`a.f().b`) is named by the walk and declined to the existing arms (see the next sentence). Measured on the normalize route before the repair: `{ x.step(a: 1) }` reached the arrow body as `x` and `= x.field` as `x`, so the receiver-method reading and the field-access refusal of body_lower_try_postfix_projection were never reached on that route and nothing that executes is retired by lowering the bare chains and the final-segment calls to the one spine; what the head denotes is the resolver's to decide. Executed evidence: v2.test.claim.body_lowering_qualified_path, whose subject is LOWERING and whose inputs are therefore SUPPLIED AT THAT BOUNDARY (DESIGN section 3; review 68361 on gunbc#11683). Four reds that fail on main before this repair -- bare value, final-segment call, block-body call and the LOCAL-RECEIVER call -- hand parser-shaped nodes the module constructs to body_lower_dotted_chain_lowered_optional and to the expression-body and brace-body sites that consult it, beside the bare-local control that stays an atom and body_lowering_first_atom_fallback_would_truncate_the_chain, which establishes that the fallback those sites sit above answers the head atom for the same input. The DESIGN section 3 pairing is discharged by exactly two route claims that execute the real stages: body_lowering_real_parser_emits_the_supplied_dotted_shape feeds the real parser's own postfix node to the same door, and body_lowering_qualified_value_reaches_arrow_body_whole runs tokenize-parse-normalize end to end and reads the real arrow body, so deleting either integration reddens a control. A CALL ON A NON-FINAL SEGMENT (`a.f().b`, the method-on-a-value shape) IS NAMED BY THE WALK AND DECLINED, STILL ERASED: it is live idiom -- v2.workflow.floor_diff_observe floor_env_optional, v2.workflow.floor_terminal_ledger_wire ledger_wire_field_at, v2.test.claim.cargo_build_run_argv_witness, v2.lens.schedule_lens (review 68280 on gunbc#11683) -- so refusing it would have turned normalize of those modules red; it is pinned as a today-row (body_lowering_call_before_end_is_erased_today_holds, the head atom the expression-body site still answers) beside body_lowering_call_before_end_is_named_and_declined, which reads the DECLINED verdict by name so a reader that simply stopped recognising the shape cannot satisfy the row. THE ARGUMENT HALF, MEASURED ON THE SAME ROUTE AND UNTOUCHED: a plain `{ step(a: x) }` reaches the arrow body as Transform(step) with the named argument dropped, `{ step(x, 1) }` as the bare literal `1`, and `{ x.step(a: 1) }` after this change as Transform(spine x.step) with no argument -- the callee half is repaired for the dotted shapes and the argument half stays as this row states it. WHAT THIS DOES NOT DISCHARGE, stated so the row is not read one rung high: this row's trigger names the whole call-expression population and demands argument-dependent NATIVE execution, a resolve-stage refusal for an undeclared callee, and controls that discriminate ARGUMENT-subtree loss. None of those is delivered here, the argument subtrees of other call shapes are untouched, and the row stays open at its stated rung.",
   ],
 

dag/gunbc/recurring_failure_mode/type_decl_field_decl_block_not_named_at_graft.dag

@@ -18,6 +18,8 @@ data type_decl_field_decl_block_not_named_at_graft: RecurringFailureMode = Recur
     "RUNG FOUND AT: 1, mitigatable -- residual reconstruct contains the drop; the invalid Named-absence is still writable. CEILING: 3 once body_lower_type_decl is the Named home for field_decl_block type_decl, so graft need not skip.",
 
     "NEXT-RUNG TRIGGER: body_lower_type_decl rehomes a field_decl_block type_decl onto a Named containment edge (the capability tracked as gunbc#11582), and namespace_graft_type_decl_named_edge no longer returns Absent on that production. Nothing smaller retires this row: landing 11582 without that rehome, or deleting the skip without the lowering, is not the climb. Closing only the record spelling while fielded variants still skip is not the climb.",
+
+    "CLIMBED 2026-09-22 (gunbc#12033), BY THE TRIGGER AS STATED AND FOR BOTH SPELLINGS. v2.compiler.body_lowering_fold body_lower_record_type_decl rehomes `type R { f: T }` onto Conj { R: payload } -- the same rehome the where-alias takes -- with the payload's Named edges the declared fields (v2.std.node_query DeclaredField); body_lower_type_variant lowers a fielded variant, braced or positional, to a declared variant that v2.std.compilers.sugar joins into the Disj with every arm's payload declared; namespace_graft_type_decl_is_fielded is DELETED and namespace_graft_type_decl_named_edge names every type_decl unit. The three enrolled rows flipped as this row said they would and did not retire: declaration_graft_coproduct_beside_record_names_both, declaration_graft_record_type_only_accepts_and_is_named (Rec Named, and the field n present under it) and declaration_graft_record_construct_accepts, all asserting Named on an Accepted assemble through the real path. Fielded variants, which this row said no witness asserted Named for, are asserted by v2.test.parse.variant_field_lowering over the declared payload. RUNG NOW: 3 for this class's subject -- an Accepted normalized tree carries no residual fielded shell, because a field block that does not lower is body lowering's typed refusal (body_lowering_reason_field_decl_unlowered) and the residual arm is gone. Declared and not claimed: generic parameters and the type-decl modifiers are not carried by the rehome, as they are not by the where-alias rehome beside it.",
   ],
 
   evidence: [],

dag/gunbc/rung_drop/roster.dag

@@ -94,6 +94,7 @@ import gunbc.rung_drop.type_reference_location_fallback_keys_production_realizat
 import gunbc.rung_drop.persisted_resolved_graph_disk_probe_unqualified_format { persisted_resolved_graph_disk_probe_unqualified_format }
 import gunbc.rung_drop.self_host_emit_derisk_claim_unobserved { self_host_emit_derisk_claim_unobserved }
 import gunbc.rung_drop.g0_type_decl_modifier_parse_without_sealing_property { g0_type_decl_modifier_parse_without_sealing_property }
+import gunbc.rung_drop.variant_fields_unlowered_on_the_native_route { variant_fields_unlowered_on_the_native_route }
 import gunbc.rung_drop.fabric_storage_append_principal_unrefused { fabric_storage_append_principal_unrefused }
 import gunbc.rung_drop.namespace_wave_admission_wall_removed { namespace_wave_admission_wall_removed }
 import gunbc.rung_drop.systemctl_show_property_input_type_wall { systemctl_show_property_input_type_wall }
@@ -173,6 +174,7 @@ data rung_drop_roster: List<RungDrop> = [
   persisted_resolved_graph_disk_probe_unqualified_format,
   self_host_emit_derisk_claim_unobserved,
   g0_type_decl_modifier_parse_without_sealing_property,
+  variant_fields_unlowered_on_the_native_route,
   approval_store_single_writer_by_agreement,
   fabric_storage_append_principal_unrefused,
   namespace_wave_admission_wall_removed,

dag/gunbc/rung_drop/variant_fields_unlowered_on_the_native_route.dag

@@ -0,0 +1,62 @@
+module gunbc.rung_drop.variant_fields_unlowered_on_the_native_route
+
+import std.types { List, NonEmptyStr }
+import gunbc.rung_drop { Standing, RungDrop, TypedDeclaration, ReplacementStaged }
+import gunbc.guarantee_rung { Mitigatable, MechanicallyPreventable }
+
+// DECLARED 2026-09-21 (gunbc#11998, side-chat ruling via neat-boar-16). ONE frontier for record
+// and positional variant fields together, because they are one fact spelled two ways: the seed
+// lowers `A { v: T }` to a Required field `v` and `A(T)` to a Required field "0"
+// (v1.compiler.parse parse_positional_variant_type_fields), and binds pattern binders from those
+// fields. On the native route no v2 stage lowers variant fields into declared field identities
+// for either spelling: namespace_graft_type_decl_is_fielded sends every fielded declaration to
+// the residual forest and body_lower_is_structure_preserved_emitted keeps field_decl_block and
+// positional_variant_payload as preserved structure. gunbc#11998 added the positional parse row,
+// so `A(T)` now reaches that same preserved state records already had -- parity, not a new gap.
+// The match-arm lowering kept only a pattern's constructor atom, so a positional binder was
+// silently lost; that loss is now the typed refusal
+// body_lowering_reason_positional_pattern_binder_unlowered.
+
+// NOT RETIRED BY gunbc#12033. The lowering half of the replacement IS executed:
+// v2.compiler.body_lowering_fold declares the fields, the graft skip is deleted, and
+// body_lower_pattern_lowered lowers `A(x) =>`, `A { v: x } =>` and `A { v } =>` to the construct over
+// their binders, so the #11998 positional-binder refusal is retired. The resolver frame is executed
+// too: v2.compiler.resolve resolve_match_node_walk scopes those binders as the arm's lexical frame, and
+// v2.test.claim.match_arm_binder_frame holds that a binder binds. What is NOT established is the
+// capability this row's subject names: that the NATIVE ROUTE, the emitted compiler, lowers fields and
+// binds binders. Nothing has observed it there yet. When this row was declared the emitted
+// compiler did not build; it has built on main since gunbc#12089 (emit-build is green on this PR's
+// head), so what remains is the native-route RUN over the specimen and the workload, deferred until
+// gunbc#12100 lands, which repairs the compile.emit cost regression #12089 introduced.
+//
+// A HARM SENTENCE THIS ROW USED TO CARRY IS RETRACTED, AND THE RETRACTION IS RECORDED HERE. An
+// earlier revision said the binder `node` in v2.std.symbol_index symbol_index_candidates_at
+// resolved silently to the MODULE v2.std.node because resolve_pattern_node_is_constructor
+// classifies by shape. That came from review 70101's reading and was never executed. Execution
+// falsified it (nimble-boar-636, 2026-09-22, on #12033's head bbc77204a49):
+// v2.test.claim.match_arm_binder_frame mab_binder_spelling_a_sibling_module_binds_the_arm (authored on gunbc#12082), with
+// v2.std.node supplied beside that arm, holds and the binder binds. v2.compiler.symbol_index_fill
+// inserts no path for a module spine, so lexical ascent cannot reach a module, and the global-bare
+// Unbound arm refuses rather than falling back to one. The shape classifier remains a construction
+// deficit (a declared payload, a module container and a declaration parse-rest node are all Conj
+// with Named edges), and gunbc#12082 replaces it with the declaration kind the symbol index records.
+// That is construction with no behavioural delta on this corpus, so it does not retire this row.
+data variant_fields_unlowered_on_the_native_route_population: List<String> = [
+  "the emitted (native-route) compiler: variant-field lowering and match-arm binder binding are executed by the interpreted v2 stages but not yet observed on the native route (the emitted compiler builds since gunbc#12089; the native run over the specimen is deferred until gunbc#12100 fixes the compile.emit cost); specimen: the binder `node` of the `Present { value: node }` arms of v2.std.symbol_index symbol_index_candidates_at",
+]
+
+data variant_fields_unlowered_on_the_native_route: RungDrop = RungDrop {
+  identity: "variant_fields_unlowered_on_the_native_route" as NonEmptyStr,
+  subject: "native route lowers variant fields, named and positional, into declared field identities and binds pattern binders from them, the way the seed does",
+  declared: "2026-09-21",
+  standing: Standing,
+  declaration: TypedDeclaration {
+    previous: MechanicallyPreventable,
+    temporary: Mitigatable,
+    reason: ReplacementStaged {
+      replacement: "a v2 stage lowers variant fields into declared field identities (named and positional \"0\")"
+    },
+    population: variant_fields_unlowered_on_the_native_route_population,
+    restoration_trigger: "the emitted compiler builds, and on that native route the specimen is observed: the binder `node` in v2.std.symbol_index symbol_index_candidates_at binds its arm and a positional `A(x)` construction and match round-trip field \"0\". A declaration-kind classifier alone (gunbc#12082) does NOT satisfy this: it changes how the interpreted stages decide, not whether the native route is observed."
+  }
+}