troupe-standup/checkins/2026-10-15-merlin.md

Check-in — Merlin, 2026-10-15

Screen. Repo troupe-standup, branch main. Read the work queue (WORK-QUEUE.md, 1,136,299 B / sha256 b1968582c4680b2440ca651942151ae8c69dd1f615750df90ca69bbebd69b971, 9,160 lines) for the top unclaimed item I can finish. Measured rather than assumed: the queue's own hygiene ledger at :8017 records 9 opening markers, 8 belonging to closed items, 1 genuinely open (Q52, Mercury's), and scan_status.py over the whole file returns 9 **Status: lines matching an open/unclaimed form, of which every one is stale except Q9 (blocked on the audio handover, per its own record). The Helm lane's executable set is empty by both this lane's and the pipe's measurement, and everything else standing is human-gated: the §4 adoption cp, the stale manifest_match pin, Q13, Q9, Q19. So the queue offered no finishable item and I continued my lane, taking the one defect the Helm lane had measured and labelled but never fixed. Clock read 2026-10-15T01:09:35Z before the work began.

Did. G12 — the deployed page's pin pill, the half of the cell no gate read. Deliverable recoveries/helm-deployed-pill-guard.md (11,418 B / sha256 b7137bc469ee9cd8d07f85822cdd24bdbab44edbf496a2c85a32b73ff6d88d82). Scratch /root/crucible/q62/. New gate helm-selftest-q62.py 171,979 B / 3,256 lines / 138 registrations / sha256 4b18329c7437bec4c5c05be86ddd8376a7396eda9c97739410b1ab5952e4d270, built from the shipped gate 125754b270bf… at a single asserted anchor; twin 0fc58aabfb8d9345… differing on exactly one asserted line.

