ECS for Control: Observations – Verification

The verification suite on target: instrument validation, the closed loop under four policies, and the shipped configuration – every prediction computed first, every result character-exact.

The Rig

The whole suite runs on one principle: a fixed rig with one moving part. The calibration (the calibration document's row, unchanged through every run), the distiller, and the test harness are constant; the only thing that varies between runs is the adaptation policy – selected by the one aliased import the implementation document describes – and the test sequence, selected by one constant. A test is the pair (policy, sequence); everything else is the same build.

The target is the RP2350 on a Pico 2 board, running on one core only, with a kernel tick of 50 ms. The physical loop: the harness prints batches into the 64-char print buffer (63 usable); the drain empties it to a serial terminal at 38,400 baud. One drain firing moves at most 33 chars (the UART FIFO plus its shift register); at the drain period repertoire 12 / 6 / 3 ticks that is a capacity of 33 / 66 / 132 chars per 12-tick window. One variable is considered and thereby ruled out: at this baud rate a full FIFO empties in under 10 ms, so even the fastest repertoire period – 3 ticks = 150 ms – finds the FIFO long empty, and every firing has its full capacity available. The demand cases are sized against these two boundaries – buffer 63, capacity 33 – so that clipping is produced by arithmetic, not by chance.

Two terminals, two roles:

the plant terminal shows the drained output – the batches themselves, case names included. It is illustration, not record.
the console carries the record: per 12-tick window one drain line and one distiller line. This is the framework's standard console output on its own UART, bypassing the print buffer – and it busy-waits on a full FIFO, which would distort any timing it delayed. That variable, too, is considered and ruled out: the record's lines are tuned to never exceed the FIFO within a tick, so the busy-wait branch is never taken and the console cannot impact the tests – which is also why the record is as terse as it is:

  0 12                  drain line:      command, period (ticks)
 6 1 42     601         distiller line:  ops, events, level, tick

The distiller line is the instrumentation the implementation document's distiller chapter mentions: the window's operation and event deltas, the level after the pass, and the recency tick. The drain line's command column is the entire command channel – the supervisor prints nothing, so traces are directly comparable across all policies.

Two reading conventions hold throughout this document. A window is the 12-tick span between two distillations – a duration, never a location; window counts appear only as durations ("thirty clean windows", "21 clipping windows = 126 operations"). A point in time is always a tick – the value in the distiller line's last column. And the drain line count per window shows the drain period directly: one 0 12 line at period 12, two 1 6 lines at period 6, four 2 3 lines at period 3.

Two rig facts the predictions lean on throughout:

partial clip: an operation that does not fit is truncated to the free space – only the overflow chars drop, and exactly one event is counted. Predictions use char-exact overflow arithmetic, one event per clipping operation.
grid-locked drain: the drain re-locks its firing to a fixed grid (implementation document, drain chapter), so runs are phase-reproducible – the precondition for the character-exact comparisons below.

Methodology

Three rules give the suite its evidential weight:

every prediction is computed before its run – from the calibration document's relations and the harness batch arithmetic, down to the individual trace line: which window clips first, what the level reads at every tick, where the command changes. A run then either reproduces the prediction or produces a finding; nothing is explained after the fact.
the confirmation criterion is character-exact. A test passes when the recorded lines match the predicted values verbatim – not "the level rose as expected" but 42 at tick 601. The counting regime's exactness claim makes this standard available; the suite holds the machinery to it.
every trace identifies itself. Each policy carries its name in the System name, and the schedule report printed at every start names the policy that produced the trace. This is not ceremony: the suite's one build incident – a run accidentally built with the wrong policy – was caught immediately by the trace's own header, on the mechanism's first opportunity. The mis-build was set aside as an excursion, the run repeated; the record stayed clean.

One harness behaviour matters for reading long captures: when a test sequence's rows are exhausted, play wraps to the first row and repeats indefinitely, with buffer and level state carrying across. The first cycle is the experiment; the trailing cycles are repetition – and under the grid-locked drain they come out phase-identical, which the suite turns into evidence of its own.

The Harness

The load generator is a heartbeat System in the program's monitoring partition, driven by three authored tables: cases (a batch shape: a list of filler operations with their char counts), runs (a case times a repetition count), and sequences (a list of runs – the unit a test selects). Every batch consists of a fixed base (24 chars in 5 operations, including the case's name printed to the plant terminal) plus the case's fillers – so a case's total demand is authored to the char and the operation. All test definitions live in CLmon, the locked-components module of the load generator's own partition, and are retained there as published – the whole suite remains in the program, re-runnable as it stands.

