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

dag/extdeps/languages/typescript/program.dag

@@ -157,8 +157,8 @@ fn ts_return(expr: TsExpr?) -> TsStmt {
   Return { expr: expr }
 }
 
-fn ts_if(cond: TsExpr, then: TsStmt, else_stmt: TsStmt?) -> TsStmt {
-  If { cond: cond, then: then, else_stmt: else_stmt }
+fn ts_if(cond: TsExpr, then_stmt: TsStmt, else_stmt: TsStmt?) -> TsStmt {
+  If { cond: cond, then: then_stmt, else_stmt: else_stmt }
 }
 
 fn ts_for_of(var_name: String, iterable: TsExpr, body: TsStmt) -> TsStmt {

dag/gunbc/node_http_server_emit.dag

@@ -185,7 +185,7 @@ fn node_http_request_handler_block() -> TsStmt {
             args: [ts_ident(name: "path")]
           )
         ),
-        then: node_http_match_handler_body(),
+        then_stmt: node_http_match_handler_body(),
         else_stmt: none
       )
     ),
@@ -213,7 +213,7 @@ fn node_http_request_handler_block() -> TsStmt {
         op: ">",
         right: ts_lit_num(text: "0")
       ),
-      then: ts_block(stmts: [
+      then_stmt: ts_block(stmts: [
         ts_const(
           name: "allow",
           value: ts_call(

dag/gunbc/recurring_failure_mode/seed_admits_a_keyword_as_a_pattern_binder.dag

@@ -15,6 +15,8 @@ data seed_admits_a_keyword_as_a_pattern_binder: RecurringFailureMode = Recurring
     "CEILING AND NEXT-RUNG TRIGGER: structurally impossible once no v2 source is admitted through the seed parser alone -- the native parse is the one grammar every module must pass. The capability that retires the leniency's reach is the native route qualifying the corpus it parses, so a keyword binder refuses at a gate every PR runs rather than only in a census.",
     "SECOND SHAPE (N7-1, gunbc#13028): a fn PARAMETER spelled `loop` and then READ as a value -- `fn infer_loop_member_role(loop: Node)` with `loop.kind`, `loop: loop`, `at: loop` in its body. The v2 parser admits the declaration (`fn f(loop: Int) -> Int { 1 }` parses) and refuses every value use with parse_g0_tokens_remain, so the whole of v2.compiler.infer became a native file refusal while every seed-interpreted control stayed green. Found by bisecting the file's new items through v2.compiler.parse parse_module_prepared under the seed: exactly the three items that read `loop` refused. The same root as the pattern-binder shape -- the seed lexes a keyword as an identifier -- reached through a binding position the pattern-binder repair does not cover.",
     "THIRD SPECIMEN (the parameter shape, keyword `then`): v2.compiler.service_realization realization_require_conj declared `then: fn() -> Optional<RealizationRefusal>` and called it as `then()`; `then` is ^dag_token_kw_then. The whole module was a native file refusal (dependency/native census run 37197235156, parse_g0_tokens_remain, no locus); v2.compiler.parse_acceptance_census located it at bytes 18350..18351, the `(` after the keyword. Renaming the parameter (and its argument labels) to `proceed` is the repair: the source was invalid, as in the second shape.",
+    "FOURTH SPECIMEN, THE BINDER/REFERENCE ASYMMETRY (2026-10-03, ROOT E of the native seven): 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 admitted 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, far from the binder: src/v2/compiler/body_lowering_fold.dag `body_lower_exit_first(.., then: Node, ..)` refused at `node: then`, and src/v2/compiler/service_realization.dag `realization_require_conj(.., then: fn() ..)` at `then()` -- both inside the native seven's import closure, measured at main a0a5c62161b. A native census over dag + src/v2 (the v2.cli.compile_cli if-arm-reader-differential refused-file list, located per file by a single-file native emit) found nine such files at their first refusal, and a declaration scan found five non-contextual keyword PARAMETERS (then x3, alias, as).",
+    "REPAIR AND THE CONTEXTUAL PRECEDENT (operator ruling via the N7 manager, 2026-10-03: close the asymmetry from the BINDER side, symmetrically): every value-binder position now consumes the reference production itself (dag_grammar_primary_name_expr) behind a leading not-predicate guard that refuses any other keyword as v2.std.parse_refusal_reason KeywordAsValueName, located at the keyword (dag_grammar_value_name_before / dag_grammar_value_name_unconditional / dag_grammar_field_pattern_binder_guard). A field LABEL is not a value name and still admits a keyword. ONE declared set, dag_contextual_value_name_keywords = module, data, is read by BOTH ends, so a name is declarable exactly when it is referenceable. The criterion for that set, recorded here as the precedent for the next keyword question: a keyword may be a value name only if it heads nothing that can begin or continue an expression -- `module` and `data` head declarations only (136 parameters are named `module`); clause keywords (then, else, in, as, where) and expression heads (if, match, let, fn, loop) never qualify, because admitting them buys ambiguity for no capability. Each guard fires only where the keyword can only be a binder (a parameter before `:`, `node NAME` before `:` / `=`, a bare NAME before `=`, a field-pattern binder before `,` / `}` excluding the literal patterns true / false, `let` unconditionally), because patterns and the `node` sugar are probed ahead of statements and RefuseOnMatch stops the parse. Claims: v2.test.parse.keyword_value_name_parse (five located subjects, five probed-position controls). The keyword binders in the corpus were renamed, not admitted. RUNG, PER POSITION, STATED: the bare `NAME =` statement sugar refuses a keyword binder only as the generic parse_g0_tokens_remain, because statement alternatives dispatch by FIRST set and a not-predicate guard is transparent to it (measured: `loop = 1` refuses at the keyword, unnamed); the keyword is still never ACCEPTED there (v2.test.parse.keyword_value_name_parse kvn_bare_eq_keyword_binder_still_refuses_holds). NEXT TRIGGER, the capability: FIRST-set computation that sees through a refusal guard, at which point that form takes the named guard like the others.",
   ],
   evidence: [],
 }

dag/gunbc/roadmap/roadmap_allocation_client.dag

@@ -30,8 +30,8 @@ fn js_and(left: TsExpr, right: TsExpr) -> TsExpr { ts_binop(left: left, op: "&&"
 fn js_or(left: TsExpr, right: TsExpr) -> TsExpr { ts_binop(left: left, op: "||", right: right) }
 fn js_not(expr: TsExpr) -> TsExpr { ts_prefix(op: "!", expr: expr) }
 fn js_invoke(name: String, args: List<TsExpr>) -> TsExpr { ts_call(callee: js_id(name: name), args: args) }
-fn js_when(cond: TsExpr, stmts: List<TsStmt>) -> TsStmt { ts_if(cond: cond, then: ts_block(stmts: stmts), else_stmt: none) }
-fn js_branch(cond: TsExpr, then: List<TsStmt>, otherwise: List<TsStmt>) -> TsStmt { ts_if(cond: cond, then: ts_block(stmts: then), else_stmt: Present { value: ts_block(stmts: otherwise) }) }
+fn js_when(cond: TsExpr, stmts: List<TsStmt>) -> TsStmt { ts_if(cond: cond, then_stmt: ts_block(stmts: stmts), else_stmt: none) }
+fn js_branch(cond: TsExpr, then_arm: List<TsStmt>, otherwise: List<TsStmt>) -> TsStmt { ts_if(cond: cond, then_stmt: ts_block(stmts: then_arm), else_stmt: Present { value: ts_block(stmts: otherwise) }) }
 fn js_quiet(stmts: List<TsStmt>) -> TsStmt { ts_try(body: ts_block(stmts: stmts), catch_param: "error", handler: ts_block(stmts: [])) }
 fn js_typeof(expr: TsExpr, kind: String) -> TsExpr { js_eq(left: ts_prefix(op: "typeof ", expr: expr), right: js_lit(value: kind)) }
 
@@ -179,7 +179,7 @@ fn allocation_render_statements() -> List<TsStmt> {
         alternate: js_plus(left: ts_lit_str(value: "Stale, last observed "), right: ts_binop(left: js_field(name: "observed_at"), op: "||", right: ts_lit_str(value: "never"))))),
       js_row(term: "Lease ends", value: js_field(name: "expires_at")),
       js_do(expr: js_send(object: js_id(name: "card"), method: "append", args: [js_id(name: "title"), js_id(name: "list")])),
-      ts_if(cond: js_field(name: "connection"), then: ts_block(stmts: [
+      ts_if(cond: js_field(name: "connection"), then_stmt: ts_block(stmts: [
         ts_const(name: "code", value: js_create(tag: "code")),
         js_text(target: js_id(name: "code"), value: js_field(name: "connection")),
         js_do(expr: js_send(object: js_id(name: "card"), method: "append", args: [js_id(name: "code")])),
@@ -188,7 +188,7 @@ fn allocation_render_statements() -> List<TsStmt> {
         js_text(target: js_id(name: "waiting"), value: ts_lit_str(value: "No connection is advertised until a fresh observation shows it running.")),
         js_do(expr: js_send(object: js_id(name: "card"), method: "append", args: [js_id(name: "waiting")])),
       ]) }),
-      ts_if(cond: ts_binop(left: js_field(name: "retired_at"), op: "===", right: ts_lit_str(value: "")), then: ts_block(stmts: [
+      ts_if(cond: ts_binop(left: js_field(name: "retired_at"), op: "===", right: ts_lit_str(value: "")), then_stmt: ts_block(stmts: [
         ts_const(name: "release", value: js_create(tag: "button")),
         js_set(target: js_get(object: js_id(name: "release"), property: "type"), value: ts_lit_str(value: "button")),
         js_do(expr: js_send(object: js_id(name: "release"), method: "setAttribute", args: [ts_lit_str(value: "data-allocation-release"), ts_lit_str(value: "")])),
@@ -201,7 +201,7 @@ fn allocation_render_statements() -> List<TsStmt> {
         js_do(expr: js_send(object: js_id(name: "card"), method: "append", args: [js_id(name: "release")])),
       ]), else_stmt: none),
       ts_const(name: "prior", value: js_send(object: js_id(name: "allocationCards"), method: "get", args: [js_field(name: "id")])),
-      ts_if(cond: js_id(name: "prior"), then: ts_block(stmts: [js_do(expr: js_send(object: js_id(name: "prior"), method: "replaceWith", args: [js_id(name: "card")]))]),
+      ts_if(cond: js_id(name: "prior"), then_stmt: ts_block(stmts: [js_do(expr: js_send(object: js_id(name: "prior"), method: "replaceWith", args: [js_id(name: "card")]))]),
         else_stmt: Present { value: ts_block(stmts: [js_do(expr: js_send(object: js_id(name: "allocationList"), method: "append", args: [js_id(name: "card")]))]) }),
       js_do(expr: js_send(object: js_id(name: "allocationCards"), method: "set", args: [js_field(name: "id"), js_id(name: "card")])),
     ])),
@@ -231,7 +231,7 @@ fn allocation_flow_statements() -> List<TsStmt> {
       ts_const(name: "pending", value: js_invoke(name: "allocationPending", args: [])),
       js_when(cond: js_not(expr: js_id(name: "pending")), stmts: [ts_return(expr: none)]),
       ts_const(name: "recorded", value: js_send(object: js_id(name: "allocations"), method: "find", args: [js_fn(params: ["a"], stmts: [js_ret(expr: js_and(left: js_and(left: js_id(name: "a"), right: js_typeof(expr: js_id(name: "a"), kind: "object")), right: js_eq(left: js_get(object: js_id(name: "a"), property: "id"), right: js_get(object: js_id(name: "pending"), property: "key"))))])])),
-      js_branch(cond: js_and(left: js_id(name: "recorded"), right: js_eq(left: js_get(object: js_id(name: "recorded"), property: "profile"), right: js_get(object: js_id(name: "pending"), property: "profile"))), then: [
+      js_branch(cond: js_and(left: js_id(name: "recorded"), right: js_eq(left: js_get(object: js_id(name: "recorded"), property: "profile"), right: js_get(object: js_id(name: "pending"), property: "profile"))), then_arm: [
         js_do(expr: js_invoke(name: "allocationSettleIntent", args: [])),
         js_status(value: js_lit(value: "Your earlier request was recorded; it is shown below.")),
       ], otherwise: [
@@ -264,10 +264,10 @@ fn allocation_flow_statements() -> List<TsStmt> {
       js_status(value: js_lit(value: "Requesting release…")),
       js_do(expr: js_then(promise: js_invoke(name: "allocationFetch", args: [js_plus(left: js_item_path(id: js_id(name: "id")), right: js_lit(value: allocation_release_suffix)),
         ts_object(fields: [ts_field(key: "csrf_token", value: js_id(name: "allocationCsrf")), ts_field(key: "generation", value: js_id(name: "generation"))])]), handler: js_fn(params: ["result"], stmts: [
-        js_branch(cond: js_invoke(name: "allocationSnapshotFor", args: [js_id(name: "result"), js_id(name: "id")]), then: [
+        js_branch(cond: js_invoke(name: "allocationSnapshotFor", args: [js_id(name: "result"), js_id(name: "id")]), then_arm: [
           js_do(expr: js_invoke(name: "allocationRender", args: [js_result(property: "body")])),
           js_status(value: js_lit(value: "Release recorded; the controller retires the workspace.")),
-        ], otherwise: [js_branch(cond: js_and(left: js_result(property: "readable"), right: js_result(property: "body")), then: [js_do(expr: js_invoke(name: "allocationRefused", args: [js_result(property: "body")]))],
+        ], otherwise: [js_branch(cond: js_and(left: js_result(property: "readable"), right: js_result(property: "body")), then_arm: [js_do(expr: js_invoke(name: "allocationRefused", args: [js_result(property: "body")]))],
           otherwise: [js_status(value: js_plus(left: js_body(property: "reason"), right: js_lit(value: " Reload to see whether the release was recorded.")))])]),
       ]))),
     ])),
@@ -289,12 +289,12 @@ fn allocation_flow_statements() -> List<TsStmt> {
           ts_field(key: "profile", value: js_get(object: js_id(name: "intent"), property: "profile")),
         ])]), handler: js_fn(params: ["result"], stmts: [
         js_set(target: js_get(object: js_id(name: "allocationCreate"), property: "disabled"), value: js_not(expr: js_invoke(name: "allocationWritable", args: []))),
-        js_branch(cond: js_and(left: js_invoke(name: "allocationSnapshotFor", args: [js_id(name: "result"), js_get(object: js_id(name: "intent"), property: "key")]), right: js_eq(left: js_body(property: "profile"), right: js_get(object: js_id(name: "intent"), property: "profile"))), then: [
+        js_branch(cond: js_and(left: js_invoke(name: "allocationSnapshotFor", args: [js_id(name: "result"), js_get(object: js_id(name: "intent"), property: "key")]), right: js_eq(left: js_body(property: "profile"), right: js_get(object: js_id(name: "intent"), property: "profile"))), then_arm: [
           js_do(expr: js_invoke(name: "allocationSettleIntent", args: [])),
           js_do(expr: js_invoke(name: "allocationRender", args: [js_result(property: "body")])),
           js_status(value: js_lit(value: "Request recorded; placement and boot are reported below.")),
         ], otherwise: [js_branch(cond: js_and(left: js_and(left: js_result(property: "readable"), right: js_result(property: "body")), right: ts_binop(left: js_result(property: "status"), op: "!==", right: ts_lit_num(text: "200"))),
-          then: [js_do(expr: js_invoke(name: "allocationRefused", args: [js_result(property: "body")]))],
+          then_arm: [js_do(expr: js_invoke(name: "allocationRefused", args: [js_result(property: "body")]))],
           otherwise: [js_status(value: js_plus(left: js_or(left: js_and(left: js_result(property: "body"), right: js_body(property: "reason")), right: js_lit(value: "The answer did not name this request.")), right: js_lit(value: " Your request is kept; Request workspace repeats it.")))])]),
       ]))),
     ])),
@@ -311,7 +311,7 @@ fn allocation_live_statements() -> List<TsStmt> {
     ts_const(name: "allocationList", value: js_element(id: "allocation-list")),
     ts_const(name: "allocationCsrf", value: js_get(object: js_get(object: js_id(name: "allocationRoot"), property: "dataset"), property: "csrf")),
   ], concat(allocation_key_statements(), concat(allocation_request_statements(), concat(allocation_render_statements(), concat(allocation_flow_statements(), [
-    ts_if(cond: js_id(name: "allocationCsrf"), then: ts_block(stmts: [
+    ts_if(cond: js_id(name: "allocationCsrf"), then_stmt: ts_block(stmts: [
       js_do(expr: js_send(object: js_id(name: "allocationForm"), method: "addEventListener", args: [ts_lit_str(value: "submit"), js_id(name: "allocationSubmit")])),
       js_do(expr: js_invoke(name: "allocationLoad", args: [])),
       js_do(expr: ts_call(callee: js_id(name: "setInterval"), args: [js_id(name: "allocationPoll"), ts_lit_num(text: "5000")])),

dag/gunbc/roadmap/roadmap_belt.dag

@@ -289,8 +289,8 @@ fn belt_refusal_member_id(a: MemberAction<DispatchMember, DispatchMemberAt>) ->
   }
 }
 
-fn belt_refusal_ids(as: List<MemberAction<DispatchMember, DispatchMemberAt>>) -> List<String> {
-  as |> map(a => belt_refusal_member_id(a: a))
+fn belt_refusal_ids(actions: List<MemberAction<DispatchMember, DispatchMemberAt>>) -> List<String> {
+  actions |> map(a => belt_refusal_member_id(a: a))
 }
 
 fn belt_reconcile_json_value(
@@ -308,7 +308,7 @@ fn belt_reconcile_json_value(
     json_kv(key: "upserts", value: json_array(elements: belt_member_ids(ms: r.upserts) |> map(id => json_string(s: id)))),
     json_kv(key: "would_teardown", value: json_array(elements: belt_member_ids(ms: r.teardowns) |> map(id => json_string(s: id)))),
     json_kv(key: "refusal_count", value: json_int(n: belt_reconcile_refusal_count(r: r))),
-    json_kv(key: "refused", value: json_array(elements: belt_refusal_ids(as: r.refusals) |> map(id => json_string(s: id)))),
+    json_kv(key: "refused", value: json_array(elements: belt_refusal_ids(actions: r.refusals) |> map(id => json_string(s: id)))),
   ])
 }