A wrong cause recruits effort where a missing one merely stalls

dag/gunbc/recurring_failure_mode/declared_trigger_names_a_term_that_is_not_the_cause.dag

@@ -0,0 +1,80 @@
+module gunbc.recurring_failure_mode.declared_trigger_names_a_term_that_is_not_the_cause
+
+import std.types { NonEmptyStr }
+import gunbc.recurring_failure_mode { RecurringFailureMode }
+
+data declared_trigger_names_a_term_that_is_not_the_cause: RecurringFailureMode = RecurringFailureMode {
+  identity: "declared_trigger_names_a_term_that_is_not_the_cause" as NonEmptyStr,
+
+  receipts: [
+    "**a declared drop's trigger names a quantity that is not what the subject actually costs, so satisfying it is unreachable by honest work and reachable by the wrong move** (INVALID STATE: a row obliged by section 4b(2) to name its restoration trigger names one, and the trigger is well formed -- it states a capability, it says what that capability must be SUFFICIENT FOR, its citations resolve, and it has never been satisfied. ",
+
+    "What is false is the CAUSAL PREMISE underneath it: the term it asks to be reduced is not the term the subject is paying. ",
+
+    "**A WRONG CAUSE IS WORSE THAN A MISSING ONE, AND THE ASYMMETRY IS THE WHOLE CLASS: A MISSING TRIGGER STALLS, A WRONG ONE RECRUITS.** A row with no trigger is visibly incomplete and section 4b(2) already refuses it. ",
+
+    "A row with a confident wrong trigger reads as tracked, so someone picks it up, reduces the named quantity, watches the number not move, and concludes the trigger is simply hard -- and the drop stands with an honest-looking receipt attached and a failed attempt behind it, which is stronger evidence of difficulty than silence would have been. ",
+
+    "The class therefore CONSUMES effort in proportion to how well the row is written. ",
+
+    "MEASURED, 2026-09-07, on `gunbc.rung_drop.determinism_transitive_reachability`, whose trigger stated that the budget pressure came from THE NUMBER OF REACHABLE DECLARATIONS across ~25 lens modules. ",
+
+    "At the directory grain the trigger names, the walk reaches FEWER THAN 100 declarations -- barely more than the 78 it seeds from -- against a candidate pool of 1500-2000, and costs 10137ms against a 500ms per-claim line: about 90ms per reached declaration, against 2.9ms per reached declaration at file grain. ",
+
+    "**THE DISCRIMINATION IS THE EVIDENCE, AND IT REQUIRED TWO GRAINS RATHER THAN A BIGGER SAMPLE AT ONE.** At file grain the candidate pool EQUALS the reached set, so a cost in reached-times-pool and a cost in reached-squared make identical predictions and no amount of data at that grain separates them. ",
+
+    "Varying the grain decouples the two populations, and the models then score outright: reached-times-pool agrees within 1.9x across the two grains, reached-squared disagrees by 44x. ",
+
+    "The quadratic-in-reached premise is refuted by measurement rather than by argument: the cost is POOL-PROPORTIONAL, and the term the row named is not the term being paid. ",
+
+    "**WHICH MECHANISM PAYS THE POOL TERM IS DELIBERATELY NOT NAMED HERE, AND THE OMISSION IS THIS ROW OBEYING ITSELF.** A full scan of the candidate pool per callee lookup was the first candidate and was refuted BY EXECUTION: `decls_in_modules` is a plain-valued call with hashable arguments, so the eval-frame memo had already collapsed the repeats to one evaluation, and an index built to remove the rescan made the witness WORSE rather than faster. ",
+
+    "The FIT survives that refutation and has since been confirmed at mechanism level with the reached set pinned identical across both arms: cost tracks the pool the walk is HANDED, not what it reaches. What is unattributed is the mechanism, not the shape -- and writing a plausible unverified mechanism into this row would commit this row's own error inside the row that names it. ",
+
+    "**WHY SOURCE READING PRODUCES THIS CLASS RATHER THAN CATCHING IT.** The same walk contains three genuinely quadratic-in-reached shapes, all real, all subject to the bare-minimum-cost rule, and NONE of them is what is being paid. ",
+
+    "Reading source finds every CANDIDATE term; only a measurement in which the candidates make different predictions finds the CAUSE. ",
+
+    "**A LIVE INSTANCE OF THIS CLASS STANDS UNREMEDIATED AND IS NAMED HERE RATHER THAN ASSUMED AWAY.** `gunbc.rung_drop.determinism_transitive_reachability` carries a restoration trigger prescribing THE CALLEE LOOKUP ANSWERS BY INDEX RATHER THAN BY SCANNING THE CANDIDATE POOL, and prose attributing the cost to a rescan of the candidate pool -- the mechanism the measurement above refutes. So that trigger is satisfiable by shipping the index while the number it exists to restore does not move, which is this class exactly. ",
+
+    "**THIS ROW DOES NOT DISCHARGE IT AND DOES NOT PROMISE THAT ANYONE WILL.** Correcting it means naming a REPLACEMENT capability for the pool term, which is the move this class forbids without a measurement that discriminates the mechanism -- and that measurement belongs to the lane holding the falsifier, not to the lane filing the class. A row that names its own live instance states the honest residual; a row that assumed the instance away would be making a claim about someone else's branch that its own head cannot verify. ",
+
+    "**THE INSTRUMENT, SO NO FIGURE ABOVE HAS TO BE TRUSTED.** Every number in these receipts is re-derived by the producer `gunbc.rung_drop.determinism_transitive_reachability` names for its own figures: `claim_batch` over a probe calling `call_reachable_decls` at both grains, bracketing the reached count and the pool size by threshold ladder. The two-model scores are that probe read at file grain and at directory grain; the refutation of the index is the same probe with the index arm present and absent, which is also what pins the reached set identical across the two arms. ",
+
+    "A row whose cause was written from a source reading is therefore the expected outcome of ordinary diligence, not of carelessness, which is why the class needs a rule rather than an exhortation. ",
+
+    "**THE SECOND FAILURE DIRECTION, AND IT IS THE ONE THAT ACTUALLY RETIRES THE DROP WRONGLY.** The same row prescribed scoping the subject to exactly the reachable modules. ",
+
+    "That WOULD lower the number -- by shrinking the pool, leaving the shape untouched -- so the trigger is satisfiable by the very narrow-the-subject move that created the drop, and a drop retired that way re-breaks the instant the subject widens, which is the thing the drop exists to restore. ",
+
+    "The operator's rule, adopted from that case: **A TRIGGER THAT CAN BE SATISFIED BY SHRINKING THE SUBJECT IS NOT A TRIGGER, IT IS A RESTATEMENT OF THE BUDGET.** ",
+
+    "**AND THE FOOTPRINT WAS VISIBLE THE WHOLE TIME, WHICH IS THE PART TO LEARN.** The witness read one file, so `n` was small, and three lanes called it near-ceiling noise on exactly that ground. ",
+
+    "But the subject had been narrowed to one file BECAUSE the directory walk was interrupted_before_verdict -- the carrier's own comment says so. ",
+
+    "So `n is small here` was the DEFECT'S FOOTPRINT rather than a reason to tolerate it: the corpus had already paid this cost once, in coverage, and the drop is the receipt for that payment. ",
+
+    "WHY IT IS NOT `trigger_satisfied_before_the_row_was_written`: there the named capability had ALREADY SHIPPED, so the class is born retired and nothing is owed. ",
+
+    "Here nothing has shipped and the work is genuinely outstanding -- what is wrong is which work. ",
+
+    "WHY IT IS NOT `dissolution_trigger_cites_a_mechanism_that_is_later_deleted`: there the citation ROTS, and a resolver can find that a named mechanism no longer exists. ",
+
+    "Here every citation resolves and every name is live; the falsehood is a claim about causation, which no citation check can see. ",
+
+    "RUNG FOUND AT: outside the ladder, and that placement is the honest one rather than rung 1. ",
+
+    "Nothing fails, nothing refuses, no diagnostic fires, and the row is well formed by every structural check the corpus can run -- section 4b(2) asks whether a trigger EXISTS and names a capability, and this one does both. ",
+
+    "CEILING: 2, mechanically preventable, and NOT higher -- which is the honest ceiling rather than a modest one. ",
+
+    "Whether a stated cause is the true cause is a claim about the world, so no construction can make a wrong one unwritable; the reachable wall is evidence, not structure. ",
+
+    "NEXT TRIGGER, NAMED AS THE CAPABILITY: **a declared drop whose reason is a COST names the instrument that measured it and the populations that instrument varied, and the row is refused if the measurement varied only one population when the stated term multiplies two** -- sufficient for a reader to re-derive the cause rather than inherit it, and demonstrated by a discriminating red on a fixture row whose cause was established at a single grain. ",
+
+    "That is deliberately a check on the EVIDENCE's shape and not on the cause's truth: the first is decidable and the second is not, and conflating them is how this class would be over-promised into a wall it cannot reach.)",
+  ],
+
+  evidence: [],
+}

