Preserve call callee and arguments through v2 body lowering

dag/gunbc/recurring_failure_mode/call_expression_erased_at_v2_body_lowering.dag

@@ -9,19 +9,21 @@ data call_expression_erased_at_v2_body_lowering: RecurringFailureMode = Recurrin
   receipts: [
     "**a call expression is erased by v2 normalize before resolve runs, so every reference it carries -- callee and arguments -- is invisible to name resolution and the refusal a missing declaration should raise has nothing to fire on** (INVALID STATE: v2.compiler.normalize, via v2.compiler.body_lowering_fold, lowers a function body that is a call into a Transform node whose only child is the `dag_token_lbrace` atom. The callee identity and every argument subtree are dropped. The module then passes normalize and resolve Accepted, with no diagnostic of any severity).",
 
-    "HARM. v2 name resolution fails OPEN for the whole call-expression population, declared and undeclared alike. A call to a name no declaration provides is Accepted. The namespace cut's census rests on a delete-first premise, that removing an authority makes every real dependent REFUSE LOUDLY, and that premise is void for every dependent reached through a call. For the observed call shapes, erasure prevents the missing-callee resolution refusal from firing. Consequently a refusal roster cannot establish completeness of affected call dependents from absence of refusals. The affected population has not been established by these receipts. Native census mode separately performs no resolution and therefore cannot establish binding-refusal completeness. A native run with no passing call-bearing identities does not by itself identify lowering as the cause of every refused identity.",
+    "HARM. v2 name resolution failed OPEN for the whole call-expression population while lowering dropped the call: a name no declaration provides was Accepted. The namespace cut's census rests on a delete-first premise, that removing an authority makes every real dependent REFUSE LOUDLY, and that premise is void for every dependent reached through an erased call. Native census mode still performs no resolution and cannot establish binding-refusal completeness. A native run with no passing call-bearing identities does not by itself identify lowering as the cause of every refused identity.",
 
-    "DISTINGUISHING FACTS, because two neighbouring rows look like this one and are not. `unresolved_callee_conflated_with_dispatched_elsewhere` is the v1 ExprCall-tail class: there the callee reaches the classifier and the miss is absorbed later. Here the callee never reaches resolve at all. And the earlier dated measurements (v2.test.claim.staged_front_end unbound_symbol_reason_note, v2.test.claim.dag_acceptance frontier_arm_note) attributed the silence to resolve. That was the wrong stage: resolve is correct over the tree it receives, and the tree has already lost the call. A wall authored in resolve would therefore be a decoration (DESIGN section 4b), because the undeclared-callee RED and the declared-callee positive control arrive as identical trees.",
+    "DISTINGUISHING FACTS, because two neighbouring rows look like this one and are not. `unresolved_callee_conflated_with_dispatched_elsewhere` is the v1 ExprCall-tail class: there the callee reaches the classifier and the miss is absorbed later. AT FILING (2026-09-12 interpreter dumps), the v2 callee never reached resolve at all: the earlier dated measurements (v2.test.claim.dag_acceptance frontier_arm_note, and a since-deleted staged_front_end commentary row) attributed the silence to resolve, which was the wrong stage — resolve is correct over the tree it receives, and that tree had already lost the call, so a resolve-side wall would have been a decoration because the undeclared-callee RED and the declared-callee positive control arrived as identical trees. THIS HEAD enrolls a discriminating RED on unprepared parse_module → body_lower_try_postfix_projection (not prepare_grammar, not normalize): body_lowering_projection_lowers_to_transform requires callee step at arity 2. Undeclared-callee resolve is still unshown on staged_front_end_unbound_value_name_refuses_with_its_own_reason. Native remains unshown.",
 
     "RECEIPT (2026-09-12, still-eagle-447, NAMESPACE XL-2 scoping). The normalized tree was dumped for five bodies via prepare_grammar, parse_module_prepared and normalize -- the calls v2.compiler.program_assembly program_assembly_read_to_normalized_root_prepared makes, and so the census route's own hand-off (v2.compiler.compile native_test_context_from_ingest). `{ k }` keeps `Atom:k`. `{ x }` over a parameter keeps `Atom:x`. `{ g(x: 1) }` with g declared, `{ zzz(x: 1) }` and `{ zzz(1) }` with zzz undeclared all become `Transform [ Atom:dag_token_lbrace ]`. The unprepared parse_module route (v2.compiler.staged_front_end run_front_end) dumps identically, so this is not a second lossy route beside a faithful one.",
 
     "EVIDENCE LEVEL, stated so the receipt is not read one rung high. The dumps ran the v2 .dag through the gunbc interpreter at main f9d37e43a1, and a structural node-count fold (not a printer) agrees: the parse tree grows with a call's arguments and nesting, while the normalized body of { g(x: 1) } is exactly one node larger than { k } -- the Transform and its lbrace atom -- and { g(x: h(y: 5)) } is no larger than that. A second named argument adds one node, so the lowering keeps something per extra argument, but none of the callee or argument content. That the natively emitted normalize behaves identically is not executed. The native route gives no contrary evidence: its receipt on the #10940 head (eager-raven-113, 2026-09-12) holds exactly one Passed identity, a literal-bodied smoke test, and every richer body refuses before or at eval (v2.compiler.infer node_grounding_frontier_note). So no route has been observed to lower a call faithfully.",
 
-    "RUNG FOUND AT: outside the ladder -- silent wrongness. The compiler Accepts a program with an undeclared callee and reports nothing.",
+    "RUNG FOUND AT: the minimum across in-scope paths (DESIGN section 4b). Unprepared parse_module → body_lower_try_postfix_projection is mechanically preventable — v2.test.manual.body_lowering_projection_call body_lowering_projection_lowers_to_transform requires callee `step` at arity 2, which is RED under Transform[Atom:dag_token_lbrace]. Interpreter prepared (prepare_grammar / parse_module_prepared), source→normalize (body_lowering_normalize_accepts_projection_module still only asserts Accepted), and native argument-dependent execution are unshown. The class rung is therefore the silent paths: outside the ladder until those land.",
 
     "CEILING: structurally guaranteed. Whether a name is bound in the containment index is decidable, and v2 resolve already refuses an unbound VALUE name with `resolve_reason_unbound_symbol`. The missing piece is not an authority but the lowering preserving what resolve needs.",
 
-    "NEXT-RUNG TRIGGER, naming the capability: v2 body lowering PRESERVES every call expression's callee and argument subtrees into the normalized tree on every v2 route that feeds resolve, so that resolve receives the callee as a reference. The climb's evidence is executed, and resolution alone does not discharge it. The repair that fires this trigger must show, by execution: (i) a call with a DECLARED callee executes through the native route and returns the expected ARGUMENT-DEPENDENT result, so that the argument subtree is demonstrably carried and consumed rather than merely present; (ii) a call with an UNDECLARED callee refuses at RESOLVE with a typed, located missing-binding cause -- at resolve, not later at grounding, emission or eval, since a refusal arriving downstream is consistent with the callee never having reached resolve at all; (iii) controls that discriminate ARGUMENT-subtree loss specifically, over the additional-argument and nested-call shapes named above, such that restoring the erasure makes those regression assertions FAIL rather than leaving them green. An invalid specimen that is Accepted is a FAILING must-refuse assertion, not evidence of anything. The prepared and unprepared routes and the native realization are distinct evidence paths and one passing route does not stand in for the others. A resolve-side check, a census count, or a migration of known call sites does not fire this trigger, because none of them makes the call reach resolve. These are requirements on the repair's evidence, not executions owed before this row lands.",
+    "PARTIAL CLIMB (2026-09-14, #11322). The compiler applies calls as Transform with callee at position 0. Discriminating enrolled control is only unprepared parse_module → body_lower_try_postfix_projection (body_lowering_projection_lowers_to_transform: helper.step(a, b) keeps callee step at arity 2). body_lowering_normalize_accepts_projection_module still only asserts normalize Accepted. Prepared ingest and arm (i) are not delivered.",
+
+    "NEXT-RUNG TRIGGER, naming the residual capability: a discriminating RED on prepare_grammar / parse_module_prepared and on normalize (not merely Accepted), AND a call with a DECLARED callee executes through the NATIVE route and returns the expected ARGUMENT-DEPENDENT result. Unprepared postfix-lowering does not stand in for those paths.",
 
     "CENSUS CONSEQUENCE, recorded because the cut consumes it: the whole-tree native census (the emitted closure binary's census mode) runs only tokenize, parse and normalize per file and never calls resolve, so its roster carries front-end refusals only. Restoring call lowering does not by itself add resolve refusals to that census. That needs the census mode to resolve per module as well.",
   ],

