recurring_failure_mode: roster two reds standing on main under the grandfathered roster

dag/gunbc/recurring_failure_mode/a_designed_narrowing_stops_inhabiting_the_subject_it_narrowed.dag

@@ -36,6 +36,7 @@ data a_designed_narrowing_stops_inhabiting_the_subject_it_narrowed: RecurringFai
     "NEXT-RUNG TRIGGER, NAMING THE CAPABILITY: a claim may DECLARE the constraint or axis its verdict is expected to turn on, and the selection path reports WHICH constraint actually excluded each candidate, so a fixture whose field is emptied by an undeclared constraint refuses. That is not satisfied by a richer refusal string, and it is not satisfied by the exclusion identities the spine already carries -- it needs the claim side to state its expected mechanism, which nothing in the witness vocabulary can express today. SUFFICIENT FOR: a narrowed field that stops inhabiting a newly tightened constraint reds at the claim rather than passing for a new reason.",
 
     "WHY IT RANKS: the artifact it corrupts is a deliberately narrowed fixture, which is exactly the artifact a cost ruling produces. So the class is CREATED BY GOOD PRACTICE -- every claim split to clear a ceiling mints a new instance -- and it compounds with the cost pressure that motivated the narrowing, because the cheaper a field is the more it has been hand-chosen and the more premises it has frozen. STATED PLAINLY BECAUSE IT IS UNCOMFORTABLE: this programme spent the two days before the specimen narrowing claims under an operator ruling to break them below a cost ceiling, so it was MANUFACTURING instances of this class throughout, and the specimen is one of its own products rather than an accident that wandered in. Every narrowing landed in that campaign is a candidate instance, and none of them was re-checked against a constraint population that has since moved.",
+    "SPECIMEN, A HAND-BUILT TREE THAT STOPPED BEING A TREE THE PRODUCER EMITS (clever-raven-680, 2026-10-05). `v2.test.claim_pipeline.resolve` `spine_resolve_accepts_normalized_tree` hands `normalize` a hand-built module root: a Conj with one labelled declaration whose target is an empty Conj. The claim exists to show that resolve accepts a normalized tree, but resolve is never reached. `normalize` refuses with `body_lowering_reason_unrecognised_lowered_shape`, measured by claim_batch on BuildBuddy against origin/main, with probe claims comparing the fatal reason against every reason symbol in src/v2/compiler and src/v2/std; exactly one matched. That refusal came from gunbc#12862 (MQ-5 flip), which made body lowering refuse a shape it does not recognise instead of reading it again as raw parse. That change was right, and the fixture is the input it now correctly refuses. The claim was red on main with no reason rostered. It is listed in `v2.workflow.floor_grandfathered_roster`, but that roster only selects an eval budget, so why the required lane did not expose the red is NOT established. The negative sibling `spine_resolve_rejects_noncanonical_root_atom` does not call normalize: it admits its tree through `admit_normalized_tree` and calls resolve, so its pass shows that resolve was reached and refused. It accepts ANY resolve rejection, though, so which wall fired is not pinned and was not measured here. NEXT TRIGGER: supply a tree the real producer emits (normalize over parsed source, or an admitted tree that body lowering recognises), keep one inhabitance claim that the route reaches resolve, and make the noncanonical-atom claim assert the resolve refusal reason it exists for. Not repaired here.",
   ],
 
   evidence: [],

dag/gunbc/recurring_failure_mode/a_quoted_key_record_literal_refusal_left_body_lowering_unrostered.dag

@@ -0,0 +1,16 @@
+module gunbc.recurring_failure_mode.a_quoted_key_record_literal_refusal_left_body_lowering_unrostered
+
+import std.types { NonEmptyStr }
+import gunbc.recurring_failure_mode { RecurringFailureMode }
+
+data a_quoted_key_record_literal_refusal_left_body_lowering_unrostered: RecurringFailureMode = RecurringFailureMode {
+  identity: "a_quoted_key_record_literal_refusal_left_body_lowering_unrostered" as NonEmptyStr,
+
+  receipts: [
+    "**A headless brace with a quoted key, under a non-map annotation, is no longer refused at body lowering** (`data ar_k: Bool = { \"n\": true }`). `v2.test.claim.body_lowering.anonymous_record` `ar_a_quoted_key_is_not_a_record_field_holds` expects `normalize` to refuse at the item with `body_lowering_reason_field_init_unlowered`, so that the quoted key is never read as field `n`. On origin/main, 2026-10-05, `normalize` ACCEPTS the subject (claim_batch on BuildBuddy, clever-raven-680; a probe claim over the same `ar_key_quoted_subject().normalized` returned Accepted). The sibling `ar_a_quoted_key_takes_the_string_key_production_holds` passes, so the parse still takes the string-key production. The claim was red on main. It is listed in `v2.workflow.floor_grandfathered_roster`, but that roster only selects an eval budget, so why the required lane did not expose the red is NOT established.",
+    "NOT ESTABLISHED: whether a later stage refuses the subject. The map-literal arm of resolve (`v2.compiler.resolve` `resolve_elided_construct_walk`, docs/plans/map-literal-introduction-design.md) refuses a headless brace whose expected head is not a Map, so the refusal may have moved from body lowering to resolve. In that case the claim keys a stage the compiler no longer refuses at, which is a stale expectation and not a fail-open. If no later stage refuses, the source is accepted with a quoted key standing where a record field was expected: silent wrongness, below the floor.",
+    "RUNG: unknown until the above is measured. NEXT TRIGGER: one run of the subject through resolve and infer that records which stage refuses and with what reason. Then the claim either asserts that refusal at that stage, or the body-lowering refusal is restored. Not repaired here.",
+  ],
+
+  evidence: [],
+}