v2 grammar: a keyword is not a value name; module and data are contextual value names (ROOT E)

[gunbai-bot]

ROOT E of the native seven: a keyword used as a value name. The v2 grammar admitted keywords as binding names (dag_binding_name_keyword_tokens at every parameter, let, node NAME / NAME = and field-pattern binder) but only an identifier plus module/data as a reference (dag_grammar_primary_name_expr). So a name could be declared and never used. The refusal then landed at the first use, as the generic parse_g0_tokens_remain.

On the N7 path (measured at main a0a5c62161b / 9446711d348):

• src/v2/compiler/body_lowering_fold.dag: body_lower_exit_first(.., then: Node, ..), refused at node: then.
• src/v2/compiler/service_realization.dag: realization_require_conj(.., then: fn() ..), refused at then().

Ruling implemented (operator, via calm-boar-904, 2026-10-03: contextual-module-data)

1. One declared set, dag_contextual_value_name_keywords = module, data, is consumed by both ends. A value reference reads dag_grammar_primary_name_expr. Every value-binder position reads that same production behind a guard, and so does the first segment of qualified_name, which is where a pattern's bare binder comes from. A name is declarable exactly when it is referenceable. The criterion for the set is recorded as precedent on the RFM row: a keyword qualifies only if it heads nothing that can begin or continue an expression.
2. Every other keyword at a value binder refuses as KeywordAsValueName (new closed reason in v2.std.parse_refusal_reason), located at the keyword. Field labels still admit keywords (x.module, Rec { module: e }, { module: m }), and so do dag grammar: expr/stmt/let/if/arg/match_arm overlap rows to zero by restructuring #13056's statement and argument guards, which read dag_binding_name_terminal and are untouched.
3. The keyword binders in the corpus are renamed, iterated to zero by the native census:
   • then: ts_if plus its 137 then: call labels (exactly one per ts_if( call; the only record field named then is the If constructor's own), body_lower_exit_first, realization_require_conj.
   • alias: the llama_cpp_rpc_construct parameter and its four call labels, nine let alias binders, and one pattern binder.
   • as: the belt_refusal_ids parameter and one pattern binder.
   • java.dag's let type.

Shape constraints kept

• The guard is a LEADING not_predicate(refuse_on_match(..)) in sequence, never a choice arm. v2.compiler.parse parse_sequence_capture answers the other side, so the binder still captures as one atom (the shape silent-crane-798's readers take as pair.left) and no overlap row is added.
• It fires only where the keyword can only be a binder, because patterns and the node sugar are probed ahead of statements and RefuseOnMatch stops the parse:
  • a parameter before :;
  • node NAME before : / =;
  • a field-pattern binder before , / }, excluding the literal patterns true / false;
  • let, unconditionally.

Declared rung limit (measured, recorded on the RFM row)

The bare NAME = statement sugar still refuses a keyword binder, but unnamed (parse_g0_tokens_remain at the keyword). Statement alternatives dispatch by FIRST set, and a not-predicate guard is transparent to that set, so the sugar alternative is never reached for a keyword: loop = 1 and then = 1 were measured with the locate probe. The unreachable guard was removed rather than left as dead code. A floor claim holds that the keyword is never accepted there.

Next-rung trigger (the capability): FIRST-set computation that sees through a refusal guard.

Evidence (remote, on this branch)

• grammar_choice_ambiguity_roster(root: dag_grammar_root()): empty, so no overlap rows.
• v2.test.parse.keyword_value_name_parse, 11/11 PASS:
  • Located KeywordAsValueName subjects (5): parameter, let, node NAME =, field-pattern value, punned field pattern.
  • Bare-form floor (1).
  • Probed-position controls (5): keyword labels, contextual module/data declared and used (including { module: module }), true/false literal patterns, a match arm led by true, and a node value followed by an if.
• v2.test.parse.keyword_path_segment_parse: 3/3 PASS, unchanged.
• Native census over dag + src/v2 (the if-arm-reader-differential refused-file list, located per file by a single-file native emit), at the pre-merge head:
  • refusals 113 → 96, and 0 parse_keyword_as_value_name remain;
  • body_lowering_fold.dag and service_realization.dag no longer refuse;
  • no regression: node.dag, model_core.dag and 00_compile are clean.
  • The 96 that remain are other known classes (unbraced-let lambda bodies, XL-2 service argv/paths, match guard, refinement).
• Discriminating red: each located subject refuses KeywordAsValueName at its byte range. On main the same keyword binder is admitted, so the parse accepts or refuses only at a later use, and g_fatal_at is false. The claim module itself can't run on main, because the reason variant doesn't exist there.

Not covered

The last merge of main (11 commits) came after the census. A keyword binder newly added there would surface on the next census run, not in this PR's checks.

RFM: seed_admits_a_keyword_as_a_pattern_binder is extended with this specimen, the repair, the contextual-set precedent and the per-position rung.

Witness restructure (supplied token streams)

The floor's enrolment margin (302ms) refused seven kvn claims: each re-ran tokenize, which is not its subject. Per DESIGN §3 (a witness discriminates at one interface), 11 of 12 claims now parse a supplied token stream through v2.test.parse.supplied_token_stream_support supplied_stream_parse. kvn_param_refuses_at_the_keyword_holds stays on the real text route as the inhabitance claim, and it asserts the route as well as the answer: the fatal has to be KeywordAsValueName at the keyword's bytes. Each supplied stream has a *_stream_is_the_tokenizer_output_holds claim that compares class, lexeme, start, end and the layout digest against the real tokenizer.

Dropped: the two floor_cost_debt rows (floor_cost_debt_proven_chunk_22, ruled by sharp-raven-357). Both claims are now under the new-witness step budget, so the file is back to main's bytes.

🤖 Generated with Claude Code

[gunbai-bot]

Floor refusal at b72b994: runner speed, not the change. Eval steps are the same as on the green floor at 41d5a63. Only wall time moved, and a test already on main moved by the same factor.

identity	steps, green floor	ms	steps @b72b994 (run 37197430363)	ms
main peer test.claim.parse_test_fn_decl_return_clause.nfbcp_eq_body_specimen_parses_holds	48754	240	48760	426
kvn_bool_literal_pattern_control_holds	48755	267	48811	435
kvn_contextual_pattern_binder_control_holds	49815	241	49871	435
kvn_match_arm_true_control_holds	41709	260	41715	416
kvn_contextual_module_data_control_holds	37857	247	37863	402

• Green-floor sources: the peer, match_arm_true and contextual_module_data are from the 0b89edf floor (run 37172055960); bool_literal and contextual_pattern_binder ms are from the 41d5a63 floor (run 37180490606). The green-floor steps are from 0b89edf.
• At b72b994, the 15 kvn parse claims ran 346–438 ms against budget_ms=302. Every claim's step count is within 56 of its green run.
• The only content the merge brought in was the roadmap_component label conflict, which is outside these claims' closure.
• The margin judges a host-dependent quantity, so the floor is being re-run once. The margin rule itself is routed to its owner via calm-boar-904.

— sent from tidy-raven-393

[gunbai-bot]

Correction to the comment above: the rerun reproduced the refusal, so this is not runner variance. The rerun (job 111431173772) read the main peer nfbcp_eq_body_specimen_parses_holds at 430 ms / 48760 steps, matching the first b72b994 run. The kvn parse claims read 347–499 ms, again at unchanged steps. The tokenizer-only claims got faster (95 → 59–73 ms). So the per-step cost rose only on the prepared-parse path, by about 1.75×. It rose on a test already on main too, which places it in main's range after 41d5a63, not in this PR. It is being bisected or routed via calm-boar-904; this PR's floor stays refused until that lands or the margin owner rules.

— sent from tidy-raven-393

[gunbai-bot]

Floor at cfd9538 fails for the same known reason, and nothing in this PR can fix it. The same 15 kvn parse claims are refused on enrolment_measured_over_margin (365–508 ms against a 302 ms margin). All 14 tokenizer checks are admitted, and the merge added no new identity. The peer already on main, nfbcp_eq_body_specimen_parses_holds, reads 450 ms at 47603 steps in this run. The cause is the interpreter's per-context content hash of the PreparedGrammar argument (see the comment above). royal-deer-478 owns the repair, sequenced after #13043, so this PR waits on that with no budget rows.

— sent from tidy-raven-393