dag/gunbc/recurring_failure_mode/roster.dag

@@ -90,6 +90,7 @@ import gunbc.recurring_failure_mode.green_reported_over_a_population_the_instrum
 import gunbc.recurring_failure_mode.external_mechanism_asserted_under_a_correct_conclusion { external_mechanism_asserted_under_a_correct_conclusion }
 import gunbc.recurring_failure_mode.artifact_declares_a_threshold_it_is_not_measured_against { artifact_declares_a_threshold_it_is_not_measured_against }
 import gunbc.recurring_failure_mode.instrument_blind_spot_anti_correlated_with_severity { instrument_blind_spot_anti_correlated_with_severity }
+import gunbc.recurring_failure_mode.declared_trigger_names_a_term_that_is_not_the_cause { declared_trigger_names_a_term_that_is_not_the_cause }
 import gunbc.recurring_failure_mode.refusal_names_a_comparison_and_prints_neither_side { refusal_names_a_comparison_and_prints_neither_side }
 import gunbc.recurring_failure_mode.admission_predicate_evidenced_from_inside_its_own_subject { admission_predicate_evidenced_from_inside_its_own_subject }
 import gunbc.recurring_failure_mode.agreement_over_absorbed_classes_that_are_empty { agreement_over_absorbed_classes_that_are_empty }
@@ -259,6 +260,7 @@ data recurring_failure_mode_roster: List<RecurringFailureMode> = [
   external_mechanism_asserted_under_a_correct_conclusion,
   artifact_declares_a_threshold_it_is_not_measured_against,
   instrument_blind_spot_anti_correlated_with_severity,
+  declared_trigger_names_a_term_that_is_not_the_cause,
   refusal_names_a_comparison_and_prints_neither_side,
   admission_predicate_evidenced_from_inside_its_own_subject,
   agreement_over_absorbed_classes_that_are_empty,