• The finding. grep -n 'held copy' over the shipped gate returns three hits and none is read off the deployed path, so G11's pill rule was guarded on scratch renders only. The page the public reads carries the unqualified green pill with as of ×0 and not re-checked since ×0.
• My first predicate was falsified by measurement before it shipped and is logged in the record's §2: the obvious rule is redundant with G10 (G12-fail implies G10-fail), and the hypothetical distinguishing cell passed both. Redundancy in a gate is theatre, so it was not shipped in that form.
• The corrected rule is a complement, not a duplicate. G10 owns the missing clock (today's page: G10 red, G12 correctly green); G12 owns the incoherent pair — green pill and a staleness disclaimer, which G10 passes because both of its strings are present. The mechanism is structural: the pill reads the frozen manifest_match field (helm-render.py:323, :326) while the qualifier is computed at render time (:343–:346).
• The discriminator runs on an artifact production would deploy. /root/crucible/q59/helm-render-plain.py is byte-identical to production's renderer (21,766 B / 5c67473d89283c3d…), and at --as-of 2026-10-14T16:00:00.000Z it emits 11,806 B / 3f48643d8e7bac77… carrying the green pill, as of ×1 and not re-checked since ×1 — G10 passes it, G12 refuses it.
• Prediction stated before the run and met exactly: shipped rc 1 / 187 passed, 1 failed (sole failure G10's row), twice at 16,212 B each; twin rc 1 / 186 passed, 2 failed at 16,583 B, adding G12 row 1. live_moved: {}, sandboxes_after: [] on all three legs. Byte-stability measured: G12 rows identical across both shipped runs; stdout identical after sandbox normalisation, residual 0, normalised sha256 7a080e1616fb20e3e9685d67cb121b9a8af35614a7edba7b649aeca62e2612d0.
• Live state delta 0 on bytes + sha256 + mtime_ns across every leg: page 9,865 B / 427b7b54c69b18d2…; snapshot 14,039 B / aa842b0fd88037f8…; held pin 120 B / 5b6d70716153c3f4…. Deployed /root/.helm/bin/ untouched (five digests re-read plus the __pycache__/), grep -c HELM_COLLECTOR = 0 so Q40 stands. Sandboxes 0. Disk 41 G avail of 154.
• A defect of mine, logged first: the runner's stdout normaliser matched (helm-legs-|/tmp/tmp) but this host's TMPDIR is /root/.hermes/profiles/merlin/cache/scratch, so it reported residual 2 with no characterisation. The two lines were printed, the pattern corrected, the run re-run, and §6's figures are the corrected ones. No G12 row or verdict depended on it.
• Nothing deployed, no another-party file edited, no secret printed. No item closed, none opened — the Helm executable set was empty at the start of the run.

Blocked. Nothing, on my side. Standing and still human-gated, unchanged and not re-argued: the §4 adoption cp (now collector 4e45021d80395d3f… + gate 4b18329c7437bec4…, this run's, superseding 125754b270bf…), the stale manifest_match pin, the G10 re-render, Q13's publication call, Q9's checksum handover, Q19's onboarding.

Next. The gate is written and green on today's page; the remaining Helm step is the adoption cp plus the re-render and deploy that G10, G11 and G12 all measure as outstanding — one sequence, an operator's call under §4, and not mine to execute. With that done the Helm lane's executable set returns to empty and its next unit is again a decision rather than a task.

Ask. Alexander: the adoption sequence is now four files — renderer 306d4bee…, collector 4e45021d80395d3f…, gate 4b18329c7437bec4…, then re-collect, re-render and deploy. Adopting the renderer alone would leave G10's and G12's rows red, so the order matters and it is stated in the record. Nothing else is asked of the pipe; Timmy's reply 58 carried no ask and discharged reply 57's two corrections, which this run did not disturb.

---

Run 33 landing evidence

Read back over the anonymous raw commit path (https://forge.alexanderwhitestone.com/git/stackchain/troupe-standup/raw/commit/<rev>/<path>, no credential) by python3 /root/crucible/q62/readback_r33.py, exit 0, VERDICT: ALL READBACKS IDENTICAL, artifact out/R33-READBACK.json (2,652 B / sha256 2e04f96b7900b8748d9831952eade8a5ca77eb93d2073add4de241e8a9149d3a, host-local, E13's rule), read at 2026-10-15T01:23:51+00:00 at revision 63158803e824b025ae874cd28d477a687986f093 — all four rows HTTP 200 and byte-identical on three sides (served = disk = git cat-file -p 63158803:<path>):

file	HTTP / bytes	sha256 (served = disk = git)
recoveries/helm-deployed-pill-guard.md	200 / 11,418	b7137bc469ee9cd8d07f85822cdd24bdbab44edbf496a2c85a32b73ff6d88d82
checkins/2026-10-15-merlin.md	200 / 5,749	078912920033a1ee1657d601eaa03d77dbc5e146917cedc763e79f6a6cb2c8d3
WORK-QUEUE.md	200 / 1,142,615	571133bddda96bc4b92d0999a683fb48bfefddd1022189a4d54221ae9930f79b
replies/2026-10-15-to-timmy-58.md	200 / 11,217	cca7de7baa70d65b… (full digest in the artifact)

The check-in's own row is this file at 63158803, the revision before this append — a file cannot cite its own post-append digest, so the row is dated rather than chased. All four files are newline-terminated (trailing_newline: true on every row, asserted by the script).

The landing deltas, measured from git rather than from the append scripts. git diff --numstat 07fdaf9c 63158803 = 80/0 on the queue, 78/0 on this file, 199/0 on the record, 95/0 on the reply = 452 insertions, 0 deletions (--shortstat → 4 files changed, 452 insertions(+)). Append-only is asserted, not claimed: the commit script refuses if any row reports a deletion, so no committed line moved and no line-number citation in the archive shifts. The queue's 80 lines are the G12 block appended after the Run 32 block; this file's 78 are its pre-append content.

Provenance, asserted not assumed: author and committer both Merlin <merlin@agents.invalid> (git -c), so the monitor sees it as counterparty content per Q36's v1.3 rule; git log --author=merlin --oneline | wc -l = 103 after the commit (102 before the push — the Run 24/25 lesson: a commit with no -c override is authored by the clone's identity and the count silently misses the run). git ls-remote origin main = 63158803…, so served = remote = disk.

Live state at the readback, delta 0 across the whole run (bytes + sha256 + mtime_ns, re-measured by measure_final.py at 01:20:25Z and unchanged since): page 9,865 B / 427b7b54c69b18d2…; snapshot 14,039 B / aa842b0fd88037f8…; held pin 120 B / 5b6d70716153c3f4…. Deployed /root/.helm/bin/ untouched and grep -c HELM_COLLECTOR /root/.helm/bin/helm-selftest.py = 0 — Q40 stands, so nothing of Q31–Q62 is in production. Sandboxes 0/0/0. Worktree clean. Disk 41 G avail of 154 (74 % used).

Nothing was deployed, published, rebuilt or re-run beyond the gate's own three legs and their measurements; decisions/ and inbox/ untouched; no another-party file edited; no secret printed — the long strings are gate report lines, file paths and sha256 digests.

— Merlin (Run 33, landing)

Run 33 closing note — the final revision is 0852bf7bb5c35d07fdcb612327b264352a607c00. Two commits carry the unit's substance: 6315880 (the deliverable, the queue block, the check-in and the reply, 4 files / +452 −0) and 0852bf7 (the landing fill, 1 file / +57). Read back over the anonymous raw commit path (.../raw/commit/0852bf7/<path>, no credential) — all four rows HTTP 200 and served = disk = git cat-file -p 0852bf7:<path>:

file	HTTP / bytes	sha256
checkins/2026-10-15-merlin.md	200 / 9,138	def4c796673c83ae7ba4fa625d35a1404bcb074783ab17693e405fa2ceca940a
recoveries/helm-deployed-pill-guard.md	200 / 11,418	b7137bc469ee9cd8d07f85822cdd24bdbab44edbf496a2c85a32b73ff6d88d82
WORK-QUEUE.md	200 / 1,142,615	571133bddda96bc4b92d0999a683fb48bfefddd1022189a4d54221ae9930f79b
replies/2026-10-15-to-timmy-58.md	200 / 11,217	cca7de7baa70d65b… (full digest in out/R33-READBACK.json)

Erratum, mine, and it is a rendering defect the readback could not see. The queue block and this file's first section were written by append scripts that escaped six characters as the six-character text \u2014 rather than the em dash it denotes. Measured with grep -oF before the fix: 29 occurrences in WORK-QUEUE.md, 43 in this file, 0 in the reply and 0 in the record — the reply and the record are clean because they were written with real characters, which locates the cause in my escaping and not in the pipeline. Fixed by /root/crucible/q62/fix_escapes_r33.py and landed in its own commit (WORK-QUEUE.md 1,142,615 → 1,142,524 B / d2f24b0e160635e4…, −91 B; this file 9,138 → 9,000 B / d60e847e143c0e97…, −138 B), with the per-sequence delta asserted from each character's own encoded length and residual 0 on all four files. The tables above carry the pre-fix digests because that is what 0852bf7 serves, and they are labelled as such; no figure, verdict or measurement moved — the defect was typographic.

Why the readback missed it, stated plainly: all four rows were HTTP 200 and byte-identical on three sides (served = disk = git) at both 6315880 and 0852bf7. The readback proves the landing. A landing check cannot see a rendering defect, because the wrong bytes landed exactly as written. That is this lane's own logged class — the instrument that proves delivery does not prove correctness — and it is why the fix's own assertion is a per-sequence byte delta rather than a claim.

A third defect of mine, in the same hour, both logged: the first version of fix_escapes_r33.py asserted the delta as −4 bytes per occurrence for every sequence, but § and × are 2 bytes in UTF-8 while –, — and … are 3 — the measured −91 was right and my expected −116 was wrong. And the first version of closing_r33.py ran the readback before committing the escape fix, so it compared fixed disk against unfixed git and refused with MISMATCH on exactly the two rows the fix touched; the instrument was right and the ordering was wrong, since a readback's whole claim is served = disk = git at a revision that exists. Both are corrected in the scripts as they now stand, and neither moved a figure.

Live state at the closing read, delta 0 across the whole run: page 9,865 B / 427b7b54c69b18d2…; snapshot 14,039 B / aa842b0fd88037f8…; held pin 120 B / 5b6d70716153c3f4…. Deployed /root/.helm/bin/ untouched, grep -c HELM_COLLECTOR = 0 (Q40 stands, so nothing of Q31–Q62 is in production); worktree clean; sandboxes 0; disk 41 G avail of 154.

One line on the unit, for whoever reads this next: the Helm lane's gates had been checking the renderer and, since G10, the deployed page's qualifier. G12 closes the other half of that cell — the pill — on the artifact the public reads, and the reason it took a second attempt is that the obvious predicate turned out to be provably redundant with G10. The discriminator is not a construction: it is the byte-identical twin of production's own renderer, which is why the rule could be shown to fire on something that could actually be deployed.

— Merlin (Run 33, closing)

---

Run 34 — the pin pill against ground truth

Screen. Same screen as Run 33, re-measured rather than carried: the queue's own hygiene ledger at :8017 still records 9 opening markers, 8 belonging to closed items, 1 genuinely open (Q52, Mercury's), and every **Status: line in the file matching an open/unclaimed form names a closed item except Q9, which its own record has blocked on the audio-handover decision. The Helm lane's executable set is empty by both this lane's and the pipe's measurement, and everything standing is human-gated. So the queue offered no finishable item and I continued my lane, discharging the one limit G12's own record named and left open: "no fuzzer, the enumerated render set only." The run's instruments are stamped 03:39 (the cell space), 03:50:24 (the matrix) and 03:50:56 (the final census) on 2026-10-15.

Did. Two findings, one predicate fix, one new guard — and the first configuration this gate has ever been able to pass.

• The cell space, measured before anything was built. Six reachable cells of the pill x qualifier pair, five of them real renders of the real renderers on the real snapshot (q63/make_cells.py -> R34-CELLS.json): green+both strings, green+no disclaimer (twice, from the production renderer and the G11-patched one), amber+both strings, green+neither string (the deployed page), and red+no disclaimer (the one constructed cell). Ground truth in the same run: a fresh fetch of the snapshot's own URL returns HTTP 200 / 217,163 B / c34ae2c245117ca7… against a held pin of f27326e8b13d1dec…, so pin_matches_live_now is false.
• Finding 1 — G10's predicate had no cell for the honest fresh state. helm-render-plain.py:329 appends " · not re-checked since" only when site_fresh != "FRESH", so a predicate demanding both strings refuses the fresh generation and the end state of G10's own remedy is red exactly like today's unfixed page. Evidence, one body two predicates: the base gate with the fresh cell as its subject is 187/1 with G10's row FAIL (control-q62-freshcell.py, 171,975 B / c05dd15f…); the new gate on the same body with the same repoint is 190/1 with G10's row PASS (twinD, 180,768 B / ef9980cc…). The fix splits the predicate into its two halves and reads freshness from the age the page's own qualifier states, against the collector's own 3600 s threshold.
• Finding 2 — no gate asked whether the pill was true, and G11 does not close it. G10 owns the missing clock, G12 owns the incoherent pair; the fresh cells carry an unqualified green match beside a fresh-looking clock while the pin does not match the live body, and G12 pairs the pill only with the disclaimer. G13 is the guard: offline, the pill's colour must agree with the held pin against the live-body hash the page publishes; live, a fresh fetch must confirm an unqualified green pill — red today, and that red is the finding; plus a read-only row. Row 2 subsumes G12 on one cell and adds three G12 cannot see, which is stated in the record rather than left for a reader to find.
• The gate and the matrix. Base 4b18329c7437bec4… (171,979 B / 3,256 lines / 138 registrations) -> shipped helm-selftest-q63.py 180,772 B / 3,432 lines / 141 registrations / 94f9b3625e5791a7…, +8,793 B / +176 lines / +3 registrations, four twins and one control each one to three asserted lines different. Subject 4e45021d80395d3f… / 29,954 B throughout. Seven configurations, prediction stated before the run and met exactly: shipped 189/2 twice, twinA 188/3, twinB 190/1, twinD 190/1, control 187/1 — and twinC rc 0, 191/0, ALL GATES PASS, the honest remediated state, the only configuration the gate has ever been able to pass.
• Live state delta 0 on bytes + sha256 + mtime_ns across all seven legs: page 9,865 B / 427b7b54c69b18d2…; snapshot 14,039 B / aa842b0fd88037f8…; held pin 120 B / 5b6d70716153c3f4…. Deployed /root/.helm/bin/ untouched, grep -c HELM_COLLECTOR = 0 so Q40 stands. Sandboxes 0/0. Disk 41 G free of 154. The two shipped runs are byte-identical after normalising the four mkdtemp shapes, residual 0.
• Four defects of mine, logged first: the first probe fetched the portfolio instead of the pin's subject and would have made the drift finding true for the wrong reason; the first normaliser missed this host's TMPDIR-based mkdtemp (Run 33's own blind spot, reproduced by its author); the first G13 block referenced four names it had not imported and died at line 3274; and twinC's third repoint silently did not apply until an assertion caught it.

Blocked. The remediation, not the work. G13 detects and cannot repair: the remedy is re-collect -> re-render -> deploy, an operator's call under §4, and the gate is red on today's page for a real and named reason — a green pill a fresh fetch refutes. Standing and still human-gated, unchanged and not re-argued: the §4 adoption cp (now collector 4e45021d80395d3f… + gate 94f9b3625e5791a7…, this run's, superseding 4b18329c…), the stale manifest_match pin, the Q13 publication call, Q9's checksum handover, Q19's onboarding. Run 33 still awaits the pipe's verification; reply 58 discharged Run 32 and carried no ask of this lane.

Next. The adoption sequence is four files in one order — renderer 306d4bee…, collector 4e45021d…, gate 94f9b362…, then re-collect, re-render, deploy — and the re-collect is now load-bearing rather than cosmetic, because G13's live row stays red until a collect recomputes manifest_match against the live body. With that done the Helm lane's executable set returns to empty and its next unit is again a decision rather than a task.

Ask. Alexander: the adoption order, and the acceptance criterion that did not exist before this run — the sequence is done when the gate reaches twinC's shape, rc 0 / 191 passed / 0 failed / ALL GATES PASS, which today's page cannot reach and a correctly re-collected page can. Nothing is asked of the pipe; no counterparty ask arrived this run.

— Merlin (Run 34)

---

Run 34 landing evidence

Read back over the anonymous raw commit path (https://forge.alexanderwhitestone.com/git/stackchain/troupe-standup/raw/commit/<rev>/<path>, no credential) by python3 /root/crucible/q63/readback_r34.py, exit 0, VERDICT: ALL ROWS EQUAL, artifact out/R34-READBACK.json (1,699 B, host-local, E13's rule), read at 2026-10-15T03:54:25+00:00 at revision 420c826382f869b5850ea102d9de7e9081fe2a75 — all three rows HTTP 200 and byte-identical on three sides (served = disk = git cat-file -p 420c826382f869b5850ea102d9de7e9081fe2a75:<path>):

file	HTTP / bytes	sha256 (served = disk = git)
recoveries/helm-pill-ground-truth.md	200 / 14,419	d6600fd195e4b11c937b6512366242c92269243293c84a28e56c0d51d54b38bb
WORK-QUEUE.md	200 / 1,150,863	2993a470d0a847b448f53348e87ed38f426d39a173c12981031e4f9aec978a8e
checkins/2026-10-15-merlin.md	200 / 19,520	8b41a75db0ee2ff0c076626c1d80fb7f049b1027e9536521c26e5a87e00dce8f

The check-in's own row is this file at 420c826382f8, the revision before this append — a file cannot cite its own post-append digest, so the row is dated rather than chased. All three files are newline-terminated (trailing_newline: true on every row, asserted by the script).

The landing deltas, measured from git rather than from the append scripts. git diff --numstat d1e5c354f75d 420c826382f8 = 118/0 on the queue, 96/0 on this file, 262/0 on the record = 476 insertions, 0 deletions (--shortstat → 3 files changed, 476 insertions(+)). Append-only is asserted, not claimed: the commit script refuses if any row reports a deletion, so no committed line moved and no line-number citation in the archive shifts. The queue's 118 lines are the G13 block appended after the Run 33 close at line 9,243; this file's 96 are its pre-append content; the record is new.

Provenance, asserted not assumed: author and committer both Merlin <merlin@agents.invalid> (git -c), so the monitor sees it as counterparty content per Q36's v1.3 rule; git log --author=merlin --oneline | wc -l = 107 after the commit. git ls-remote origin main = 420c826382f8… = local HEAD, so served = remote = disk.

Live state at the closing read, delta 0 across the whole run (bytes + sha256 + mtime_ns, re-measured by final_r34.py at 03:50:56Z and unchanged since): page 9,865 B / 427b7b54c69b18d2… / mtime_ns 1791709034017837233; snapshot 14,039 B / aa842b0fd88037f8… / 1791479579475780303; held pin 120 B / 5b6d70716153c3f4… / 1791478687099553071. Deployed /root/.helm/bin/helm-selftest.py untouched (7ed1bca8f9da624f…, 33,647 B) and grep -c HELM_COLLECTOR = 0 — Q40 stands, so nothing of Q31–G13 is in production. Sandboxes 0/0. Disk 41G free of 74%. Worktree dirty rows at the closing read: (none beyond this append).

A defect of mine in the append script, logged: its hygiene assertion was assert "\u20" not in text over each whole file, and it fired on checkins/2026-10-15-merlin.md — not on this run's text but on Run 33's erratum at line 153, which quotes the six-character escape sequence deliberately as the thing it is describing. The assertion was too broad, not the append wrong. Verified by scope rather than by re-running: grep -c '\\u20' returns 1 in the check-in (line 153, pre-existing prose) and 0 in the queue, and the appended Run 34 blocks carry none. Nothing was re-appended, so no duplicate block exists.

One line on the unit, for whoever reads this next: G10 owned the missing clock and G12 owned the incoherent pair, and between them they covered every cell of the pill's presentation while leaving its truth unread. G13 is the first guard in this lane that compares a claim against the thing it claims about, and the reason the gate can now reach ALL GATES PASS at all is that G10's predicate stopped refusing the honest fresh state it had been refusing since it was written.

— Merlin (Run 34, landing)

---

Run 35 — the pin pill in both directions

Screen. Same screen as Runs 33 and 34, re-measured rather than carried: the queue's hygiene ledger at :8017 still records 9 opening markers, 8 belonging to closed items, 1 genuinely open (Q52, Mercury's), and every **Status: line matching an open/unclaimed form names a closed item except Q9, blocked on the audio handover by its own record. The Helm lane's executable set was empty and everything standing is human-gated — so the queue offered no finishable item and I continued my lane, discharging Run 34's own stated open limit: "Row 1 is green on all six cells today, so it has never fired … not a demonstrated catch." Clock read 2026-10-15T05:58:02Z before the work began.

Did. One demonstrated catch, one hole, one new row — and the second passing configuration this gate has ever reached. Deliverable recoveries/helm-pill-both-directions.md (13,535 B). Gate helm-selftest-q64.py 182,752 B / 3,464 lines / 142 registrations / 6a887f42754a8d96… on Run 34's 94f9b3625e5791a7…: +1,980 B / +32 lines / +1 registration, four asserted anchors, four twins and one control.

• Ground truth: live body 200 / 217,163 B / c34ae2c245117ca7…; held pin 120 B / f27326e8b13d1dec…; pin_matches_live_now false; snapshot manifest_match: true with live_body_sha256 equal to the pin and observed_at 2026-10-08T17:12:59.458Z. The page's "live body sha256 f27326e8b13d1dec…" is a present-tense claim of a six-day-old frozen value — the pill's defect class, one line below it, read by no gate.
• Finding 1 — row 1's catch is real and sits inside the lane's own adoption sequence. helm-collect.py:647–662 re-pins from the live body and exits without rendering, so re-pin → page not yet re-rendered is reachable by the collector's own --pin. twinE (only _g13_pin repointed at the live body's hash): row 1 FAIL, row 2 PASS — the failing G13 row moves from row 2 to row 1, 190/2.
• Finding 2 — the hole between the two rows. Row 2 passes whenever the green pill is absent, so a drift claim is unverifiable by construction. The falsered cell under the shipped gate: control-g rc 0 / 191/0 / ALL GATES PASS. A false drift sails through the gate that exists to check the pill's truth.
• G13 row 3 — a red pill must also be confirmed by a fresh fetch (the live body must not match the pin). Offline measured with a dead proxy: rc 1, 191/1, sole failure row 3, fetch_error=URLError(ConnectionRefusedError(111,…)). The three rows are transitively closed for the pill's class — page-published vs pin and pin vs live covers page vs live — which is why no fourth row is owed.
• Matrix, prediction stated before the run: shipped rc 1 / 190/2 twice, byte-identical after normalisation; twinE 190/2 (row 1 fires, row 2 flips PASS); twinF rc 0 / 192/0 / ALL GATES PASS — the honest remediated end state, the second configuration this gate has ever passed; twinG 191/1, row 3 only; twinH 192/0 — a true drift claim is not refused; control-g 191/0 — the hole. twinG/control-g isolates row 3 and nothing else (pair_isolates_row3: true).
• Live state delta 0 across all seven legs (bytes + sha256 + mtime_ns): page 9,865 B / 427b7b54c69b18d2…; snapshot 14,039 B / aa842b0fd88037f8…; held pin 120 B / 5b6d70716153c3f4…. Deployed /root/.helm/bin/ untouched, grep -c HELM_COLLECTOR = 0 so Q40 stands. Sandboxes 0/0/0. Disk 41 G free of 154.
• Four defects of mine, logged first: my twinE prediction named two failures while printing 189/3 (the row-level prediction was met exactly); the first cell set left observed_at at the 2026-10-08 stamp, so twinF was the stale cell and came back red on G12 — nearly recorded the remediated state as unpassable; the runner's first run died on its own set-in-JSON bug before writing the artifact; and the runner's docstring still carries the original prediction, because a prediction edited after the run is not a prediction.

Blocked. The remediation, not the work — unchanged in kind from Runs 33 and 34 and not re-argued: the §4 adoption cp (now renderer 306d4bee…, collector 4e45021d80395d3f…, gate 6a887f42754a8d96…, this run's, superseding 94f9b362…), the stale manifest_match pin, the Q13 publication call, Q9's checksum handover, Q19's onboarding. The pipe's reply 59 verified Runs 33 and 34 end to end with no correction of mine or theirs; nothing in this run disturbs it.

Next. The adoption sequence is four files in one order — renderer, collector + gate, then re-collect, re-render, deploy — and it is now load-bearing twice: G13's live row stays red until a collect recomputes manifest_match, and Finding 1 shows the re-pin inside a collect can leave the page and the pin disagreeing until the re-render lands. With that done the Helm lane's executable set returns to empty and its next unit is again a decision rather than a task.

Ask. Alexander: the adoption order, and the acceptance criterion, now demonstrated twice — the sequence is done when the gate reaches twinF's shape, rc 0 / 192 passed / 0 failed / ALL GATES PASS, which today's page cannot reach and a correctly re-collected, re-rendered page can. Nothing else is asked of the pipe; reply 59 carried no ask of this lane and discharged Runs 33 and 34 in full.

---

Run 35 landing evidence

Read back over the anonymous raw commit path (https://forge.alexanderwhitestone.com/git/stackchain/troupe-standup/raw/commit/<rev>/<path>, no credential) by python3 /root/crucible/q64/readback_r35.py, exit 0, VERDICT: ALL ROWS EQUAL, artifact out/R35-READBACK.json (host-local, E13's rule), read at 2026-10-15T06:13:48+00:00 at revision 0b783b6770ece59b4194f7c1a96779380a39be77 — all four rows HTTP 200 and byte-identical on three sides (served = disk = git cat-file -p 0b783b67:<path>):

file	HTTP / bytes	sha256 (served = disk = git)
recoveries/helm-pill-both-directions.md	200 / 13,535	8536781b5566390d…
replies/2026-10-15-to-timmy-60.md	200 / 5,698	73ada303d0d0db55…
WORK-QUEUE.md	200 / 1,155,433	11b85674e04310b0…
checkins/2026-10-15-merlin.md	200 / 29,135	3cdb2323f02dbdb0…

The check-in's own row is this file at 0b783b67, the revision before this append — a file cannot cite its own post-append digest, so the row is dated rather than chased. All four files are newline-terminated (trailing_newline: true on every row, asserted by the script). Full digests are in out/R35-READBACK.json.

The landing deltas, measured from git rather than from the append scripts. git diff --numstat 8a99383 0b783b67 = 69/0 on the queue, 89/0 on this file, 224/0 on the record, 91/0 on the reply = 473 insertions, 0 deletions (--shortstat → 4 files changed, 473 insertions(+)). Append-only is asserted, not claimed: the commit script refuses if any row reports a deletion, and the append script asserts each target's new bytes start with its old bytes, so no committed line moved and no line-number citation in the archive shifts. The parent is the pipe's reply 59 (8a99383), so this run's commit sits directly on the counterparty's.

Provenance, asserted not assumed: author and committer both Merlin <merlin@agents.invalid> (git -c), so the monitor sees it as counterparty content per Q36's v1.3 rule; git log --author=merlin --oneline | wc -l = 109 after the commit. git ls-remote origin main = 0b783b67… = local HEAD, so served = remote = disk.

Live state at the closing read, delta 0 across the whole run (bytes + sha256 + mtime_ns, re-measured by final_r35.py at 06:14Z and identical to the census the matrix took before its first leg): page 9,865 B / 427b7b54c69b18d2… / mtime_ns 1791709034017837233; snapshot 14,039 B / aa842b0fd88037f8… / 1791479579475780303; held pin 120 B / 5b6d70716153c3f4… / 1791478687099553071. Deployed /root/.helm/bin/helm-selftest.py untouched (33,647 B / 7ed1bca8f9da624f…) and grep -c HELM_COLLECTOR = 0 — Q40 stands, so nothing of Q31–G13's row 3 is in production. Sandboxes 0/0/0. Disk 41 G free of 154 (74 % used). Worktree clean beyond this append.

Nothing was deployed, published, rebuilt or re-run beyond the gate's own seven legs and their measurements; decisions/ and inbox/ untouched; no another-party file edited; no secret printed — the long strings are gate report lines, file paths and sha256 digests.

One line on the unit, for whoever reads this next: G13's two rows covered the pill's presentation and, between them, every cell of its truth in the green direction — and row 1's catch turned out to sit in the middle of the lane's own adoption sequence, reachable by the collector's own --pin. Row 3 closes the red direction, and the three together are transitively closed: a page that publishes one hash, holds another, and is fetched against a third has nowhere left to hide.

— Merlin (Run 35, landing)

Run 36 — the live-body-sha line's own clock

Did. G14 — the page's "live body sha256" line, the residual Run 35's own record named and left open, discharged; and a deploy sandbox that never left, measured and fixed.

The line renders live body sha256 f27326e8b13d1dec… on the deployed page — the held pin, frozen 2026-10-08T16:58:07.100Z, while the live body today is c34ae2c2… (200 / 217,163 B). G10 owns the page clock, G12 the pill's pairing, G13 the pill's truth; nothing read that line.

• The obvious predicate was falsified before it shipped (q65/probe_r36.py → out/R36-PROBE.json): ("live body sha256" not in text) or ("as of " in text) is strictly weaker than G10, whose own predicate already requires both clock strings. The distinguishing cell is real: the G11 renderer (306d4bee…, the lane's current adoption payload) at the stale clock emits 11,819 B / 951a8a7645fe7ef4… (reproducing Run 29's and Run 33's recorded digest) on which G10, G12 and G13 row 1 all PASS while the hash line is an unqualified present-tense claim. That body is what the section-4 adoption would deploy today. The rule that survives: the element containing live body sha256 must itself contain as of.
• Renderer fix (q65/make_renderer_g14.py, one edit at a unique asserted anchor, pre-image preserved byte-exact at helm-render-g14-pre36.py): helm-render-g14.py 22,930 B / sha256 a70998c8592a03cd… / 514 lines. Emitted bytes, all rc 0: g14-stale 11,917 B / ecb5838ed2953942 (as of in the hash element, True); g14-fresh 11,695 B / 410e2f57b2aae51c (True); the g11 controls reproduce 951a8a76… / 1eec213e… exactly. The qualifier's tail appears only on the stale branch, same rule as the pill.
• Gate (q65/build_r36.py from 6a887f42754a8d96… at five asserted anchors, +3 registrations): helm-selftest-q65.py 190,330 B / 3,619 lines / 145 check( registrations / 833d08275977054a…. Matrix (run_matrix_r36.py → out/R36-GATE.json, prediction stated before the run, live censused around every leg, live_delta_empty_all_legs: true): shipped rc 1, 192 passed / 3 failed (G10 deployed-page, G13 row 2 live, G14 row 1) — met exactly, and byte-identical on the second run after sandbox normalisation (sha256 07c1c58ddb969403…, residual 0); twinI (g14-stale cell) rc 0, 195/0, ALL GATES PASS — met exactly, the honest remediated state; twinJ (g11-stale cell, the adoption payload) rc 1, 194/1 — G14 row 1 only, its evidence line quoting the unqualified element — met exactly; control-g (the q64 gate under twinJ's repoints) rc 0, 192/0, ALL GATES PASS — met exactly, the hole measured: the adoption payload passes every gate the lane has today.
• twinK (g14-fresh cell) did not meet its prediction: rc 1, 194/1, G13 row 2 — and that is a finding, not just a miss of mine. A fresh clock on the frozen manifest_match is still caught by G13 row 2 (pin_matches_live_now=False). The renderer alone does not make the page passable; re-collect → re-render → deploy does — the sequence the lane has carried since Run 28, now with the renderer first.
• A sandbox leak, measured and fixed (sandbox_probe.py, one leg): /tmp/q31-g8-deploy-* grew +1 per gate run, 474 directories on /tmp at the final census; the Q31/G8 --deploy leg's mkdtemp was never removed. Edit B captures the directory and removes it after the two G8 checks that read it. My first form put the removal in the finally and turned both rows red (measured shipped 190/5, twinI 193/2); the second form ships. Post-fix delta 0 on all five q65 legs; control-g, the unfixed base, still leaks its one — the hole leaks too.
• Record: recoveries/helm-hash-line-qualifier.md (13,678 B / sha256 d92f5b7ce9fab458…, this host, at the write).
• Live state, delta 0 across all seven legs (out/R36-GATE.json per-leg live_unchanged: true ×6; out/R36-FINAL.json): page 9,865 B / 427b7b54c69b18d2… / mtime_ns 1791709034017837233; snapshot 14,039 B / aa842b0fd88037f8… / 1791479579475780303; held pin 120 B / 5b6d70716153c3f4… / 1791478687099553071. Deployed /root/.helm/bin/ untouched — five digests re-read (ee0b36a82f23fcf3…, 5c67473d89283c3d…, 7ed1bca8f9da624f…, 12570786ba703787…, 7386999867789694…) plus the __pycache__/ an adoption must not copy in — and grep -c HELM_COLLECTOR = 0, so Q40 stands and none of Q31–G14 is in production. Disk 41 G free of 154 (74 %). Nothing deployed, no another-party file edited, decisions/ and inbox/ untouched, no secret printed.
• Reply 60's correction discharged: pin_stackchain is defined at helm-collect.py:664, not 647–662 — verified this run with grep -n 'def pin_stackchain' /root/crucible/q48/helm-collect.py → 664:def pin_stackchain():. Run 35's record cited the older span; the collector's own line numbers stand as the pipe read them, and this run's record uses 664.

Blocked. The remediation, not the work — unchanged in kind from Runs 33 through 35, and now demonstrated insufficient in one step: twinK measures that adopting the G14 renderer without a re-collect leaves G13 row 2 red, because manifest_match is the collector's frozen field. Standing and still human-gated: the §4 adoption sequence, the stale manifest_match pin (measured false, four times now, on four instruments — the held pin f27326e8… against the live body 200 / 217,163 B / c34ae2c2…), the Q13 publication call, Q9's checksum handover, Q19's onboarding.

Next. The adoption sequence is five files in one order — adopt renderer a70998c8… (22,930 B, superseding 306d4bee…) → adopt collector 4e45021d… (29,954 B) + gate 833d0827… (190,330 B, superseding 6a887f42…) → re-collect → re-render → deploy. The acceptance criterion is unchanged and now demonstrated a third time: rc 0 / 195 passed / 0 failed / ALL GATES PASS (twinI's shape). The re-collect is load-bearing three times over: G13's live row, Run 35's re-pin finding, and the G14 qualifier's truth. The 474 pre-existing q31-g8-deploy-* directories are host residue; the leak is closed going forward, and removing the old ones is a host operation this run did not take.

Ask. Alexander: the same adoption decision, one item wider than last run — the renderer is now an adoption object (twinK measures that a re-render on the current payload publishes a page this gate refuses), and the gate supersedes again. Nothing new is raised beyond that; every other open item belongs to another lane or to you. One convention note, not an ask: Merlin's replies are filed in the to-timmy-NN series per the naming rule reply 56 settled; this run writes no reply because reply 60 left no ask and nothing of a counterparty's is outstanding.

Run 36 landing evidence

Read back over the anonymous raw path (no credential) by python3 /root/crucible/q65/readback_r36.py, exit 0, VERDICT: ALL ROWS EQUAL, artifact out/R36-READBACK.json (host-local, E13's rule), read at 2026-10-15T08:43Z at revision be55b9542c3b0cef48f8719b9d823efd2dab529b — all three rows HTTP 200 and byte-identical on three sides (served = disk = git cat-file -p be55b95:<path>):

file	HTTP / bytes	sha256 (served = disk = git)
recoveries/helm-hash-line-qualifier.md	200 / 13,678	d92f5b7ce9fab458…
checkins/2026-10-15-merlin.md	200 / 39,888	b52a155807e4b915…
WORK-QUEUE.md	200 / 1,166,035	c0264da97bd49360…

The check-in's own row is this file at be55b95, the revision before this append — a file cannot cite its own post-append digest, so the row is dated rather than chased. All three files are newline-terminated (trailing_newline: true on every row, asserted by the script). Full digests are in out/R36-READBACK.json.

The landing deltas, measured from git rather than from the append scripts. git diff --numstat 822f2d4 be55b95 = 74/0 on the queue, 107/0 on this file, 237/0 on the record = 418 insertions, 0 deletions (--shortstat → 3 files changed, 418 insertions(+)). Append-only is asserted, not claimed: the commit script refuses if any row reports a deletion, and the append script asserts each target's new bytes start with its old bytes, so no committed line moved and no line-number citation in the archive shifts. The parent is the pipe's tick block (822f2d4, authored Timmy <timmy@stackchain.ai>), so this run's commit sits directly on the counterparty's.

Provenance, asserted not assumed: author and committer both Merlin <merlin@agents.invalid> (git -c), so the monitor sees it as counterparty content per Q36's v1.3 rule; git log --author=merlin --oneline | wc -l = 111 after the commit. git push readback 822f2d4..be55b95 main -> main, so served = remote = disk.

Live state at the closing read, delta 0 across the whole run (bytes + sha256 + mtime_ns, final_r36.py → out/R36-FINAL.json, identical to the census the matrix took before its first leg): page 9,865 B / 427b7b54c69b18d2… / mtime_ns 1791709034017837233; snapshot 14,039 B / aa842b0fd88037f8… / 1791479579475780303; held pin 120 B / 5b6d70716153c3f4… / 1791478687099553071. Deployed /root/.helm/bin/ untouched — five digests re-read (ee0b36a82f23fcf3…, 5c67473d89283c3d…, 7ed1bca8f9da624f…, 12570786ba703787…, 7386999867789694…) — and grep -c HELM_COLLECTOR = 0, so Q40 stands and nothing of Q31–G14 is in production. Disk 41 G free of 154 (74 %). Worktree clean beyond this append (the two append-source files were scratch and are deleted, not committed).

Nothing was deployed, published, rebuilt or re-run beyond the gate's own seven legs and their measurements; decisions/ and inbox/ untouched; no another-party file edited; no secret printed — the long strings are gate report lines, file paths and sha256 digests.

One line on the unit, for whoever reads this next: the page has now had every present-tense claim it publishes either qualified or guarded — the qualifier by G10, the pill's coherence by G12, the pill's truth by G13's three rows, the hash line's clock by G14 — and the adoption payload that would have shipped today fails exactly one of them, which is the whole argument for the sequence in the Ask.

— Merlin (Run 36, landing)

---

Run 37 — 11:0xZ: the claim check, re-generated on a corrected instrument

Screen. The queue offered no finishable item, and this run measures that rather than inheriting it. The hygiene ledger the queue's own convention names (:8020, 2026-10-13T23:18Z) predates Runs 22–36, so I re-generated the claim check myself on a new instrument instead of reading it. Clock read 2026-10-15T11:00:02Z before the work began.

Did. The queue hygiene census — the claim check the queue's convention requires before taking an item whose opening line reads open or unclaimed. Record recoveries/queue-hygiene-census.md (10123 B / sha256 eb0e1b4f5fa8733fb12eba758d9543a60eb85b8f12f5f7fc79b9908300d2405d). Instrument /root/crucible/q66/q66_census6.py (4,388 B / sha256 e340b105dd96955f…, host-local scratch; six generations, 21,845 B, every defect logged rather than deleted).

• Result: 15 opening records, 80 closure lines indexed, 12 closed / 3 genuinely open. Validated against eleven answers read by hand from the queue before the run (Q21/Q24/Q25/Q45/Q46/Q47/Q49/Q50/Q51/Q52 closed, Q53 open) → 11 / 11, VALIDATION PASS. Queue at HEAD 1,170,483 B / 9,533 lines / 49 ## Q sections.
• The method is the finding. Opening records are keyed on their shape, which is what catches Q50/Q51/Q52/Q53 — their opening records are bullet lines nested inside other sections, not ## headers, so a header walk cannot do this job. Closures are item-anchored and searched whole-file, because this queue is append-only and a closure lands at the tail.
• Six generations of instrument defect, logged first; four erred in the dangerous direction. v1 walked only ## headers and matched the word "open" (missed Q50–Q53, false-flagged Q5/Q7/Q14); v2 caught Q7 continuation notes as openings; v3 cut its region at a --- rule (false OPEN for Q25 and Q49) and counted "Done means:" as a closure word (false CLOSED for Q53); v4 did not anchor closures to the item (Q53 closed off an unrelated G11 block at :8839); v5 scoped the closure search to the region before the next opening record, so Q52 read OPEN though **Q52 — DONE at 4010b96 sits at :8517. v6 passed. Every defect was the instrument's, not the queue's — and a closed item reading claimable is the exact failure the convention exists to prevent.
• The three genuinely open, and why none is mine. Q53 :8530 — Mercury's, R5-a/R5-b carried in replies/2026-10-14-to-mercury-05.md, and the pipe's own tick at :8939 states it is open. Q37 :5278 — the pipe's tooling, whose own block says "Q37 stays open there", the residual being a per-tick discipline plus a push identity it names "an access decision, not a script." The career-lane apply queue :7303 — Alexander's, its Status line reading "seven decisions and one rate figure are Alexander's."
• Two citation defects found in the queue's own record. (a) :7323 reads "Q51 — DONE at e4967da9…", which parses as a commit SHA; measured, git cat-file -t e4967da9 → "Not a valid object name" and sha256sum /root/crucible/q51/helm-selftest-q51.py → e4967da9bdc45378… — it is the gate file's digest, and the closure commit is 57d8e6b (2026-10-13T13:40:02Z, Merlin), which :7384 already carries correctly. (b) grep -c 'Status: open and unclaimed' → 3 at :2264 / :2684 / :6847, all closed — reproducing the pipe's own correction at :8018–:8020. Closure revisions verified against git, not prose: a9f23a6, de74527, 0e65dfb, 4c6cd50, 57d8e6b, 4010b96, eec3ff3 — seven of seven resolve.
• Q7, measured: no item opened. An item invented to fill an empty set would be invented work. The queue is not thin — three open items exist and all three belong to another lane or to Alexander — and the Helm lane's next unit remains the §4 cp, a decision, not a task.
• Live state, delta 0 (clock 2026-10-15T10:57:48Z): snapshot 14,039 B / aa842b0fd88037f83115b4a5… / mtime_ns 1791479579475780303; held pin 120 B / 5b6d70716153c3f4bd82045d… / mtime_ns 1791478687099553071; deployed /root/.helm/bin/ five digests unmoved (ee0b36a82f23fcf3… / 5c67473d89283c3d… / 7ed1bca8f9da624f… / 12570786ba703787… / 7386999867789694…), grep -c HELM_COLLECTOR = 0 so Q40 stands; /tmp/q31-g8-deploy-* 475 dirs, newest cfkvskma mtime 2026-10-15 08:53:29.994355542Z = Run 36's last gate run, so no new directory has appeared since — a delta-0 reading on the leak that corroborates the candidate gate's Edit B; disk 41 G free of 154 G. One correction to my own records: the "sandboxes 0" line is off by one — ls -d /root/crucible/*/sandbox* → 2, of which q65/sandbox_probe.py is a script and q43z/sandbox-mine is a Run-13 leftover (32 K, data/snapshot.json, mtime 2026-10-12 18:39). Harmless, in scratch, and it makes "0" wrong, so it is recorded rather than restated.

Blocked. Nothing executable is blocked — there is nothing executable to be blocked on. The three open items are other-lane or Alexander's. The binding human calls stand as measured, unchanged and already surfaced: the §4 adoption cp (this queue's Run 36 block names renderer a70998c8…, collector 4e45021d…, gate 833d0827…, acceptance rc 0 / 195 / 0; the file list must be re-read at adoption time, never copied from an earlier block), and the manifest_match pin, false in production since 2026-10-08 — the live body is 217,163 B / c34ae2c2… against the held pin f27326e8…, so the page the public reads still prints a match that is not one. Nothing was executed from this side.

Next. (1) Re-run the claim check per tick — it is one script and the census is only as fresh as its clock. (2) No Helm unit: the executable set is empty, and the next Helm step is the adoption decision, not a task. (3) Nothing else is mine to open.

Ask. One line, and it is not re-raised beyond naming it: the §4 adoption decision — authorize the four-file cp in order (renderer → collector + gate → re-collect → re-render → deploy) or hold, with the acceptance criterion rc 0 / 195 / 0 / ALL GATES PASS. The Q51 citation defect (e4967da9… is a gate digest where a revision belongs) is a one-line append and is the pipe's or mine to make; no count or verdict moves either way.

Nothing deployed, no another-party file edited, decisions/ and inbox/ untouched, no secret printed. Merlin merlin@agents.invalid.

---

Run 37 landing evidence — appended after the push

Landed as a28d9df8c907c5070e7a674e3486317124fc4368 (29a4872..a28d9df on main), pushed 2026-10-15T11:0xZ. git diff --cached --numstat before the commit: 69/0 WORK-QUEUE.md + 88/0 checkins/2026-10-15-merlin.md + 156/0 recoveries/queue-hygiene-census.md = 313 insertions, 0 deletions, so the append-only assertion holds by count as well as by the structural prefix check both append scripts ran.

Read back over the anonymous raw path at that revision (/root/crucible/q66/readback_r37.py, artifact out/R37-READBACK.json, 1793 B / sha256 7eb664dd1278660c7acda1e2624110c3, host-local):

file	http	bytes	sha256 (first 16)	served = disk = git
recoveries/queue-hygiene-census.md	200	10,123	eb0e1b4f5fa8733f	yes
WORK-QUEUE.md	200	1,175,960	258a9f1847c8db60	yes
checkins/2026-10-15-merlin.md	200	50,177	ef9bb981519690c7	yes

ALL ROWS EQUAL: True, all three newline-terminated. The readback's blind spot, stated: it proves the landing, and a landing check cannot see a rendering defect because the wrong bytes land exactly as written.

Author-field note, standing and not new: this commit is authored Timmy <timmy@stackchain.ai> because the pipe pushes under that credential — the attribution fault recorded in WIZARDS-TABLE.md fault 2 and logged as Q36/Q37's class. The content is this lane's, on the files' first-person text.

Live and deployed unchanged and re-measured at 10:57:48Z, before the commit: snapshot 14,039 B / aa842b0fd88037f83115b4a5…; held pin 120 B / 5b6d70716153c3f4bd82045d…; deployed /root/.helm/bin/ five digests unmoved with grep -c HELM_COLLECTOR = 0; /tmp leak site 475 dirs, newest cfkvskma at 08:53:29.994355542Z. Nothing deployed, no another-party file edited, no secret printed. Merlin merlin@agents.invalid, author=merlin. — Merlin (Run 37, landing)

---

Run 38 — the adoption rehearsal (Helm lane)

Screen. Queue re-read before taking anything: WORK-QUEUE.md at HEAD a843f4e, 1,178,312 B, 9,614 lines; the standing claim check from Run 37 (a28d9df) still holds — the executable-unclaimed set is empty (Q53 is Mercury's, Q37 the pipe's, the career lane Alexander's), and the Helm lane's next unit is the section-4 adoption, a decision rather than a task. So I continued the lane on the one thing standing between the ask and a verifiable adoption: the acceptance leg has never run the payload. Clock read 2026-10-15T13:4xZ before the work began.

Did. The adoption cp, performed on a copy, with the gate reading the payload's own page. Deliverable recoveries/helm-adoption-rehearsal.md (12,914 B / sha256 b31466d2e77451f47e6ae10a5314fbc96ec2d151151aa3ba5912d3aa72648490). Scratch /root/crucible/q67/. The sandbox bin is a copy of /root/.helm/bin with the three payload files copied over it (adoption_identical_to_payload: true, asserted per file): collector 4e45021d80395d3f… (29,954 B), renderer a70998c8592a03cd… (22,930 B), gate 833d08275977054a… (190,330 B). Two gate twins generated by asserted replace-all over every live-path literal (collector path ×2, renderer path ×8, deployed page ×8, held pin ×2, G11 scratch renderer ×3 in twin B).

• The prescribed adoption is green, and what it ships is honest-red. Collect #1 (manifest_match=False; held f27326e8…, live normalised e40308e5…, live wire c34ae2c2…, FRESH, observed 2026-10-15T13:42:14.099Z) → render #1 (13,847 B / f0097cea3b63d2e6…, as of ×2, disclaimer ×0, red drift pill) → gate rc 0 / 195 passed / 0 failed / ALL GATES PASS. The rc 0 / 195 / 0 acceptance criterion is reachable, on the payload's own artifacts rather than a fixture.
• A --pin before adoption makes the gate red — the blocker, with its root cause measured. Re-pin (pinned e40308e573d046d7…) → collect #2 (manifest_match=True) → render #2 (13,847 B / 7cdfc56676b1323f…, green pill) → gate 194 passed / 1 failed, the failing row naming itself: G13 an unqualified green pill is confirmed by a fresh fetch … live_sha256=c34ae2c245117ca7 held_pin_digest=e40308e573d046d7 pin_matches_live_now=False unqualified_green_pill=True. Cause, measured on the same URL with both pipelines in one run (probe_normalisation.py): pin_stackchain (helm-collect.py:664-680) hashes curl's stdout read as text (13 CRLFs folded, 217,163 B → 217,119 chars) while G13 row 2 (helm-selftest-q65.py:3360-3377) hashes the raw bytes — e40308e5… vs c34ae2c2…, agree False. A green pill cannot ship green while the site serves CRLF. Code-level misalignment inside the lane: the next Helm item, and the reason the adoption ask must not be paired with a --pin.
• G7/G10/G11's contract rows pass on the payload renderer — the parity twin's RENDERER and renderer import name the payload, and every producer leg passed, including the destination-gate negatives. The G11 twin's second failure is my own artifact: its negative leg (the G14 discriminator) renders the same scratch path I redirected, so the "violates the predicate" leg no longer violated it. Logged, not hidden.
• Predictions P1-P8 written before any gate ran (build_rehearsal.py), scored in out/RUN.json: P1 P2 P3 P4 P5 P8 met; P6 P7 not met, each cause named in the record rather than restated as a near-miss.
• Live state delta 0 across all ten steps (bytes + sha256 + mtime_ns): page 9,865 B / 427b7b54c69b18d2…; snapshot 14,039 B / aa842b0fd88037f8…; held pin 120 B / 5b6d70716153c3f4…; deployed bin five digests unmoved, grep -c HELM_COLLECTOR = 0 so Q40 stands; /tmp/q31-g8-deploy-* 475 before and after; disk 40 G free of 154 G.
• My own defects, logged first in the record: the byte-stability claim was unsupported on the first pass (two identical-tally legs differing in stdout digest — characterised by byte_stability.py as exactly 4 lines, all mkdtemp paths, two of them sb/helm-legs-* paths my normaliser did not cover); the first root-cause probe was wrong (bytes.decode() does not fold newlines — the corrected probe reproduces both pipelines and its wrong output is recorded); the G11 twin's discriminator artifact; and two refusals discovered by running rather than reading (--deploy required on both sandbox legs, Q31's and G7's destination gates).

Blocked. Nothing on my side. The adoption itself stays Alexander's under §4, and this run changes its shape in one way: cp the three payload files without a --pin first (195/0 on an honest red page), with the pin/gate hashing-convention alignment filed as the next Helm item before any green pill can ship. Standing and unchanged: the Q13 publication call, Q9's checksum handover, Q19's onboarding, the manifest_match pin's staleness (now measured a second time, in a second representation).

Next. The Helm lane's next executable unit is the convention alignment itself — one of two shapes, both small: make G13 row 2 fold newlines the way the collector's text read does, or make --pin hash the raw bytes. Either closes the class; the record states both. After that the lane's set returns to empty and its next unit is again the cp, an operator's call.

Ask. Alexander: nothing new is asked — the adoption ask from Run 37 stands, amended only in order (no --pin first). When the cp happens, the acceptance target is rc 0 / 195 / 0 on a page carrying a red drift pill, and a green pill on the published page would mean the convention split is still open.

---