Unit lane cap 60 -> 80 min from the first uncensored wall (follow-up to #13445)

.github/workflows/witnesses.yml

@@ -23,7 +23,7 @@ env:
 jobs:
   rust-unit-tests:
     runs-on: [self-hosted, linux, arm64]
-    timeout-minutes: 50
+    timeout-minutes: 90
     if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository
     permissions:
       contents: read
@@ -76,7 +76,7 @@ jobs:
           if (! '[' '-f' "$GUNBC_FLOOR_RECEIPT" ']') || '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']' || ('[' "$GUNBC_FLOOR_CLASS" '=' 'infra' ']' && (! ('[' '-f' "$GUNBC_FLOOR_RECEIPT" ']' && 'grep' '-q' 'class=structural' "$GUNBC_FLOOR_RECEIPT"))) || ('[' "$GUNBC_FLOOR_CLASS" '=' 'none' ']' && (! ('[' '-f' "$GUNBC_FLOOR_RECEIPT" ']' && 'grep' '-q' 'class=structural' "$GUNBC_FLOOR_RECEIPT")) && (! ('[' '-f' "$GUNBC_FLOOR_RECEIPT" ']' && 'grep' '-q' 'class=infra' "$GUNBC_FLOOR_RECEIPT"))); then 'printf' 'class=%s\nsignature=%s\nexit=%s\n' "$GUNBC_FLOOR_CLASS" "$GUNBC_FLOOR_SIGNATURE" "$GUNBC_FLOOR_EXIT" > "$GUNBC_FLOOR_RECEIPT"; if '[' "$GUNBC_FLOOR_CLASS" '=' 'infra' ']'; then 'echo' '::error title=environment::floor_class='"$GUNBC_FLOOR_CLASS"' signature='"$GUNBC_FLOOR_SIGNATURE"' exit='"$GUNBC_FLOOR_EXIT"'; this is not a verdict about the diff. Attempt receipt: '"$GUNBC_FLOOR_RECEIPT"; fi; if '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']'; then 'echo' '::error title=subject::floor_class='"$GUNBC_FLOOR_CLASS"' exit='"$GUNBC_FLOOR_EXIT"'; read the step log for the subject defect'; fi; fi
           'exit' "$GUNBC_FLOOR_EXIT"
 
-        timeout-minutes: 40
+        timeout-minutes: 80
   emit-build:
     runs-on: [self-hosted, linux, arm64]
     timeout-minutes: 90

dag/gunbc/recurring_failure_mode/shared_precondition_re_derived_once_per_claim_frame.dag

@@ -38,6 +38,7 @@ data shared_precondition_re_derived_once_per_claim_frame: RecurringFailureMode =
 
     "NEXT-RUNG TRIGGER, a capability and not an artifact: the floor reports, for each refusing file, the shared pure preconditions its claims re-derive and the multiplicity -- sufficient that a cost refusal names the duplication where one exists, so the reader is never offered trim-or-re-home as an exhaustive choice over work that should have been computed once. Until then the class is found by partitioning a claim by hand, which requires an author who already suspects it.",
     "OCCURRENCE (2026-10-04, gunbc#13185): the program_assembly self-host contract. MEASURED: required run 37169119743 recorded 214,850 eval steps (671 ms CPU) for one claim that calls v2.compiler.program_assembly assemble_program_from_ingest three times, against the 72,300-step per-claim budget -- about 71,600 steps per assembly. INSTRUMENT FOR THE SCALING SHAPE, re-derivable: a driver that calls the contract's pac_assemble 300 times through `gunbc run` and subtracts the printed pre-entry CPU from total user CPU gave about 43 ms per assembly for a two-line module with a function, for its unparseable sibling, and for a ONE-LINE module (about 39 ms for the one-line unparseable form). So the cost does not move with the source at this size. WHAT IS ESTABLISHED: each assembly pays a fixed, text-independent cost of roughly the floor's whole per-claim budget, and the three assemblies inside ONE claim frame paid it three times. WHAT IS INFERRED AND NOT ESTABLISHED: that the fixed part is a shared precondition rebuilt per call rather than work each assembly genuinely owes. That reading fits this class and the ladder in the first receipt (bare ingest of a four-line source dominating a claim), but no partition of the 71,600 steps was taken here. DISCRIMINATOR THAT WOULD SETTLE IT: the per-phase step partition of one assembly (tokenize, parse, normalize, resolve, and whatever each constructs before reading its input) on two sources of different length; a phase whose steps are identical across both and are spent before its input is read is the rebuilt precondition. CONSEQUENCE ALREADY PAID: the contract could not be enrolled as a floor claim (gunbc.guarantee_stall self_host_program_assembly_contract_floor_enrollment_stall).",
+    "OCCURRENCE (2026-10-05, gunbc#12951 restoring the rust-unit-tests lane; repair pending): the same shape in the RUST unit population, where the frame is one #[test] rather than one claim. v1_compiler.cli_run.required_floor_runner changed_witness_projection_tests cost_debt_* (cost_debt_verdict_refusals resolves the live v2.workflow.floor_cost_debt_verdict entry graph in every test) and v1_compiler.cli_run.reach_base_standings tests (each resolving a live required_floor graph) re-derive one pure precondition per test, minutes apiece, while each test inspects only the verdict over a handful of SUPPLIED terminal rows. The restored lane hit its 40-minute step cap on main with every test that ran passing (job 111941683683), and gunbc#13445 raised the cap by the cap's own rule to keep the required context runnable. That raise treats the symptom. The repair this row prescribes is the DESIGN section 3 witness rule: resolve the verdict entry once per process (or supply the verdict function's inputs) and keep ONE test on the real resolve route.",
   ],
 
   evidence: [

dag/gunbc/witness/compiler_gate_workflow.dag

@@ -299,8 +299,20 @@ data compiler_gate_unit_test_step_id: String = "rust_unit_tests"
 // first, witnesses run 36676083674 on srv4, is the current maximum), plus the hosted population
 // silent-koi-310 tabulated, which sits below it; re-read them there and re-derive when a fleet wall
 // exceeds two thirds of the cap.
+// RE-DERIVED 2026-10-05: after gunbc#12951 restored the lane over main's population, the step hit the
+// 40-minute cap with every test that ran passing (job 111941683683 on gunbc#13420: the cost_debt_*
+// and reach_base_standings tests each resolve a live .dag entry graph, minutes apiece). That wall is
+// CENSORED at 40, so it is a lower bound on the true maximum; the rule applied to it gives 40 x 1.5 =
+// 60. If a fleet wall then exceeds 40 (two thirds of 60), re-derive again from the uncensored wall.
+// RE-DERIVED AGAIN, 2026-10-05, FROM THE FIRST UNCENSORED WALL: gunbc#13445's own required run
+// executed the full population under the 60-minute cap and the step finished in 52m51s (read it from
+// that run's rust_unit_tests step times). That exceeds two thirds of 60, so the rule applies to it:
+// 52m51s x 1.5 = 79.3, rounded up to the next 5 = 80.
+// The cost shape is the real defect (DESIGN section 3: those tests re-derive a live graph per test
+// where the claim needs only supplied inputs); it is rostered as an occurrence of
+// gunbc.recurring_failure_mode shared_precondition_re_derived_once_per_claim_frame, not hidden by this cap.
 fn compiler_gate_unit_test_timeout() -> Minute {
-  minute(count: 40)
+  minute(count: 80)
 }
 
 // Checkout, toolchain-home isolation and the toolchain install run before the unit step; the step