The cases are designed against the calibration row's boundaries:

"1/8 34"      34 chars /  8 ops    the acceptable rate, exactly
"1/7 34"      34 chars /  7 ops    inside the band
"1/6 34"      34 chars /  6 ops    the triggering rate, exactly
"2/7 44 ff"   44 chars /  7 ops    heavy: fills fast, 2 events per window
"1/8 70 bst"  70 chars /  8 ops    burst: clips at write, at any drain rate
"2/12 40"     40 chars / 12 ops    the triggering rate at doubled op rate

The 34-char cases share one warm-up arithmetic: at drain capacity 33, the backlog grows one char per window; after thirty clean windows the buffer holds exactly 63 chars, and the first event follows at tick 361 – every steady-rate test begins with this same, fully predicted onset.

Phase A – Instrument Validation

Before any closed loop runs, the instrument itself is validated: the hold policies (fixed command, no adaptation) drive the drain, and the distiller's arithmetic is checked against sustained loads. Five tests, eight runs – every one confirmed character-exact, zero deviations. Each test below states its setup (policy and CLmon sequence), the claim under test, the prediction computed before the run, and the result with its evidence.

A1a – Neutrality at the Acceptable Rate, Clamped

setup: policy AdaptHold0 (drain held at period 12); sequence 0 = "1/8 34" × 40.
claim: at exactly the acceptable rate the level is neutral (the calibration document's neutrality identity) – here in its clamped form: a level at 0 stays at 0.
prediction: thirty clean windows 8 0 0 (the backlog grows one char per window, filling the buffer to exactly 63 by tick 349); first event at tick 361; from there exactly 1 event / 8 operations per window with the level at 0 to the end of the capture; drain line 0 12 unchanged throughout.
result: confirmed character-exact – start, onset, and tail:

  0 12
 8 0  0       1      <- clean from the start
  0 12
 8 0  0      13
 ...
  0 12
 8 0  0     349      <- 30th clean window: buffer at exactly 63
  0 12
 8 1  0     361      <- first event -- and the level stays 0
  0 12
 8 1  0     373
  0 12
 8 1  0     385      <- steady: 1 event / 8 ops, neutral
 ...
  0 12
 8 1  0     709      <- unchanged, here and to the end of the capture

The onset at tick 361 re-verifies drain capacity 33 and usable buffer 63; the steady one-event tail is itself evidence for the partial-clip semantics – refusing whole operations would shrink the intake below capacity and force clean windows, which never appear.

A1b – Neutrality off the Clamp

setup: AdaptHold0; sequence 1 = "2/7 44 ff" × 6 (charge), then "1/8 34" × 24 (hold).
claim: the neutrality identity holds at any level, not only at the clamp: an at-rate stream freezes the level at its standing value.
prediction: the six charge windows (ticks 1–61) show events 0, 0, 1, 2, 2, 2 and levels 0, 0, 1, 10, 19, 28 (the heavy case climbs +9 per clipping window); the 24 hold windows (ticks 73–349) show exactly 1 event / 8 operations with the level frozen at 28 – below Tset = 42, no trip; after the wrap at tick 361, the charge replays against the full buffer and ratchets the plateau upward.
result: confirmed character-exact, the predicted trajectory value for value:

  0 12
 7 0  0       1      <- charge case: clean while the buffer fills
  0 12
 7 0  0      13
  0 12
 7 1  1      25      <- first event
  0 12
 7 2 10      37      <- 2 events per window: +9
  0 12
 7 2 19      49
  0 12
 7 2 28      61      <- charge ends: level 28
  0 12
 8 1 28      73      <- hold: 1 event / 8 ops -- level FROZEN
  0 12
 8 1 28      85
 ...
  0 12
 8 1 28     349      <- 24th hold window: still 28
  0 12
 7 2 37     361      <- wrap: the charge replays, the ratchet resumes
 ...
  0 12
 7 2 84     781      <- third cycle: saturated at Cap = 84
  0 12
 8 1 84     793      <- and held there

The wrap froze a second plateau at 82, and the third cycle saturated at 84 = Cap exactly, pinned – the upper clamp observed en passant, beyond the prediction.

A2 – The Triggering Slope and the Detection Curve

setup: AdaptHold0; sequence 2 = "1/6 34" × 60.
claim: at the triggering rate the level climbs at the derived slope (+2 per window: one event's weight 8 less six operations' decay 6), and Tset is reached exactly at the detection curve's promised deadline – 126 operations of sustained excess.
prediction: thirty clean windows; onset at tick 361; +2 per window: 2, 4, 6, …; level = Tset = 42 exactly at tick 601 – 21 clipping windows = 126 operations after onset; the staircase continues (the hold policy only watches) to Cap = 84 at tick 853, pinned.
result: confirmed character-exact – the onset, every staircase value, the Tset crossing, and Cap:

  0 12
 6 0  0     349      <- last clean window
  0 12
 6 1  2     361      <- onset: the +2 staircase begins
  0 12
 6 1  4     373
  0 12
 6 1  6     385
 ...
  0 12
 6 1 40     589
  0 12
 6 1 42     601      <- level = Tset: 126 ops after onset
  0 12
 6 1 44     613      <- the hold policy only watches: the drift continues
 ...
  0 12
 6 1 82     841
  0 12
 6 1 84     853      <- Cap
  0 12
 6 1 84     865      <- pinned thereafter

A3 – Drift Inside the Band

setup: AdaptHold0; sequence 3 = "1/7 34" × 60.
claim: a rate inside the band (between 1/8 and 1/6) drifts at the derived slope +1 per window, and the detection curve still prices it: Tset at 294 operations of sustained excess – detection promised, but later.
prediction: onset at tick 361; +1 per window; level 30 at the sequence's named end (tick 709) – visible drift, no trip within the named length; the wrap continues the drift seamlessly: Tset = 42 at tick 853, 42 clipping windows = 294 operations after onset; Cap = 84 at tick 1357.
result: confirmed character-exact across the entire arc:

  0 12
 7 0  0     349      <- last clean window
  0 12
 7 1  1     361      <- onset: the +1 staircase
  0 12
 7 1  2     373
  0 12
 7 1  3     385
 ...
  0 12
 7 1 30     709      <- named end of the sequence: well below Tset
  0 12
 7 1 31     721      <- the wrap is invisible, the drift continues
 ...
  0 12
 7 1 41     841
  0 12
 7 1 42     853      <- level = Tset: 294 ops after onset
  0 12
 7 1 43     865
 ...
  0 12
 7 1 84    1357      <- Cap
  0 12
 7 1 84    1369      <- pinned thereafter

With A1 and A2: slopes 0 / +1 / +2 at rates 1/8, 1/7, 1/6 – the slope relation exact across the band.

A4 – Batching Invariance (Two Runs: Distiller at Twice and at Half the Period)

setup: AdaptHold0; sequence 4 = "1/6 34" × 30; the suite's one rig delta: the distiller period set to 6 ticks (A4a) and 24 ticks (A4b) against the standard 12.
claim: the level is a function of the counts alone (the counting regime's batching invariance) – distiller scheduling can neither add nor lose evidence; its only effects are recognition granularity and where the zero clamp lands.
prediction: A4a: distillations alternate – batch lines carrying A2's values verbatim, and null lines 0 0 with the level frozen (no operations, nothing drains). A4b: the counts arrive in double quanta (12 ops, 2 events, +4 level per distillation), with one predicted artefact: the distillation straddling the onset nets 8 − 12 = −4 and clamps at 0, leaving a persistent −2 offset against A2; first sight of Tset quantized to 44 at tick 625; Cap 84 at tick 865.
result: both runs confirmed character-exact, artefact included. Side by side, lines with the same tick aligned (the drain fires identically in both – one 0 12 per window):

A4a (distiller period 6)              A4b (distiller period 24)
  0 12                                  0 12
 6 0  0     349
 0 0  0     349   <- null: frozen
  0 12                                  0 12
 6 1  2     361   <- onset, as A2     12 1  0     361   <- onset straddle: CLAMPED
 0 0  2     361
  0 12                                  0 12
 6 1  4     373
 0 0  4     373
  0 12                                  0 12
 6 1  6     385                       12 2  4     385   <- +4 quanta, -2 offset vs A2
 0 0  6     385
 ...                                   ...
  0 12                                  0 12
 6 1 42     601   <- Tset, on time    12 2 40     601   <- the -2 offset persists
 0 0 42     601
  0 12                                  0 12
 6 1 44     613
 0 0 44     613
  0 12                                  0 12
 6 1 46     625                       12 2 44     625   <- first sight of Tset: quantized
 ...                                   ...
  0 12                                  0 12
 6 1 82     841                       12 2 80     841
 0 0 82     841
  0 12                                  0 12
 6 1 84     853   <- Cap, on time
 0 0 84     853
  0 12                                  0 12
 6 1 84     865                       12 2 84     865   <- Cap, one quantum late

Invariance holds exactly where the theorem says – counts, cursors, steady slope – and fails exactly at its one nonlinearity, the zero clamp under a straddling distillation. A faster distiller bought nothing; a slower one paid quantized recognition. Decoded en passant: the recency tick updates only on distillations with operations – the null lines carry the previous stamp.

A5 – The Machinery Lever (Two Runs: Drain Held at 12 and at 6)

setup: sequence 5 = "2/7 44 ff" × 16; A5a under AdaptHold0 (drain 12), A5b under AdaptHold1 (drain 6).
claim: correcting the mechanism's own actuator removes the event class: the demand that saturates the evidence at one drain period produces none at the doubled rate (capacity 66 per window ≥ demand 44).
prediction: A5a: onset at tick 25, then +9 per clipping window: Tset crossed at 46 (tick 85), Cap 84 at tick 145, pinned through the wraps. A5b: not a single event in any window of any cycle – level 0 flat, two 1 6 drain lines per window.
result: both confirmed character-exact. Side by side, lines with the same tick aligned:

A5a (drain held at 12)                A5b (drain held at 6)
  0 12                                  0 12
 7 0  0       1                        7 0  0       1
  0 12                                  1  6
 7 0  0      13                        7 0  0      13
  0 12                                  1  6
                                        1  6
 7 1  1      25   <- onset             7 0  0      25
  0 12                                  1  6
                                        1  6
 7 2 10      37   <- +9 per window     7 0  0      37
  0 12                                  1  6
                                        1  6
 7 2 19      49                        7 0  0      49
 ...                                   ...
  0 12                                  1  6
                                        1  6
 7 2 46      85   <- Tset crossed      7 0  0      85
 ...                                   ...
  0 12                                  1  6
                                        1  6
 7 2 84     145   <- Cap, pinned       7 0  0     145
  0 12                                  1  6
                                        1  6
 7 2 84     157      forever           7 0  0     157   <- never an event

A5a hit every predicted value on the tick; A5b showed zero events across ~105 windows – the identical load, erased by one period step. No caller involved, nothing attributed: the lever acts entirely on the providing side.

Phase A's verdict: the instrument is validated – the slope identity at three rates, two exact points on the detection curve, Cap from three approach slopes, the invariance theorem with its boundary artefact, and the capacity model at two operating points.

Phase B – The Closed Loop

The supervisor goes live: the ladder policy (no dwell) first, the dwell policy against it. Six tests, seven runs – every claim verified; one prediction deviation, understood, recorded below. Same per-test format as Phase A.

B1 – Comparator Zero in the Loop

setup: AdaptLadder; sequence 0 = "1/8 34" × 40 – A1a's sequence, now under a live policy.
claim: at the commitment the loop is quiescent: a supervisor deciding every pass issues no command change, ever.
prediction: the data lines of A1a, verbatim – onset at tick 361, then 8 1 0 steadily; every one of the ~100 live decisions a no-op (level 0, at or below Tclear, with the command already at the bottom clamp); drain line 0 12 unchanged.
result: confirmed – the A1a trajectory reproduced under the live policy, line for line:

  0 12
 8 0  0       1      <- live policy in the loop, clean from the start
  0 12
 8 0  0      13
 ...
  0 12
 8 0  0     349
  0 12
 8 1  0     361      <- onset, exactly as A1a
  0 12
 8 1  0     373
  0 12
 8 1  0     385
  0 12
 8 1  0     397      <- and so on: level 0, command 0, to the end

Not one command change in the capture: no drift, no spurious action, at the commitment.

B2 – The Detection Curve in the Loop, and the First Finding

setup: AdaptLadder; sequence 2 = "1/6 34" × 60 – A2's sequence.
claim: three parts. First, closed-loop escalation fires exactly at the curve's deadline, 126 operations after onset. Second, a finding derived from the code before the run: the second step is built into every trip – the command reaches the drain one window late (the deterministic unit delay on the command port), so the post-trip window still clips at the old rate while the level still stands at Tset, and the ladder, deciding every pass, steps again. Third, under a sustained violation the loop cannot park – it hunts.
prediction: as A2 to the trip: level 42 at tick 601 → command 0→1; at tick 613 the load still clips on the old rate: 44 → command 1→2 (the predicted double-step; the only line above Tset); clean from tick 625, discharge −6 per window; de-escalations at Tclear: 2→1 at level 14 (tick 673), 1→0 at 8 (tick 685); parked at 0 by tick 709; silent recharge, second onset at tick 1057, second trip at tick 1297 – hunt period 58 windows; the drain lines hop through the divisor chain at every change.
result: confirmed character-exact – every level value, every command change, every drain-line hop:

  0 12
 6 1 40     589
  0 12
 6 1 42     601      <- trip: cmd 0 -> 1
  1  6               <- the command reaches the drain
 6 1 44     613      <- still clipping on the OLD rate: cmd 1 -> 2
  2  3               <- fast phase: four firings per window
  2  3
  2  3
 6 0 38     625      <- clean: correction effective, discharge -6
  2  3
  2  3
  2  3
  2  3
 6 0 32     637
 ...
 6 0 20     661
  2  3
  2  3
  2  3
  2  3
 6 0 14     673      <- Tclear: cmd 2 -> 1
  1  6
  1  6
  1  6
 6 0  8     685      <- Tclear: cmd 1 -> 0
  0 12
  0 12
 6 0  2     697
  0 12
 6 0  0     709      <- parked; silent recharge follows
 ...
  0 12
 6 1  2    1057      <- second onset, after the predicted 29 quiet windows
  0 12
 6 1  4    1069
 ...
  0 12
 6 1 42    1297      <- second trip: hunt period 58 windows
  1  6
 6 1 44    1309      <- the whole transient replays, phase-identical

The second cycle repeated the first with every event at +696 ticks – extending the grid-locked reproducibility from the drain to the whole closed-loop transient.

B3 – Recovery Parks

setup: AdaptLadder; sequence 6 = "1/6 34" × 55, then "1/8 34" × 40.
claim: when the load genuinely returns to tolerance, the loop discharges, de-escalates step by step, and parks – the hunt is the signature of sustained violation, not of recovery.
prediction: identical to B2 through the transient (trip 42 at tick 601, double-step 44 at 613, discharge −6); the case switch shows as the ops column stepping 6 → 8 (tick 661) and steepens the discharge to −8 per window (more operations, same decay): de-escalations at levels 10 (tick 673) and 2 (tick 685), parked at 0 by tick 697; the rebuilt backlog then clips at the acceptable rate: 8 1 0 steady, level frozen, command at rest – no re-trip.
result: confirmed character-exact – the same transient, the opposite tail:

  0 12
 6 1 42     601      <- trip and double-step, exactly as B2
  1  6
 6 1 44     613
  2  3
  2  3
  2  3
 6 0 38     625      <- discharge -6, as B2
 ...
 6 0 26     649      <- last violating-case window
  2  3
  2  3
  2  3
  2  3
 8 0 18     661      <- case switch: ops 6 -> 8, discharge steepens to -8
  2  3
  2  3
  2  3
  2  3
 8 0 10     673      <- Tclear: cmd 2 -> 1
  1  6
  1  6
  1  6
 8 0  2     685      <- Tclear: cmd 1 -> 0
  0 12
  0 12
 8 0  0     697      <- parked
 ...
  0 12
 8 1  0    1057      <- the rebuilt backlog meets an at-tolerance load:
  0 12                   one priced event per window, level frozen at 0
 8 1  0    1069
  0 12
 8 1  0    1081      <- command at rest -- no re-trip, no hunt

Same transient as B2, opposite tail: sustained violation and genuine recovery are distinguishable in the record by the last column alone.

B5 – The Settling Map, and the Second Finding (Two Runs)

setup: AdaptLadder; B5-drift = sequence 3 ("1/7 34" × 60), B5-heavy = sequence 5 ("2/7 44 ff" × 16). With B1 and B2, these complete the map over the legal load range.
claim: the ladder's settling map – every sustained load either parks at the bottom command or hunts; and, the second code-derived finding, the top command is never a settled rung: a batch that fits the buffer is fully cleared at period 6, a batch that does not clips at write regardless of the drain, so no sustained in-budget load can need the fastest period.
prediction: B5-drift: trip at 42 (tick 853 – the 294-operation curve point, closed-loop); double-step 43 at 865; discharge −7 per window; de-escalations at levels 8 (tick 925) and 1 (937); hunt period 79 windows (second trip tick 1801). B5-heavy: trip 46 at tick 85; double-step 55 at 97; a third-step attempt absorbed by the top clamp (48 at 109, still above Tset, command already at the top); de-escalations at 13 (tick 169) and 6 (181); hunt period 16 windows (second trip tick 277).
result: both confirmed character-exact. B5-drift, trip and unwind:

  0 12
 7 1 41     841
  0 12
 7 1 42     853      <- trip (294 ops after onset): cmd 1
  1  6
 7 1 43     865      <- double-step window: cmd 2
  2  3
  2  3
  2  3
 7 0 36     877      <- discharge -7
 ...
 7 0  8     925      <- Tclear: cmd 2 -> 1
  1  6
  1  6
  1  6
 7 0  1     937      <- Tclear: cmd 1 -> 0
  0 12
  0 12
 7 0  0     949      <- parked; the drift rebuilds
 ...
  0 12
 7 1 42    1801      <- second trip: hunt period 79 windows

B5-heavy, the compressed version of the same shape:

  0 12
 7 1  1      25      <- onset (fast: the heavy case fills in 2 windows)
  0 12
 7 2 10      37      <- +9 per window
 ...
  0 12
 7 2 46      85      <- trip: cmd 1
  1  6
 7 2 55      97      <- double-step: cmd 2
  2  3
  2  3
  2  3
 7 0 48     109      <- still >= Tset: the third step, absorbed by the clamp
 ...
 7 0 13     169      <- Tclear: cmd 2 -> 1
  1  6
  1  6
  1  6
 7 0  6     181      <- Tclear: cmd 1 -> 0
  0 12
  0 12
 7 0  0     193
 ...
  0 12
 7 2 46     277      <- second trip: hunt period 16 windows

Three full limit cycles captured for the heavy case, phase-identical. The map, with B1 and B2:

 1 event / 8 ops    parks at command 0
 1 event / 7 ops    hunts, period 79 windows
 1 event / 6 ops    hunts, period 58 windows
 heavy (44 chars)   hunts, period 16 windows

The hunt period falls monotonically with load, and across the whole range the top command appears only as the double-step transient or clamp-held – never as a settled rung.

B6 – The Priced Residual

setup: AdaptLadder; sequence 7 = "1/8 70 bst" × 60.
claim: a structural burst – a single operation larger than the buffer, clipping at write at any drain rate – saturates the ladder, and the declaration prices the residual: at saturation it runs at exactly the acceptable rate, so the correct response is none.
prediction: clipping from the very first window, no warm-up (overflow 7 of the 70-char batch into the empty 63-char buffer); charge at 3 events per window, +16 each: levels 16, 32, 48 → command 1 at tick 37; 64 → command 2 at 49 (the built-in second step); from tick 61 the fast drain clears the inter-batch backlog and the residual settles at 1 event / 8 operations: level frozen at 64, above Tset with further escalation clamped, forever.
result: confirmed character-exact:

  0 12
 8 1  0       1      <- clips from the FIRST window: burst, no warm-up
  0 12
 8 3 16      13      <- 3 events per window while charging: +16
  0 12
 8 3 32      25
  0 12
 8 3 48      37      <- Tset: cmd 1
  1  6
 8 3 64      49      <- the built-in second step: cmd 2
  2  3
  2  3
  2  3
 8 1 64      61      <- the hold: 1 event / 8 ops, level frozen
  2  3
  2  3
  2  3
  2  3
 8 1 64      73      <- unchanged, here to the end of the capture

8 1 64 in every following window: one priced event per window, level frozen above Tset, no de-escalation churn, no further action – saturation as correct minimal behaviour.

B4 – The Dwell Against the Ladder

setup: AdaptDwell; sequence 2 = "1/6 34" × 60 – the same sequence as B2; the only difference is the policy.
claim: the operation-denominated dwell (the calibration row's recovery horizon, 28 operations) removes the built-in second step at zero cost to the recovery – one decision per correction's measurable effect.
prediction: identical to B2 through the trip (42 at tick 601, command 0→1, dwell armed at the trip's odometer reading); at tick 613 the second step is held – 6 operations of fresh evidence, short of 28; the level column continues as B2's (44, 38, 32, …); the dwell expires in-band without effect; a single de-escalation 1→0 at level 14 (tick 673); the hunt otherwise as B2's.
result: confirmed on every core claim – with the suite's one prediction deviation, in the dwell's favour. Side by side, lines with the same tick aligned:

ladder (B2)                           dwell (B4)
  0 12                                  0 12
 6 1 42     601   <- trip: cmd 1       6 1 42     601   <- trip: cmd 1, dwell armed
  1  6                                  1  6
 6 1 44     613   <- cmd 2!            6 1 44     613   <- HELD: no second step
  2  3                                  1  6
  2  3                                  1  6
  2  3
 6 0 38     625                        6 0 38     625   <- discharge -6, identical
  2  3                                  1  6
  2  3                                  1  6
  2  3
  2  3
 6 0 32     637                        6 0 32     637
 ...                                   ...
  2  3                                  1  6
  2  3                                  1  6
 6 0 14     673   <- cmd 2 -> 1        6 0 14     673   <- cmd 1 -> 0: single step
  1  6                                  0 12
  1  6                                  0 12
  1  6
 6 0  8     685                        6 0  8     685
  0 12                                  0 12
  0 12
 6 0  2     697                        6 0  2     697
  0 12                                  0 12
 6 0  0     709   <- parked            6 0  0     709   <- parked
 ...                                   ...
  0 12                                  0 12
 6 1 42    1297   <- second trip:      6 1 42    1285   <- second trip:
                     period 58                             period 57

The second step is gone in both cycles – no 2 3 drain line appears anywhere in the dwell's trace – and the level column is the ladder's, value for value (44, 38, 32, 26, 20, 14, 8, 2, 0 on the same ticks): the dwell cost the recovery nothing. The deviation: the hunt period came out 57 windows, not the predicted "unchanged" 58. The cause is read off the trace: the single de-escalation completes at tick 673 where the ladder's pair needs until 685, so the drain returns to the slow period one window earlier and the whole cycle contracts by exactly one window. The dwell does not only remove the excursion; it shortens the hunt.

Phase B's verdict: the closed loop is characterised end to end – the curve holds in the loop, recovery and sustained violation are distinguishable on the trace, the ladder's built-in double-step is real and the operation-denominated dwell removes it at zero recovery cost.

The Shipped Configuration

The program ships as the dwell policy under a purpose-designed load: the triggering rate again, but at doubled operation rate ("2/12 40" – 2 events per 12 operations = the declared 1 per 6). The design exploits an asymmetry the calibration document's curve makes precise: adding chars deepens the charge and lengthens the discharge in equal measure, but adding operations at the same rate compresses the whole cycle – the detection deadline is fixed in operations (126), and doubling the operation rate halves the windows it takes.

setup: AdaptDwell – the shipped policy; sequence 8 = "2/12 40" × 20.
claim: the shipped pairing shows every mechanism these documents describe in one short, repeating, observable cycle – behaving exactly as the calibration predicts.
prediction: four clean refill windows; onset at tick 49 with 2 events / 12 operations = the declared rate; +4 per window to the trip at 44, tick 169 (132 operations = the 126-operation deadline, quantized to the 12-operation window); the latency window held by the dwell (48 at 181 – no second step); discharge −12 per window; de-escalation at level 12 (tick 217); parked at 0 by 229; four clean windows, then the next cycle – phase-identical, period 228 ticks = 19 windows ≈ 11.4 s.
result: confirmed character-exact, six full cycles captured – trips at ticks 169, 397, 625, 853, 1081, 1309, each +228:

  0 12
12 0  0      25      <- refill, clean
  0 12
12 0  0      37
  0 12
12 2  4      49      <- onset: 2/12 = the declared triggering rate
  0 12
12 2  8      61      <- +4 staircase
  0 12
12 2 12      73
 ...
  0 12
12 2 40     157
  0 12
12 2 44     169      <- trip: cmd 1  (132 ops = the 126-op deadline, quantized)
  1  6
12 2 48     181      <- latency window, HELD by the dwell
  1  6
  1  6
12 0 36     193      <- discharge -12
  1  6
  1  6
12 0 24     205
  1  6
  1  6
12 0 12     217      <- Tclear: cmd 1 -> 0
  0 12
  0 12
12 0  0     229      <- parked
  0 12
12 0  0     241
 ...
  0 12
12 0  0     265
  0 12
12 2  4     277      <- next cycle, phase-identical
  0 12
12 2  8     289

Every mechanism described in these documents appears once per cycle: refill, onset at the declared rate, the evidence staircase, the trip at Tset, the dwell holding the latency window, the rate change in the drain lines, the discharge, the de-escalation at Tclear, the park.

The plant terminal contributes two views of its own – shown here as a reference for running v21 as shipped: each batch prints as one line, hb, the tick, the case name, and the case's filler tail (16 chars when it arrives whole).

clipping readable by eye: the case's fillers are designed so the truncation boundary falls mid-pattern – healthy windows print the full filler tail, clipping windows cut it at the same character every time. The observer literally watches the plant lose text and the loop restore it, every eleven seconds:

hb      37 2/12 40    :-:-:-:-::--:---     <- healthy: the full filler tail
hb      49 2/12 40    :-:-:-:-::-          <- onset: the first cut
hb      61 2/12 40    :-:-:-:-:            <- clipping: cut at the same char every time
hb      73 2/12 40    :-:-:-:-:
 ...
hb     181 2/12 40    :-:-:-:-:
hb     193 2/12 40    :-:-:-:-::--:---     <- fast drain, then park: the tail returns
 ...
hb     265 2/12 40    :-:-:-:-::--:---
hb     277 2/12 40    :-:-:-:-::-          <- next cycle, phase-identical

the backlog, read off the screen: the terminal lags the writer by exactly the buffer fill, so the live screen's last line is always cut where the backlog begins. During the filling phase the cut drifts by the backlog growth per window and freezes when clipping pins the fill – the buffer level, an internal quantity everywhere else in the suite, is visible on the plant terminal as the length of the missing tail. A capture taken mid-run freezes the proof on its final line:

hb    1609 2/12 40    :-:-:-:-::--:---
hb    1621 2/12 40    :-:-:-:-::--:---
hb    1633                               <- the live last line, frozen mid-delivery:
                                            10 of the batch's 40 chars have arrived,
                                            30 in flight = the buffer fill, on screen

Verdict

Sixteen recorded runs; every prediction computed before its run; one deviation, understood, and in the tested mechanism's favour. In the calibration document's terms, the suite establishes on target:

the counting regime, exactly: batching invariance verbatim at doubled and halved distiller rates, the null-window freeze, and the one predicted clamp artefact at its one nonlinearity.
the neutrality identity at three rates: slope 0 at the acceptable rate (clamped and off the clamp), +1 inside the band, +2 at the triggering rate.
the detection curve at two points and in the loop: 126 operations at the triggering rate, 294 inside the band – open-loop and closed-loop, exact.
every threshold: Tset tripped on the predicted operation, Tclear crossed on the predicted window, Cap reached from three slopes and pinned.
the recovery horizon as the dwell: one decision per correction's measurable effect, at zero recovery cost, with the command excursion strictly smaller and the hunt one window shorter.
absorption and the priced residual: graceful per-event clipping throughout, and the structural burst residual held at exactly the acceptable rate under saturation.
two structural findings, derivation to demonstration: the command-latency double-step built into every undamped trip, and the top rung unreachable by any sustained in-budget load.

The observation machinery promises operations, and keeps that promise exactly – which is where this set of documents draws its line. What lies beyond it – producer rates, temporal deadlines, whole-program composition – is the calibration document's declared boundary, and another round's subject.