dag/gunbc/recurring_failure_mode/lowering_accessor_collapses_a_sequence_operand.dag

@@ -8,10 +8,10 @@ data lowering_accessor_collapses_a_sequence_operand: RecurringFailureMode = Recu
 
   receipts: [
     "a lowering accessor that silently narrows a MULTI-ELEMENT operand to its first element: the caller asks what an argument is and receives a proper part of it, with no refusal and nothing counted, so every consumer downstream reasons about a subset of the program the source actually wrote (DESIGN section 5 -- a failure arm must refuse, never widen)",
-    "SPECIMEN AND SYMBOL, 2026-09-12. `v2.compiler.body_lowering_fold` `body_lower_operand_ref_optional`, reached from `body_lower_named_arg_value_optional` via `body_lower_arg_operand_optional`: on a node that is a sugar sequence pair it recurses into `pair.left` ALONE. For the argument `left: seed + acc` it returns the operand for `seed` and drops `acc` entirely. The narrowing is unconditional and unreported -- no diagnostic, no counter, no typed arm distinguishing `this is the whole operand` from `this is the first of several`.",
+    "SPECIMEN AND SYMBOL, 2026-09-12. `v2.compiler.body_lowering_fold` `body_lower_operand_ref_optional`, then reached from `body_lower_named_arg_value_optional` via a since-deleted named-arg operand peel: on a node that is a sugar sequence pair it recurses into `pair.left` ALONE. For the argument `left: seed + acc` it returns the operand for `seed` and drops `acc` entirely. The narrowing is unconditional and unreported -- no diagnostic, no counter, no typed arm distinguishing `this is the whole operand` from `this is the first of several`. INTERPRETER UPDATE (2026-09-14, #11322): that peel is gone. Named-arg value now routes colon-right through `body_lower_arg_operand_local_optional` → `body_lower_arg_expr_optional` → `body_lower_try_body_lowered`, so an infix operand lowers via `lower_binary_infix` rather than `pair.left` alone. `body_lower_operand_ref_optional` itself still recurses `pair.left` (fallback when try_body_lowered is Absent; also `v2.lens.complexity_accumulator_copy.analyze` `projection_receiver_port_reading`).",
     "HOW IT SURFACED, WHICH IS THE PART WORTH KEEPING: not in the compiler, but in a CONSUMER that happened to need the whole answer. The accumulator-copy lens censuses the identifiers an argument mentions. Its first repair reached the same shape by a different route (a first-match DFS for the argument's first `^dag_surface_primary_expr`) and inherited the identical narrowing, which review 64393 caught: `left: seed + acc` censused as `[seed]`, one identifier, so a `BindsFresh` `seed` resolved the port to `PortPureLiteral` and a COPIED ACCUMULATOR CLASSIFIED CLEAN with the carrier invisible. Two independent implementations of `the argument's value` converged on the same wrong answer, which is the evidence that the defect is in the shared fact rather than in either caller.",
     "WHY NO EXISTING WITNESS HELD IT, stated as a property of the corpus: every fixture in the accumulator-copy suite used a single-identifier or single-call argument, where narrowing to the first element and returning the whole operand agree. The class is only observable at arity two or more on one port, and nothing in the suite wrote that until the review asked for it. A collapse that is invisible on every fixture in the suite is not a tail case -- it is an unexercised axis.",
-    "RUNG FOUND AT: below the floor, because the loss is SILENT -- `values inhabit declared types` and `applications bind in exact bijection` are floor sentences, and an operand silently replaced by a proper part of itself is neither refused nor recorded. CEILING: structurally guaranteed, and reachable -- the operand carrier cannot be narrowed without a typed refusal once the accessor returns a shape that can represent a multi-element operand, at which point dropping an element has no constructor. NEXT-RUNG TRIGGER, NAMING THE CAPABILITY: `body_lower_named_arg_value_optional` preserves the full sequence an argument names, so a caller asking for an argument's value receives all of it or a located refusal -- not its first element. A diagnostic variant, a counter, or a second accessor beside it retires nothing; the narrowing itself must become unwritable. When it lands, `v2.lens.complexity_accumulator_copy.analyze` `arg_value_node` dissolves into that accessor and its stated-divergence annotation deletes with it.",
+    "RUNG FOUND AT: the minimum across in-scope paths (DESIGN section 4b). Named-arg value (`body_lower_named_arg_value_optional`) is no longer the 2026-09-12 silent pair.left drop: that path now body-lowers the colon-right expression. Call-argument collection no longer silently drops a later argument via `body_lower_arg_comma_split_left_ok` (deleted; rest comes from the grammar repeat collector) and no longer drops a punctuation-atom operand into an empty arg list (`body_lower_call_value_optional` refuses with `body_lowering_reason_unsupported_form`). `body_lower_operand_ref_optional` still silently recurses `pair.left`, so the class rung remains that path: below the floor. CEILING: structurally guaranteed, and reachable -- the operand carrier cannot be narrowed without a typed refusal once the accessor returns a shape that can represent a multi-element operand, at which point dropping an element has no constructor. PARTIAL CLIMB (2026-09-14, #11322): the named-arg value route uses `body_lower_arg_operand_local_optional`, not the deleted peel. NEXT-RUNG TRIGGER, NAMING THE CAPABILITY: `body_lower_operand_ref_optional` preserves the full sequence a caller hands it, or refuses, so dropping `pair.right` is unwritable; AND `v2.lens.complexity_accumulator_copy.analyze` `arg_value_node` dissolves into `body_lower_named_arg_value_optional` so the stated-divergence annotation deletes. A diagnostic variant, a counter, or a second accessor beside either retires nothing. The named-arg climb does not stand in for the operand_ref residual.",
   ],
 
   evidence: [],