The held pin f27326e8b13d1dec (pinned 2026-10-08T16:58:07.100Z) no longer
matches the live body (200 / 217,163 B / c34ae2c245117ca7), yet the
renderer's pill reads the frozen manifest_match field and prints a green
'match' beside 'not re-checked since' in a page whose own verdict pill
reads '0 green / 6 not green'. One renderer edit conditions the pill on
the reading's freshness (stale -> amber 'match (unverified)'; the fresh
branch is byte-identical), and gate G11 adds four checks on Q45S10+G10:
161,122 B / 3,053 lines / 135 registrations. Prediction stated before the
run and met: shipped 184/1 (G10's deployed-page row), twin 183/2.
Live delta 0 on bytes/sha256/mtime_ns/ctime_ns across all four objects;
sandboxes 0/0; HELM_COLLECTOR still 0, so nothing is in production.
Nothing deployed, no another-party file edited, no secret printed.
Readback by /root/crucible/q58/readback_r28.py, artifact out/R28-READBACK.json,
read_at 2026-10-14T13:28:12Z, revision 7af50b5, head_at_read 7af50b5, author
Merlin <merlin@agents.invalid>. All three rows HTTP 200, served = disk =
git cat-file -p 7af50b5:<path>:
recoveries/helm-deployed-page-generation.md 9,953 B bdd5fa1c03586c28...
WORK-QUEUE.md 1,067,607 B a78cc8dff36908a5...
checkins/2026-10-14-merlin.md 65,984 B 0af2ecd2aaaee0f0...
The landing delta is measured from git, not from the append script:
git diff --numstat 7af50b5^ 7af50b5 = 72/0 on the queue, 124/0 on the check-in,
149/0 on the record = 345 insertions, 0 deletions. The queue's byte delta is
1,062,291 -> 1,067,607 B = +5,316 against a block of 5,322 B; the 6-byte
difference is the block's leading newline-dash-dash-dash separator aligning with
the separator the parent already carried, which is also why git counts 72 added
lines rather than the block's own 74. Reconstruction verified byte-exact:
parent[:1060132] + block + parent[1060138:] == rev is True, so the pipe's
"Erratum, mine: the 13:09Z tick" block is intact and keeps its own separator. No
another-party content was clobbered.
ONE DEFECT OF MINE, logged in the check-in's landing block rather than smoothed:
the append script's printed before figure for the queue was 1,060,143 B against a
shared prefix of 1,060,132 B -- 11 bytes stale, because sha(QUEUE) and the later
QUEUE.read_bytes() are two separate reads and the pipe was writing the file
between them (its erratum is stamped 2026-10-14T13:26:06Z, after my 13:25:50Z
append and before my 13:27:05Z commit). The file content is correct and every
assertion that mattered was on bytes read once and written once; only the printed
diagnostic is stale. The git figures are the authoritative ones, and the check-in
was unaffected -- parent is a prefix of rev: True, residual 0 B, 124 lines =
numstat 124/0 -- because the pipe does not write my check-in. This is the
concurrent-writer form of Run 24's logged defect, not its unit form: the units
were bytes throughout.
Live state at the landing, unchanged: deployed page 9,865 B /
427b7b54c69b18d270288910fc810732463129f48ec4bdd7dbc75cdb22997ce4 / mtime_ns
1791709034017837233; snapshot 14,039 B / aa842b0fd880... / mtime_ns
1791479579475780303; held pin 120 B / 5b6d70716153c3f4... / mtime_ns
1791478687099553071. Deployed /root/.helm/bin/ untouched (ee0b36a82f23... /
5c67473d8928... / 7ed1bca8f9da... / 12570786ba70... / 738699986778...),
grep -c HELM_COLLECTOR = 0, so Q40 stands and G10 is not in production. Sandboxes
0/0 both ways. Disk 45 G avail of 154.
Append-only, trailing newline asserted on the written file: check-in 65,984 ->
69,697 B (+3,713, sha256 d1d616878ecbd269...). No another-party file edited,
decisions/ and inbox/ untouched, no secret printed.
The Helm's pinned site now reads HTTP 200 / 217,163 B / sha256 c34ae2c245117ca7...
while the held pin is f27326e8b13d1dec... pinned 2026-10-08T16:58:07.100Z, so
pin_matches_live_now is false. The deployed page /var/www/alexander-whitestone/helm/index.html
is 9,865 B / sha256 427b7b54c69b18d270288910fc810732463129f48ec4bdd7dbc75cdb22997ce4 / mtime
2026-10-11T08:57:14.017Z and renders a green "match" with no "as of" and no "not re-checked
since". The renderer carrying that fix is mtime 2026-10-11T11:12:43.756Z, 8,129.7 s later, and
the real snapshot through it (--out scratch --as-of 2026-10-14T00:00:00.000Z, rc 0) renders
11,798 B / sha256 f32191223931e74b... carrying "as of 2026-10-08T17:12:59.458Z . 5d 6h 47m ago
. not re-checked since". The fix exists, works, and was never deployed.
Why the self-test was green: helm-selftest.py:420-421 runs the qualifier check on a synthetic
fixture at a pinned clock (hr.SNAPSHOT = fp), and :422-425's "build_page() writes nothing"
only proves build_page did not overwrite production. Neither reads the deployed artifact --
the Q34/Q40 law in a new place: a gate that tests the producer cannot vouch for the artifact
in the document root.
The fix is gate G10, four checks, on Q45S10's c56230e5a075... (147,151 / 2,798 / 127):
helm-selftest-q58.py 153,469 B / sha256 3b98b62fa5c7ea626091f6d0f63566de79818ae414bcffe323dd1ddd53956158
/ 2,916 lines / 131 check(" registrations. Shipped (reads the live page): rc 1, 180 passed /
1 failed, stdout 15,055 B / e8304379529c4c83..., the one FAIL being "the deployed page carries
the manifest qualifier". Twin (the same gate with _g10_deployed repointed at a scratch
current-generation render, ast-asserted): rc 0, 181 passed / 0 failed, ALL GATES PASS, stdout
14,824 B / fe8c8c72825962d9.... Prediction stated before the run and met exactly -- a red row
that cannot go green would prove nothing.
Live state delta 0 across all four invocations on bytes + sha256 + mtime_ns: page 9,865 B /
427b7b54c69b18d2... / 1791709034017837233; snapshot 14,039 B / aa842b0fd880... /
1791479579475780303; held pin 120 B / 5b6d7071... / 1791478687099553071. Sandboxes 0/0 both
ways (shallow glob and recursive rglob). No --deploy anywhere in the G10 block. Deployed bin
unchanged, five digests re-read, grep -c HELM_COLLECTOR = 0 so Q40 stands and G10 is not in
production.
Two shipped runs are both 180/1 at 15,055 B while byte_stable_stdout reads false; the
difference is mkdtemp suffixes in the sandbox path the gate prints. The four G10 rows are
byte-identical across both runs, and normalising the four path patterns gives stdout sha256
1958d8212fa60e44... on both with residual differing lines 0.
Six defects of mine are logged first in the record: two claims in one cell (the first G10
check 3 asserted both the predicate's soundness and the finding, which would have made the
twin 180/1 and hidden the discriminator); a report filter written from memory
(startswith("PASS") never matches the two-space rendering -- the lane's own logged class
reproduced on a fresh artifact); a live-path assertion that fired on G5's read-only check and
then on G10's own comment; byte_stable_stdout: false reported as found with the cause
measured; ast.unparse's single quotes; and pathlib.Path in a gate that imports
from pathlib import Path.
No queue item was opened: the Helm executable set was empty at the start of the run (Q49's
"Status: open and unclaimed" at :6847 is stale -- this file's own hygiene ledger at :8026
records Q49 CLOSED), so the unit taken was the one defect the lane had measured and labelled
but never fixed. Owed to Alexander, both decisions rather than tasks: re-render and re-deploy
the Helm page, and the section-4 adoption cp of collector 4e45021d... + gate 3b98b62fa5c7ea62....
Append-only, prefix asserted on bytes before each write, trailing newline asserted on the
written files: queue 1,060,143 -> 1,065,465 B (+5,322, sha256 9f0a02b429eb7ed5...), check-in
58,536 -> 65,984 B (+7,448, sha256 0af2ecd2aaaee0f0...), record 9,953 B / sha256
bdd5fa1c03586c28.... No another-party file edited, decisions/ and inbox/ untouched, no secret
printed.
Deliverable recoveries/helm-pwdir-channel-refusal.md (14,808 B / sha256
d4c381f713e9fe95beefbd14a93220ab4049625f280c116e656419f3e11b7b89) plus the queue block at the foot
of WORK-QUEUE.md (+5,419 B / 63 lines, 951,756 B / d8f54086edbcbbc96e39533d7b6dcf0e9effff108b596ed18685b03d1045e1db)
and checkins/2026-10-14-merlin.md (Run 22). Scratch tree /root/crucible/q55/; nothing deployed, no cp
into /root/.helm/bin/, decisions/ and inbox/ untouched, no another-party file edited, no secret printed.
The class, measured on the shipped Q52 gate before the change: a subject whose root is composed from
the user database (ROOT = Path(pwd.getpwuid(os.getuid()).pw_dir) / ".helm") resolves the live root
under a scratch HOME (rc 0, both fixtures), passes the Q52 home-channel check (the check asserts the
legs' HOME is redirected; pwd.getpwuid never reads HOME), and writes the LIVE held pin through the
gate's own --q52-witness flag (5b6d7071... -> fdd45f74..., restored byte-exact by the guard). A foot
check reports after the legs; only a precondition refuses before them.
The fix: gate cd43284ff009d1cceb3aaa6a65b701d1076eaf801e32b705672601b4122b746a (143,385 B / 2,735
lines / 126 registrations -- unchanged; +3,020 B / +58 lines on the Q52 gate 78b290ec...) -- a
precondition after Q46's parse guard, before the Q39 sandbox, the admission probe and any leg: a
subject whose AST reads the pwd module is refused (exit 2, dated, naming every pwd site with its
line). Disarmed twin 8adad99bdc872ecd09ddea88ae55b5fc55a3886571ffaa5f49a053b52430586d.
25 guarded cells: armed x pwr/pwr-witness/pwn rc 2 refusal (stdout 0 B, live delta {}); disarmed x
pwr-witness reproduces the escape (live pin 5b6d7071... -> ced810a9..., restored byte-exact);
disarmed x pwr 175/1 with Q52 PASS and Q45 FAIL (the shipped behaviour); green pair x5 176/0 at
14,044 B; regressions 11/11. Covered shapes are not over-refused: the witness pin lands inside the
sandbox, and the covered fixtures fail Q43 identically under the shipped gate (measured side by side).
Live delta 0 on bytes/sha256/mtime across all 25 cells (snapshot aa842b0f... / 14,039, pin
5b6d7071... / 120); ctime moved on the pin across the deliberately-live witness cells (guard restores)
-- disclosed. Sandboxes: q55 tree 0/0; the E14 leak re-measured at 26 across /root/crucible and all
26 removed (842,401 B reclaimed) with the q55 __pycache__. Deployed /root/.helm/bin/ untouched,
HELM_COLLECTOR count 0 -- Q40 stands. Disk 45 G avail of 154.
Adoption, Alexander's: the s4 cp is collector 4e45021d... + gate cd43284ff009..., superseding
78b290ec... / e4967da9... / a951dbe8.... Five defects of mine are logged first in the deliverable
(part 1's void d/e rows, its prefix-vs-full restored comparison, its broken Q45 filter, my assumed
d/e expectation, and the gate's first-written Q55 label). No new item opened -- the Helm lane's
executable set is empty; the next unit is a decision, not a task.
The fill for Run 21 (content at 258e3ad). Read back over the anonymous raw path at
revision 258e3ad by /root/crucible/q54/readback_q54.py (artifact out/Q54-READBACK.txt,
398 B, mtime 2026-10-13 23:04:19.489552154Z, host-local): record 200 / 34,311 /
4ba00ce427b85079adedf34524c8334a92e949b205efcc682c8cdd47a99a1cd7, queue 200 / 935,526 /
c5316986a532ce2ba4c479e89b0a4839c7bcd6e6c613d859511616b9fb7323e0, check-in 200 / 94,099 /
1da711a046950f73979bfaa52fe04479c76cbd573ba1421c937d3f53dd8d4ba7 -- all three
served = disk = git, all newline-terminated, ALL ROWS EQUAL.
Clock correction, appended not edited in place: the Run-21 blocks cite "~21:2xZ",
which no instrument supports. The Run-21 content commit 258e3ad was made at
2026-10-13T23:03:50Z (git log -1 --format=%cI) and the readback artifact at
23:04:19.489552154Z. The cite was assumed from reply 42's 21:07Z timestamp rather than
measured -- the same defect class as reply 42 section 1, reproduced by this run's own
Screen line and corrected here.
Live and deployed unchanged across the whole run: snapshot 14,039 B / aa842b0fd880 /
mtime_ns 1791479579475780303; held pin 120 B / 5b6d70716153 / mtime_ns
1791478687099553071; deployed bin ee0b36a8 / 5c67473d / 7ed1bca8 / 12570786 / 73869998
with grep -c HELM_COLLECTOR = 0 on the gate (Q40 stands, nothing of Q31-Q45s9 in
production); disk 45 G avail of 154; worktree clean.
Read-only run: no gate invocation, no live write, no deployment, no edit to another
party's file, decisions/ and inbox/ untouched, no secret printed.
The three sentences replies/2026-10-13-to-merlin-42.md (1b16385) returned against
Run 20's closing note, each re-measured from git with a non-stripping reader
(measure2.py) and cross-checked with sha256sum:
1. Both readback clocks were wrong: readback.py ran at 20:45:43.513552892Z (not
~21:0xZ) and readback_final.py at 20:52:18.142200548Z (not ~21:2xZ); cfae76a
was committed 20:51:49Z, 29.1 s before readback_final.py existed, so the
closing note cites a readback that postdates its commit. The note's table is
sound (cf07003 digests); the clock sentences and the readback description are
the defect.
2. Row 3's equality: the per-revision census shows record and queue byte-identical
across cf07003->cfae76a (34,311 / 4ba00ce4, 927,009 / 7754184c, both 0x0a);
the check-in is 83,854 / 4306bc50 at cf07003 and 85,869 / a1f3ad72 at cfae76a,
which is what disk and branch/main serve. The table row is right; the sentence
above it needs the per-row revision.
3. Three of three, confirmed: at 7673477 all three files end 0x29 (31,219 /
925,786 / 82,262); dc3c2f7 terminated queue+check-in, cf07003 the record
(+22/-1 on the record alone), cfae76a the check-in's closing note (+33).
4. The queue close block's undated 927,009 is cf07003's reading; the queue at HEAD
1b16385 is 933,092 / 114d937e.
Own defect logged first: the take-1 instrument (measure_r42.py) .strip()ed its
captures, so its digests were computed over stripped content; measure2.py is the
authority and the record is sound.
Queue hygiene appended: four "open and unclaimed" status lines name closed items
(Q21, the Q13 fix pack, Q49, Q51); the DONE blocks below them govern.
Read-only run: no gate invocation, no live write, no deployment, no edit to
another party's file, decisions/ and inbox/ untouched, no secret printed.
Live and deployed unchanged: snapshot aa842b0f / 14,039, pin 5b6d7071 / 120,
HELM_COLLECTOR 0 in every deployed file, disk 45 G of 154.
Names the three commits that carry this unit (7673477 corrections +307/-0, dc3c2f7
landing evidence and E17 +76/-2, cf07003 E18 +22/-1) and the final readback at
cf07003: all three rows HTTP 200 and served = disk = git cat-file -p cf07003:<path>,
each newline-terminated -- record 34,311 B / 4ba00ce427b85079..., queue 927,009 B /
7754184c5368..., check-in 83,854 B / 4306bc5035ed... The record's digest is the same
value E18 carries, so the two rows agree rather than one chasing the other; the check-in's
own row is dated at cf07003, the revision before this append, and is not restated.
out/ artifacts (Q53-MEASUREMENTS.json, Q53-READBACK.txt, Q53-READBACK-FINAL.txt) are
host-local and not forge-verifiable -- 0 paths under out/ in the tree, raw path 404 --
E13's rule applied to this run's own artifacts.
Nothing deployed, no cp into /root/.helm/bin/, decisions/ and inbox/ untouched, no
another-party file edited, no secret printed. Live state delta 0 across every measurement:
snapshot 14,039 B / aa842b0fd88037f8... / mtime_ns 1791479579475780303 / ctime_ns
1791907371554631194; held pin 120 B / 5b6d70716153c3f4... / mtime_ns
1791478687099553071 / ctime_ns 1791907371554631194. Deployed bin untouched
(ee0b36a82f23, 5c67473d8928, 7ed1bca8f9da, 12570786ba70, 738699986778), HELM_COLLECTOR
count 0 -- Q40 stands, so none of Q31-Q45s9 is in production. df -h / -> 46 G avail of
154, 71 % used. Sandbox census in the q53 tree 0; E14 records the 26 elsewhere under
/root/crucible.
Found by readback_final.py's per-row trailing-newline flag, not by inspection: at
dc3c2f7 the queue and the check-in both read True and the record read False, because
fix_newline.py's own E17 literal ends with the signature and no newline -- so the append
written to log the defect re-introduced it on the record. Fixed by writing one newline
byte; no line of content moved. Record 33,064 B / cfb71db33761... -> 34,311 B /
4ba00ce427b85079adedf34524c8334a92e949b205efcc682c8cdd47a99a1cd7, +22/-1 (the -1 is the
newline E17 itself dropped).
The lesson is stronger than E17's rule and is stated in E18: a trailing newline is not a
property you get from writing head + sep + tail + addition, because the ADDITION has to
end with one. The assertion belongs on the written file -- assert the bytes end with a
newline after every append, or print the flag per readback row -- not on the helper's
intent. Both instances are measured in E18 and neither is deleted.
Nothing deployed, no cp into /root/.helm/bin/, decisions/ and inbox/ untouched, no
another-party file edited, no secret printed. Live state unchanged: snapshot 14,039 B /
aa842b0fd88037f8... / mtime_ns 1791479579475780303, held pin 120 B / 5b6d70716153c3f4...
/ mtime_ns 1791478687099553071, ctime_ns 1791907371554631194 on both; deployed bin
untouched, HELM_COLLECTOR count 0.
Landing evidence for Run 20, read back over the anonymous raw path at ~21:0xZ,
instrument /root/crucible/q53/readback.py. All three rows HTTP 200, served = disk =
git cat-file -p 7673477:<path>:
recoveries/helm-home-channel-guard.md 31,219 B / 0f8b7f1617a67f5e8308e85b837e3256d74949080750dbabacc0f09f106464fa
WORK-QUEUE.md 925,786 B / 78feb8441d8f01183c5f57c7248366400d7f5d5720bf3b8a10d12c37b73a2c11
checkins/2026-10-13-merlin.md 82,262 B / 9db0834471415e3a6a4d1844910a8f21d3a558305b9a69ea08785b8ec0bcda94
The check-in row is that file at 7673477, before this append -- a file cannot cite its
own post-append digest, so the row is dated rather than chased. out/Q53-MEASUREMENTS.json
and out/Q53-READBACK.txt are host-local and not forge-verifiable: 0 paths under out/ in
the tree at 7673477, raw path 404 -- E13's own rule applied to this run's artifacts.
E17, found on my own tool before this commit: q53/append.py's append_last() wrote
head + sep + addition and never wrote tail back, and tail was the file's single trailing
newline, so the record, the queue and the check-in each lost it. Measured by
git diff --numstat: the Run-20 append read 16/0 on the queue and 159/0 on the record
(clean), then 19/1 and 28/1 once the landing appends ran -- the 1 in each being the
dropped newline, not a content edit. Restored by writing one newline byte to each file
(WORK-QUEUE.md 927,008 -> 927,009 B; the check-in 83,853 -> 83,854 B); no line of
content moved. It matters beyond hygiene because this lane's readback discipline compares
served = disk = git cat-file byte for byte, so a lost trailing newline is a real delta an
outside reader would have to explain. The rule: write head + sep + tail + addition, and
assert tail is whitespace-only before dropping it -- the count(anchor) == 1 discipline
extended to the tail.
Nothing deployed, no cp into /root/.helm/bin/, decisions/ and inbox/ untouched, no
another-party file edited, no secret printed. Live state unchanged: snapshot 14,039 B /
aa842b0fd88037f8... / mtime_ns 1791479579475780303, held pin 120 B / 5b6d70716153c3f4...
/ mtime_ns 1791478687099553071, ctime_ns 1791907371554631194 on both; deployed bin
untouched, HELM_COLLECTOR count 0 -- Q40 stands, so none of Q31-Q45s9 is in production.
Append-only: E10-E16 in recoveries/helm-home-channel-guard.md (21,230 B /
953ea1a14c5fa49b... -> 31,219 B / 0f8b7f1617a67f5e..., +159/-0) and a Run-20 block in
WORK-QUEUE.md (919,333 B / c5fa27ea61cf43de... -> 925,786 B / 78feb8441d8f01183...,
+16/-0). Scratch tree /root/crucible/q53/; read-only, no gate invocation, no live write,
nothing deployed, no cp into /root/.helm/bin/, decisions/ and inbox/ untouched, no
another-party file edited, no secret printed.
Measured this run, not accepted:
- E10 (reply 38 s1, upheld): E4's legs-caller row said :1160; grep -n
'_q50_rebuild_env(' helm-selftest-q52.py gives :815 def, :977 probe caller, :1162 legs
caller. :1160/:1161 are the two comment lines above it -- a comment read as code. The
record's own s2 cite was right; the erratum's cell was the defect.
- E11 (reply 38 s2 / reply 39 s0, restated scoped and dated): the command as written,
grep -rn 'caff1f504855264a' /root/crucible/q52/, returns 9 lines in 8 files at 20:5xZ
(run19_append_record.py 2, the other seven 1 each); out/ returns 0 (rc 1); the repo
tree at HEAD returns 15 lines in 6 files. The 3 is a Run-18-era reading of the three
scratch prose files it names, 1 each, stale because Run 19's own five scripts quote the
string. Finding unchanged: the figure stays unverified; direction Corroborated by
out/Q52-MATRIX.json's two guard_restored rows with final_live_delta {}.
- E12 (reply 40 s2): the landing block's readback clock is 18:30:31Z, not 18:31:0xZ.
out/Q45S9-RUN19-READBACK.json (1,686 B / ccec083ce40f...) records read_at
2026-10-13T18:30:31.084749+00:00, revision 068ac5f, epoch 1791916231.084749. A +/-360 s
band census reproduces the pipe's supporting measurement to the millisecond: next
write after the read is run19_append_landing.py at +160.699 s = 18:33:11.78Z.
- E13 (reply 40 s3): the readback artifact is host-local, not forge-verifiable --
git ls-tree -r --name-only HEAD gives 244 paths, 0 under out/, no worktree out/, and
the anonymous raw path returns HTTP 404 (11 bytes). Stated as a property of the lane:
every out/*.json across Q31-Q45s9 is host-local.
Two findings of my own, from re-reading rather than from being told:
- E14: the sandbox census is tree-scoped. E7's "both ways -> [] / []" is true of the q52
tree; the recursive census over /root/crucible is 26 -- 19 helm-legs-* (q43 x1,
q43/variants x2, q43z/variants x1, q44 x2, q45/variants x13) and 7 helm-q39-* (q48).
The skill's own logged lesson applied to my own record.
- A sixth line-citation defect: E4's --q52-witness row puts the section comment at
:1261; grep -n gives :1262 (comment) and :1270 (flag test).
E15 re-derives, measured not accepted: gate 78b290ecf2d93e0c... 140,365 B / 2,677 lines
/ 126 check(; disarmed twin be7b306a... 140,390 B; _q52_home_sites :758;
_q50_rebuild_env :815; probe caller :977; check("Q52", ...) :1205;
out/Q52-MATRIX.json 12,308 B / 75bd624e... at 2026-10-13T16:02:51+0000;
out/q52-dis-check.out 191 lines, 174 passed / 2 failed, FAILs at :186 (Q52
home-redirect) and :187 (Q45 module-constant, HELM_HOME /root/.helm and HELD_DIR
/root/.helm/data/held escaping the cut redirect) -- E3 re-derives exactly.
Live delta 0 on bytes/sha256/mtime_ns across every measurement: snapshot 14,039 B /
aa842b0fd88037f8... / mtime_ns 1791479579475780303 / ctime_ns 1791907371554631194; held
pin 120 B / 5b6d70716153c3f4... / mtime_ns 1791478687099553071 / ctime_ns
1791907371554631194, still Run 18's restore trace. Deployed /root/.helm/bin/ untouched
(ee0b36a82f23, 5c67473d8928, 7ed1bca8f9da, 12570786ba70, 738699986778), HELM_COLLECTOR
count 0 -- Q40 stands, so none of Q31-Q45s9 is in production. df -h / -> 46 G avail of
154, 71 % used.
Standing and still human-gated, unchanged: the s4 adoption cp of collector 4e45021d... +
gate 78b290ecf2d93e0cc3087e5ede8baef5c10ca52986706d5da69a13a619dbdd9f; the manifest_match
pin stale since 2026-10-08; Q13's publication call; Q9's checksum handover; Q19's
onboarding. No new item opened: Q42 is zephyrus's, Q52 is Mercury's, Q53 is Alexander's,
so the Helm lane's executable set is empty again and its next unit is a decision, not a
task.
Readback of the three landed files at 068ac5f, as its own commit: all three HTTP 200,
served = disk = git cat-file -p HEAD:<path>.
- recoveries/helm-home-channel-guard.md 21,230 B / 953ea1a14c5fa49b6d2d8e0d8324a8ac9d739ca4c39695646a5c05ae9cbf37fb
- WORK-QUEUE.md 909,662 B / 83b62e9d55180c38a12d9c26b8abea2661f033b448745599250fcba8a181a6fc
- checkins/2026-10-13-merlin.md 73,547 B / 43fb28e1fe92f587ce5cfa24fda8461a800b10239f63bd699672c35b21f1b19d
Instrument /root/crucible/q52/run19_readback.py, artifact out/Q45S9-RUN19-READBACK.json
(1,686 B / ccec083ce40f53242ab469f96529d9047eb525047891bedd4b492256fa45b39d), which names
the revision it was read at. This block was written against the queue at 909,662 B /
83b62e9d... and does not cite its own post-append digest.
Live state at readback time: snapshot 14,039 B / aa842b0fd88037f8... / mtime_ns
1791479579475780303, held pin 120 B / 5b6d70716153c3f4... / mtime_ns 1791478687099553071,
ctime 1791907371554631194 on both; deployed /root/.helm/bin/ untouched, HELM_COLLECTOR
count 0. Nothing deployed, no another-party file edited, no secret printed.
Taken on replies/2026-10-13-to-merlin-37.md section 2, which left five corrections open
on this lane's own file. Nothing above the appended sections was edited; three appends
only, 312 insertions / 0 deletions.
- The label collision is closed by renaming in prose: the item is Q45s9 (the queue's own
section id, and the wording the c559d33 commit subject already carries), not Q52, which
is Mercury's item at WORK-QUEUE.md:7167. The gate's internal check("Q52") registration
and _q52_* helpers are deliberately not renamed -- renaming changes the gate's digest
and would invalidate the byte-level verification reply 37 performed against it.
- The gate digest, measured in full: sha256sum /root/crucible/q52/helm-selftest-q52.py ->
78b290ecf2d93e0cc3087e5ede8baef5c10ca52986706d5da69a13a619dbdd9f (64 hex, 140,365 B /
2,677 lines / 126 registrations). The c559d33 commit subject carries a 63-character
value, one c dropped at index 16; a commit message cannot be edited, so the correction
lives in the record and the queue. The section-4 adoption cite is the 64-character value.
- The disarmed row's transient pin figure is unverified: grep -rn 'caff1f504855264a'
over the scratch tree returns 3 hits, all this lane's prose, 0 in out/; the same for
1791907100434371499. out/Q52-MATRIX.json (12,308 B / 75bd624ef25c5667...) records
10d12a7d20c5f0ac... / 1791907358370548372 for that row and 576a47723957844e... /
1791907371509627497 for the raw row, both guard_restored true. Direction Corroborated,
cited figure unverified.
- The readback pairing is stated: out/Q52-READBACK.json carries revision 6954cc6 and its
check-in row 67,347 B / 912985e3..., against the record's landing table's 65,145 B /
d89b2189... at c559d33 -- both true, the revision field is the pairing.
- Four line citations corrected by grep -n in the shipped gate (_q52_home_sites :786 -> :758,
legs' _q50_rebuild_env caller :1162 -> :1160, check("Q52") :1204 -> :1205, --q52-witness
flag test :1270), and the q52-dis-check row's second failing check named
(out/q52-dis-check.out:187, FAIL Q45 ... HELM_HOME: /root/.helm).
- "Delta 0 across all 21 invocations" is restated as net zero with two disclosed
transient movements: exactly two of five matrix rows carry a non-empty guard_live_delta
with guard_restored true, and final_live_delta is {}.
Artifacts: recoveries/helm-home-channel-guard.md 21,230 B / 953ea1a14c5fa49b6d2d8e0d8324a8ac9d739ca4c39695646a5c05ae9cbf37fb;
WORK-QUEUE.md 909,662 B / 83b62e9d55180c38a12d9c26b8abea2661f033b448745599250fcba8a181a6fc;
checkins/2026-10-13-merlin.md 73,547 B / 43fb28e1fe92f587ce5cfa24fda8461a800b10239f63bd699672c35b21f1b19d.
Live state re-measured 2026-10-13T18:18:06Z, delta 0: snapshot 14,039 B / aa842b0fd88037f8...
/ mtime_ns 1791479579475780303; held pin 120 B / 5b6d70716153c3f4... / mtime_ns
1791478687099553071; ctime 1791907371554631194 on both, unmoved since Run 18. Deployed
/root/.helm/bin/ untouched (ee0b36a8 / 7ed1bca8 / 5c67473d / 12570786 / 73869998),
grep -c HELM_COLLECTOR = 0 -- Q40 stands. No gate invocation, no live write, no cp, no
another-party file edited, decisions/ and inbox/ untouched, no secret printed.
The last runtime-resolution route in Q45 s7-limit-1's family with neither a literal nor an ast-visible env read: HELM_HOME = Path.home() / ".helm" composes the live root because CPython's posixpath.expanduser reads HOME itself. The channel is live in the shipped subject -- the real collector calls Path.home() twice (its himalaya search). Mechanism: an ast inventory of home-database reads (_q52_home_sites, :786) and, inside Q50's one rebuild function (two callers, probe :977 / legs :1162), a redirect of HOME + USERPROFILE to <target>/q52-home -- a redirect, not a refusal -- with a conditional Q52 NOTE and one new check("Q52", :1204). A --q52-witness extra flag (:1261) runs the copy with --deploy --pin --skip-tests --out <sandbox dest>, the pin shape the suite itself refuses (Q44's rule), because the class's write path is unreachable from the green run.
Measured: green 5/5 at 176 passed / 0 failed (= 175 + 1), 14,044 B stdout, live delta {}; the real collector's own .home() read makes the check non-vacuous. Discriminator, five cells under the digest-verified guard: armed x collector-home.py (d62888c4) -- the copy resolves inside the sandbox and the pin lands at q52-home/.helm/data/held/stackchain-home.html.sha256 in the sandbox, live delta 0; armed x collector-expanduser.py (99c49d39) -- same; disarmed x home -- HOME stays /root, the copy resolves HELM_HOME=/root/.helm and the live pin moves to sha256 caff1f504855264a / mtime_ns 1791907100434371499, restored byte-exact; disarmed without the witness flag -- the foot's own check fails (FAIL Q52, home_reads=['.home()'] HOME='/root', 174 passed / 2 failed); direct invocation, ambient env -- the live pin moves (the class's floor). Regressions 11/11 hold; live delta 0 on bytes/sha256/mtime across all 21 invocations (snapshot 14,039 B / aa842b0f, held pin 120 B / 5b6d7071); ctime moved on both objects (1791907371554631194), the guard restores of the two deliberately-live rows -- disclosed. Final tree 0 sandboxes; deployed /root/.helm/bin untouched (7ed1bca8, grep -c HELM_COLLECTOR = 0 -- Q40 stands, so none of Q31-Q52 is in production); disk 46 GiB free of 154.
Five defects of mine logged first in the deliverable: the witness's missing local subprocess import; the witness anchored before the leg copy was written; the witness's live census reading the held directory (IsADirectoryError); the NOTE claiming a redirect that had not fired (the disarmed twin's own FAIL contradicted it -- the NOTE is now derived from the actual env); and the first matrix measuring nothing because the real collector pins only under --pin, which the suite refuses. Limits stated as the item's own: the original-subject legs inherit the ambient environment (Q48's residual); pwd.getpwuid().pw_dir bypasses HOME (the inventory names it, the redirect cannot relocate it); the inventory is static (Q46's limit).
Files: recoveries/helm-home-channel-guard.md (13,173 B / sha256 3f813ca23202590c675f7ac7587f0d5e7d8b0ff9ee9f4f0711996530a2d6d7db), WORK-QUEUE.md (897,771 B), checkins/2026-10-13-merlin.md (Run 18). Scratch tree /root/crucible/q52/ not committed. No deployment, decisions/ and inbox/ untouched, no another-party file edited, no secret printed. The Helm lane's executable set is empty again; the adoption cp (collector 4e45021d + gate 78b290ec, superseding e4967da9) remains Alexander's.
The ordering defect the class hid behind, closed: the run-wide held census
(_q44_held_before) was read ~470 lines after the admission probe spawn, so the
run-wide instrument structurally could not see a probe write. Measured on the
base gate first (Q44 PASS while the guard reports the live pin MOVED), then
fixed by a pure move of the census machinery above the probe branch.
Gate e4967da9bdc4537802993523c7044a762a9a6366576df4e4234444789310107e
(134,427 B / 2,558 lines / 125 registrations) on the Q50 gate a951dbe8...
diff = 2 hunks + 33 added - 27 removed; 2552 + 33 - 27 = 2558 exactly.
Disarmed twin b1d96976... (134,378 / 2,557 / 125).
Cells: armed x named 166/9 with Q44 PASS and Q50 PASS, delta {} on both
objects; disarmed x named 164/11 with Q44 FAIL and Q50 FAIL, the run-wide
check naming the moved held pin and failing on ctime alone after the window
detector's byte-exact restore. Green pair 5/5 at 175/0, 13,929 B. Regressions
11/11 (latin1 and bom green at 13,929 B). Live delta 0 on bytes/sha256/mtime
across all 32 invocations; ctime movement disclosed; 0 sandboxes.
Still open: Merlin's Q45 s9 follow-on (runtime path resolution) and the s4
adoption cp (collector 4e45021d + gate e4967da9), the manifest_match pin, and
the Q13 publication call -- all Alexander's.
Nothing deployed; decisions/ and inbox/ untouched; no another-party file
edited; no secret printed.
Taken on the pipe's own offer (reply 34, asks 1). The Q48 value-redirect and Q49
default-redirect are factored into _q50_rebuild_env(_target) and called twice: at the
rule's original site for the legs (target the legs' sandbox) and above the admission
probe's spawn for the probe (target the probe's own tree, which exists before the
spawn -- the legs' sandbox does not). The spawn now carries env=, and a per-window
census of both live objects around the spawn is the class's detector: a move is
restored byte-exact in-gate, recorded, printed as a dated Q50 DETECTOR note, and
fails the named check "Q50 the admission probe's spawn moved neither live object".
Measured, all five matrix cells under a digest-verified guard (subject env-root-v1.py):
base-q49 x named MOVED held pin 120 B / 5b6d7071... -> 14 B / 784b9bde..., guard-restored
q50-armed x unset delta 0 0 value + 1 default redirect
q50-armed x named delta 0 1 value redirect -- the blank cell, filled
q50-dis x unset delta 0 the probe copy's own Q45 literal relocation covers the
default shape; the redirect is load-bearing only in the named cell
q50-dis x named delta 0 the DETECTOR fires: pin moves inside the gate, restored
byte-exact, foot prints FAIL Q50 (165/10 vs armed 166/9)
Green 5 x rc 0 / 175 passed / 0 failed (174 + 1) / 13,929 B / live delta 0.
Regressions 11/11 hold (n1-n5, noparse, dep-unparseable, undecodable, broken_dep rc 2;
latin1 and bom green 175/0). Live objects byte-identical to session start on
(bytes, sha256, mtime_ns); deployed bin untouched (ee0b36a8... / 7ed1bca8...,
HELM_COLLECTOR count 0 -- Q40's finding stands). Named follow-on, not fixed here:
hoist the run-wide held census above the probe. Three harness defects of mine logged
first in the record. Nothing deployed; no another-party file edited; no secret.
The record's deferred table and the check-in's deferred line are filled from the
anonymous raw read at main, taken after the push (a pre-push readback returns 404
for a new file), so the figures are stable for any outsider. All three HTTP 200
and byte-identical to disk.
- (a) ATTRIBUTION, measured not withdrawn. env-root-v1.py = q48/env-root.py with its
two default literals returned to /root/.helm (asserted count 2). Under a
digest-verified guard: the fixture run --dry-run / bare / --deploy --out <scratch>
with Q48_ROOT UNSET each moved the live held pin, and
HELM_COLLECTOR=<that fixture> Q48_ROOT unset python3 q48/helm-selftest.py moved it
too. All three Q48_ROOT=<scratch> controls: no move. Written bytes measured by a
5 ms watcher: 14 B / sha 784b9bded20e9e22... / 'q48-env-pin\n'. Q48's 6.2
attribution is upheld as a measurement; the pipe's negative reproduces exactly.
The writing leg is named verbatim by the per-leg census: the G8 --dry-run
original-subject leg, whose own source comment asserts "it writes nothing".
- (b) THE CLASS IS CLOSED, green 5/5. helm-selftest-q49.py (128,948 B / 2,445 lines /
085ddf4f42ae80ea...): the DEFAULT redirect (every os.environ.get("X","<default>")
pair inventoried by ast; a default literal resolving inside the live data root is
redirected to the per-invocation sandbox), a per-leg census of BOTH live objects as
detection, and a guard on the in-process --deploy leg. Checks 120 -> 123
(+3 check("Q49"), nothing else moved). Five green runs: rc 0, 174 passed /
0 failed, 13,863 B stdout, digests 13cf5cf7 / d4666b9f / 0abd28cd / 5ed81c37 /
bbbd1901, live delta 0 on both objects.
- TWO FINDINGS BEYOND THE ITEM. (i) G8's --deploy branch calls hcg.main() IN-PROCESS
with only SNAPSHOT_PATH patched, so a subject that resolved its root at import time
wrote the LIVE SNAPSHOT (14,039 B -> 137 B) -- reproduced, restored, and now
guarded. (ii) In the fully disarmed configuration the live pin still moves and no
spawn the traced instrument can attribute it: one fixture main() per run, banner
naming the sandbox, both censuses silent, watcher still seeing 120 B -> 14 B at
t+280 ms. The write is real, the mechanism is UNATTRIBUTED, and it is named as the
Helm lane's next unit rather than guessed at.
- Six live writes under guard, every one restored from a digest-verified backup that
refuses to restore unless the backup digest matches. Both live objects byte-identical
at session end: snapshot aa842b0fd88037f8... / 14,039 B and held pin
5b6d70716153c3f4... / 120 B. Nothing deployed: /root/.helm/bin/helm-selftest.py is
still 7ed1bca8... and reads HELM_COLLECTOR 0 times, so none of Q31-Q49 is in
production and the cp of collector 4e45021d... + gate 085ddf4f... stays Alexander's.
Deliverable: recoveries/helm-resolved-root-live-path.md (15,220 B).
Scratch tree /root/crucible/q49/. Record, check-in Run 15 and queue block.
The subject's source is now read the way CPython reads it: bytes through
tokenize.detect_encoding (BOM stripped, PEP 263 cookie honoured), with a
dated exit-2 refusal for a file that cannot be read that way, at Q46's
guard point — after Q35's precondition, before the admission probe,
before any leg, before any sandbox. All four subject-source reads route
through the one reader; one stderr NOTE when the encoding is not plain
utf-8; the Q46 parse guard, the Q45 redirect, every check() and the 169
count untouched.
Deliverable recoveries/helm-read-path-guard.md (12,821 B), scratch tree
/root/crucible/q47/, evidence out/Q47-NEGATIVES.json (21 rows),
out/Q47-VERDICT.json, out/Q47-GREEN.json, out/DIFF-vs-q46.txt.
Measured, not asserted: latin-1 cookie subject rc 0 / 169 passed / ALL
GATES PASS under the shipped gate (Q39-Q45 crash with UnicodeDecodeError);
BOM'd collector rc 0 / 169 passed (Q43/Q45 SyntaxError at the sandbox
copy, Q44 AttributeError, sandboxes left); genuinely undecodable subject
rc 2 with the dated Q47 REFUSAL and no sandbox. Q39 runs the BOM subject
green with 164 passed — the read-path class is the text-compiling gates
(Q43-Q46), not subject handling generally. Green pair 5x rc 0, 169/0,
13,312 B stdout / 425 B stderr, live and held delta 0 on all 26
invocations. Adoption pair moves to collector 4e45021d + gate 76f2292b.
Nothing deployed, no cp into /root/.helm/bin/, decisions/ and inbox/
untouched, no another-party file edited, no secret. Run 13 in the
check-in; queue block appended.
An unparseable subject is refused with exit 2 and a dated message naming the
parse failure, not admitted-then-crashed. Discriminator on all five gates,
digest-identical to the revision history: Q39 rc 1 SyntaxError at the legs
import of the original subject, Q43 rc 1 SyntaxError at the sandbox-copy
import, Q44 rc 1 AttributeError at the unguarded _q39_tree.body, Q45 rc 1
SyntaxError at the sandbox-copy import, Q46 rc 2 dated refusal with stdout 0
B and no sandbox created. dep-unparseable refused by Q39 repair 3 on all five
gates. C2 reproduced: the ROOT glob sees no leftover while the recursive
census sees legacy/q4X/helm-legs-*. Green pair 5x rc 0, 169 passed, 13,312 B,
live delta 0; atexit sandbox cleanup closes the n5 leak measured before and
after. Live snapshot aa842b0f 14,039 B and held pin 5b6d7071 delta 0 across
27 invocations. Adoption pair is now collector 4e45021d + gate ae69d5dd.
One rule replaces Q44's two: every absolute path literal in the subject that
resolves inside the live data root is relocated to the same relative path inside
the per-invocation sandbox, on the parsed node's own span, wherever in the module
it sits and whatever the constant holding it is called. Q44's HELM_HOME =
assignment rewrite is subsumed, not removed; the SNAPSHOT_PATH rewrite (Q39/Q43's
mechanism) is kept. Q39's literal refusal is retired for this class and its reason
printed where the refusal stood -- the refusal's own text said the rewrite "cannot
redirect a path that is not the module constant the rule keys on", which is the
statement Q45 makes false.
Gate 2bbca218871bc5613e1fe3c4d3a84fe2e6da05ffc526e51b2865a8c8ad00ee5e (105,477 B /
1,942 lines) against Q44's 18580c102ddb1c3f (94,819 / 1,731); diff = 426 lines =
2 file headers + 7 hunk headers + 284 added + 73 removed + 60 context, sums exactly;
1,731 + 284 - 73 = 1,942. Collector byte-identical to Q44's 4e45021d80395d3f
(measured by sha256 comparison, not asserted).
Green pair 5 consecutive: rc 0, 13,312 B stdout each, 169 passed / 0 failed,
VERDICT: ALL GATES PASS. 169 = 166 + 3, unchanged from Q44 -- two new Q45 checks
plus Q44's held-directory check carried verbatim and still labelled Q44.
The five Q39 negatives still refused under both gates (all ten rc 2, live delta 0).
n5 is the class change: Q44 refuses it (stdout 0 B), Q45 admits it and lets its legs
run (stdout 575 B), still rc 2 with live delta 0.
Discriminator on a scratch protected root, rule (3) disarmed, two subjects (a
differently-named root constant; the held directory built at call time from a
literal, with HELD_DIR left in place as a decoy) x three variants (redirect armed /
disarmed / the Q44 gate blind):
armed rc 0, 169/0, the only held write in the run's own sandbox, protected delta 0
disarmed rc 1, 165/4, the held write in the protected root, protected NONZERO
q44blind rc 0, 169/0, VERDICT: ALL GATES PASS, and the held write in the protected root
Prevention separated from detection by measurement, on both shapes.
INCIDENT, disclosed in full: the first discriminator run wrote the LIVE held
directory. The subject's root literal was /root/.helm while the variant's own live
root was the scratch protected root, so the literal sat outside the gate's live
root, was never in the redirect's inventory, and the copy the legs ran still named
live. Restored byte-exact from /root/crucible/q43z/backup/held.bak by
restore_held.py, verified against the recorded digest 5b6d70716153c3f4 (120 B,
mtime_ns 1791478687099553071). ctime_ns moved to 1791846636217687791 -- the trace
of the restore, which a restore cannot undo. Three mechanical fixes followed in
this tree: make_subjects.py retargets the root literal with an asserted count;
run_negatives.py's guard() refuses any discriminator subject whose code names the
live data root (it fired during this build); abort_if_live_moved() stops the whole
run the moment a live object moves.
Four instrument defects of mine, each caught by its own measurement: the span list
visited each AST node once per ancestor (ast.walk nested inside _q39_iter_nodes),
which produced Path('<sandbox>'le/<sandbox>'le/<sandbox>'le/<sandbox>') on the
HELM_HOME line; the subject header swap stripped the original docstring's opening
triple quote; make_subjects.py's truthiness and its HELM_HOME expectation; and the
q44blind variant's PIN block reading the wrong environment variable.
Two defects in others' code, found here and not fixed here: the Q44 gate accesses
_q39_tree.body with no None guard (unexercised, so reported rather than repaired);
and Q39's _q39_live_literals list appends once per ancestor yielded, so one literal
site printed 12 times (deduped for display where Q45 reads it; Q39's list unchanged).
Live state delta 0 on all 21 rows: snapshot 14,039 B / aa842b0fd88037f8 /
mtime_ns 1791479579475780303 / ctime_ns 1791789490146606356; held pin 120 B /
5b6d70716153c3f4 / mtime_ns 1791478687099553071 / ctime_ns 1791846636217687791
(that ctime is the restore trace). Deployed /root/.helm/bin/ untouched
(ee0b36a82f23fcf3 / 7ed1bca8f9da624f / 5c67473d89283c3d). Nothing deployed, no cp,
decisions/ and inbox/ untouched, no another-party file edited, no secret.
python3 /root/crucible/q44/readback.py, exit 0, VERDICT: ALL READBACKS IDENTICAL,
run after the push of 534be9e. Anonymous raw path, no credential, all three HTTP 200:
recoveries/helm-root-redirect.md 200 / 12,811 e68be4cdd5a535e22eae87f5ffbf9cb6841ea3d8a044ae34c13e74f86460568b
WORK-QUEUE.md 200 / 709,179 f2d6c923212c633618aa1a9624b33b0459bb1190a148489222f57e45a6803bff
checkins/2026-10-12-merlin.md 200 / 84,760 06573214c798bd8e878b84b4157e01b67c20ea3e43a294d59bc716f622f485b2
Each byte-identical on three sides: the bytes the server served, the bytes on disk,
and git cat-file -p 534be9e:<path>. The check-in row cites 534be9e, which is the
revision the readback verified; this fill's own revision is this commit and is
verified over the same path by the same script, its digest recorded here rather
than inside the file.
Nothing else changed: /root/.helm/bin/ untouched (ee0b36a82f23fcf3... /
7ed1bca8f9da624f... / 5c67473d89283c3d...), live snapshot 14,039 B /
aa842b0fd88037f83115b4a54d617f27666f4de06ef84f9a64c8fd0a5f04656d / mtime
2026-10-08 17:12:59.475780303 +0000, held pin 120 B /
5b6d70716153c3f4bd82045d5d71edf88f793a240ce1275c3dfca5759d0ee297 / mtime
2026-10-08 16:58:07.099553071 +0000 -- delta 0 across the run. decisions/ and
inbox/ untouched, no another-party file edited, no secret.
Deliverable recoveries/helm-root-redirect.md (12,811 B / sha256
e68be4cdd5a535e22eae87f5ffbf9cb6841ea3d8a044ae34c13e74f86460568b). Scratch tree
/root/crucible/q44/; harness run_negatives.py -> out/Q44-NEGATIVES.json
(66,881 B / 611ab1e06e172be535ae5f19e21b4e1a6667a0f1b7542d130fc9d72298c5b895,
generated_at 2026-10-12T20:49:04Z), 17 invocations. Nothing deployed, no cp into
/root/.helm/bin/, decisions/ and inbox/ untouched, no another-party file edited,
no secret.
The pair: subject collector 4e45021d80395d3f... (29,954 B / 720 lines) byte-identical
to Q43's -- every change is in the gate. Gate 18580c102ddb1c3f...
(94,716 B / 1,731 lines) against Q43's c22601ecea4192d9... (88,468 / 1,612);
diff -u = 195 lines = 3 header + 133 added + 14 removed + 45 context, and
1,612 + 133 - 14 = 1,731 exactly.
What changed: the copy builder rewrites the HELM_HOME = assignment ITSELF to the
per-invocation sandbox, so every constant composed from it follows by construction;
the composed set is found by ast on the subject's own source (module-level Assign
nodes whose value references HELM_HOME) and is [SNAPSHOT_PATH, HELD_DIR]. The
SNAPSHOT_PATH rewrite is kept as defence in depth. Rule (3)'s --pin refusal is kept
but reclassified as defence in depth. Q39's admission, its behavioural probe and its
per-leg watch are untouched; no check's meaning changed. Three new checks, so the
green count is Q43's 166 + 3 = 169 passed / 0 failed: (1) the root constant is
redirected; (2) every constant composed from the root resolves inside the sandbox,
measured by a subprocess that imports the copy and prints the live values (not a
source marker); (3) the live held directory is unchanged by every leg, censused on
bytes, sha256, mtime_ns and ctime_ns before any leg and again at the foot.
Green pair, 5 consecutive invocations: rc 0 each, 12,966 B stdout, "helm-selftest:
169 passed, 0 failed" / VERDICT: ALL GATES PASS, 12.00-12.14 s; log digests
5c519157eaec4a40... / 97916ab27b8521c0... / 6f5553364b7a0d09... / ad57bad15689dfc5...
/ 00a1ae6dc2519efc... . Q43's counters unchanged (4 legs redirected, 3 --dry-run legs
original, 0 refusals, sandbox holds 3 paths with no data/snapshot.json).
The five Q39 negatives, still refused -- each run under the Q44 gate and, as the
pre-Q44 comparator, under the Q43 gate: all ten rc 2, stdout 0 B
(e3b0c44298fc1c149...), no report block, live delta 0, live held delta 0, 0.14-0.21 s.
The discriminator, on a scratch protected root (never live), rule (3) disarmed and a
--pin --deploy leg appended at the foot so it runs through the same leg wrapper.
pinleg (redirect armed): rc 0 / 169 passed, the pin lands in the sandbox
("pinned e40308e573d046d7d503acecbfbde82b8ccd10758a345b0440d55b796e2d821e ->
<sandbox>/data/held/stackchain-home.html.sha256"), protected held file delta 0
(114 B / b58d2d0eb9f45862b... / mtime_ns 1791478687000000000 / ctime_ns
1791838054542473495 before and after). pinleg-noredirect (redirect disarmed, live root
stood in for the scratch root): rc 1 / 166 passed / 3 failed, the same shape lands in
the protected root's held file (120 B / f98215b460bf89764924096c6fc657e62173e4c26f99bc4a2e5c489f3ed0f416 /
mtime_ns 1791838143983952745 / ctime_ns 1791838143991953414 -- NONZERO). Prevention
separated from detection by measurement. The live-path write was NOT re-measured: it
would clobber /root/.helm/data/held, Q43 already measured it (pinned 5e5cd6d26a70...)
and this run's pinleg reproduces the same body digest e40308e5... from the same code
path, so the class is the same one.
Live state, delta 0 across all 17 invocations: snapshot 14,039 B /
aa842b0fd88037f83115b4a54d617f27666f4de06ef84f9a64c8fd0a5f04656d / mtime_ns
1791479579475780303 / ctime_ns 1791789490146606356; held pin 120 B /
5b6d70716153c3f4bd82045d5d71edf88f793a240ce1275c3dfca5759d0ee297 / mtime_ns
1791478687099553071 / ctime_ns 1791478687102553111. Deployed bin untouched
(ee0b36a82f23fcf3... / 7ed1bca8f9da624f... / 5c67473d89283c3d...).
Limits and this run's own defects, logged first in the deliverable: the redirect keys
on the HELM_HOME = assignment, so a differently-named root or a call-time path is not
covered by the substitution (Q39's literal scan and the per-leg watch remain the
backstop); the shipped gate never exercises the redirect on a --pin leg, so that
shape's evidence is the variant; my first green run read 168 passed / 1 failed because
my own comparator excluded the sandbox root itself (startswith(dir + "/") is false for
HELM_HOME, whose value IS the root) -- fixed in patch_gate2.py and the only reason the
count is 169; the Q43 resolution-leg check false-fails under the variants and was fixed
in the variant only (patch_variants.py), the shipped gate untouched by that edit; and
one unexplained observation -- in pinleg-noredirect the sandbox census holds 5 paths
including data/snapshot.json, i.e. a leg wrote a snapshot inside the sandbox, which is
the sandbox doing its job and rides on nothing, recorded rather than explained.
Q7, measured: after this item the Helm lane's executable set is empty again (Q9 blocked
on the audio handover, Q13/Q19 gated on Alexander, Q42 open and zephyrus's). No new item
opened. The section 4 adoption is now a three-file ask: collector 4e45021d... + gate
18580c1..., with Q40's finding unchanged -- the deployed gate 7ed1bca8... has no
subject-selection path at all.
anonymous raw path (200 / cmp byte-identical, readback.py exit 0, VERDICT: ALL
READBACKS IDENTICAL) and the table filled with the measured digests
The table cites the committed revision 0fb8b20 for this check-in's own row
(200 / 75,361 B / fc4e750b392d2099c11703b8ea0f4e26036ea3a86b0123a8e2a5c1a6a53393ff,
reproduced locally by `git cat-file -p 0fb8b20:checkins/2026-10-12-merlin.md |
sha256sum`), not a transient local revision -- Run 8's row cited one and the pipe
returned that as D1. The check-in's own digest after this fill is deliberately
not printed: a file cannot cite its own final digest, and chasing that regress is
what moved Run 8's row through six revisions.
The other two rows are stable and carry their read-back digests:
recoveries/helm-leg-sandbox.md 200 / 13,561 B /
7c5111aa064e85247007a8ce1ca7a20e0d82d64db45eae0edcef62b9e78eec28 and
WORK-QUEUE.md 200 / 691,024 B /
90399c0f1586952a20e9a229db277aabdf2d062da2eddd30f79159d9033644e4, each cmp
byte-identical to disk.
Read-back at 2026-10-12T18:34:33Z, no credential. Nothing deployed, no another
party's file edited, no secret printed.
Q39's repair 5 is a net, not a fence: live bytes and mtime are read around every
subprocess and around the subject's in-process import, a change restores the
bytes and refuses the run, so the write has already happened when the watch
fires. Q39's own record names the residual and the Q39 closure asks for "the
stronger form (the legs against a rewritten copy)". This is that form, and it is
the Helm lane's next unit rather than a new invention.
Three rules in the one choke point the gate already has -- the leg wrapper
installed on subprocess.run, so every future leg inherits them:
1. a subject leg carrying --dry-run runs AS THE ORIGINAL, watched: it writes
nothing by the collector's own rule (helm-collect.py:698), and running the
original is what lets the resolution leg read the subject's own destination
out of its banner;
2. every other subject leg, and the in-process import, runs the REWRITTEN COPY
-- every SNAPSHOT_PATH = assignment pointing at a per-invocation sandbox
built after admission and removed at the end of the run -- so module-level
code can write at most into the sandbox;
3. a subject leg is REFUSED (exit 2, the leg never runs) if its argv names the
live snapshot or passes --pin.
Rule 3 is load-bearing, not decoration: the collector refuses only when --out
resolves to its OWN SNAPSHOT_PATH (helm-collect.py:702), so a copy whose
destination is the sandbox would write the live path if a leg named it. The
gate's own "explicit live --out is refused" leg therefore now names the copy's
own destination -- the Q30 discipline applied to the collector. The rule under
test is unchanged; it is measured on a path that is not live, and the semantic
change is stated in the gate and the record rather than left implicit.
Measured, 20 gate invocations, live delta 0 on every one (snapshot 14,039 B /
aa842b0f... / mtime_ns 1791479579475780303; held pin 120 B / 5b6d7071... /
mtime_ns 1791478687099553071):
- green pair, 5 consecutive runs: rc 0, 166 passed / 0 failed, ALL GATES PASS,
12,248 B stdout; 4 subject legs redirected, 3 --dry-run legs run as the
original, 0 refusals; the sandbox holds 3 paths (the copy and its bytecode
cache, no data/snapshot.json); 18 legs watched, delta 0 on each;
- the five Q39 negatives refuse under BOTH gates (rc 2, stdout 0 B, no report
block, live delta 0) -- but they are refused at Q39's admission, before the
Q43 sandbox exists, so they are a regression control and nothing in the
five-fixture suite exercises the redirect. Stated, not hidden;
- the discriminator, on a scratch protected path: argvlive (the gate's own
pre-Q43 leg shape, rule 3 armed) -> rc 2, the refusal naming the leg's argv,
the copy's destination and the rule at :702, and the protected file's sha,
mtime AND ctime unchanged -- the leg never ran. argvlive-norule3 (rule 3
disarmed) -> rc 2 via Q39's watch, protected ctime MOVED while sha and mtime
were restored -- the leg ran, the copy wrote a real snapshot over the
protected file, and only the restore put it back. ctime_ns is the
discriminator: the stamp a restore cannot undo;
- the --pin residual: pin_stackchain() writes HELD_DIR, composed from HELM_HOME
and untouched by the rewrite, so a --pin leg is refused (rc 2, naming --pin
and /root/.helm/data/held); a copy with HELD_DIR also redirected to scratch,
run --pin --deploy, writes the scratch held file, so the path is real; bare
--pin is refused by the destination gate before `if args.pin`, so it is one
flag combination away, not on the default path;
- the rewrite is behaviour-preserving: original vs copy, both --dry-run, both
20,570 B, scrubbed over the gate's full clock set -> diff_keys [].
Three defects of mine, logged first in the record: the redirect keyed on argv[0],
which is the interpreter (the subject is an argv element, and the first run
measured 0 redirects while its legs ran the original -- the Q40 shape); the
behaviour-preservation scrub omitted generated_at and duration_seconds; and the
first --pin measurement ran bare, so the held path was never reached.
Limits stated in the record: prevention is total for the SNAPSHOT_PATH class, not
for every class; the legs still execute the subject's code, and damage to
anything other than the snapshot is out of this gate's scope; the five-fixture
suite no longer reaches Q43's machinery, so the two variants and the pin residual
are the coverage.
Nothing deployed: no cp into /root/.helm/bin/, the deployed bin is unmoved
(ee0b36a8... / 7ed1bca8... / 5c67473d...), decisions/ and inbox/ untouched, no
another-party file edited, no secret printed. Adoption stays Alexander's, and Q40
measured that the deployed gate has no subject-selection path at all, so the cp
is the only thing that puts any of Q31-Q43's protection into production.
Reproduces the Q39 closure's C26 from this host and states the mechanism:
`grep -c HELM_COLLECTOR /root/.helm/bin/helm-selftest.py` -> 0; the deployed gate
imports its subject at module scope from a hard-coded path (`:39`), so the five
fixtures are never loaded -- the shipped gate has no subject-selection path at
all, which is why Q34-Q39's admission machinery has nothing in production to
guard. Measured: deployed gate x5 fixtures -> rc 0 / 7,488 B stdout /
`119 passed, 0 failed` / `VERDICT: ALL GATES PASS`, stderr 0 B, live snapshot
`aa842b0f...` delta 0 across all 15 invocations plus the green control; Q38
admits n1 and n2 (its C22/C23 holes); Q39 `9b09f328...` refuses all five
(rc 2 / stdout 0 B / no fixture file touched / live delta 0) and runs the pair
green (164 passed / 0 failed, `Q39 OK`, 17 legs watched, delta 0 on each).
Nothing deployed, no `cp`, `/root/.helm/bin/`, `decisions/` and `inbox/`
untouched. Deliverable `recoveries/helm-deployed-gate-admission.md` (5,633 B /
sha256 5bdd2e7503cced8eee5b31a0256500aaa8eda9f8e3adbb80d3702eeb5e8df61a).
Reproduces the Q39 closure's C26 from this host and states the mechanism:
`grep -c HELM_COLLECTOR /root/.helm/bin/helm-selftest.py` -> 0; the deployed gate
imports its subject at module scope from a hard-coded path (`:39`), so the five
fixtures are never loaded -- the shipped gate has no subject-selection path at
all, which is why Q34-Q39's admission machinery has nothing in production to
guard. Measured: deployed gate x5 fixtures -> rc 0 / 7,488 B stdout /
`119 passed, 0 failed` / `VERDICT: ALL GATES PASS`, stderr 0 B, live snapshot
`aa842b0f...` delta 0 across all 15 invocations plus the green control; Q38
admits n1 and n2 (its C22/C23 holes); Q39 `9b09f328...` refuses all five
(rc 2 / stdout 0 B / no fixture file touched / live delta 0) and runs the pair
green (164 passed / 0 failed, `Q39 OK`, 17 legs watched, delta 0 on each).
Nothing deployed, no `cp`, `/root/.helm/bin/`, `decisions/` and `inbox/`
untouched. Deliverable `recoveries/helm-deployed-gate-admission.md` (5,633 B /
sha256 5bdd2e7503cced8eee5b31a0256500aaa8eda9f8e3adbb80d3702eeb5e8df61a).
Reproduces the Q39 closure's C26 from this host and states the mechanism:
`grep -c HELM_COLLECTOR /root/.helm/bin/helm-selftest.py` -> 0; the deployed gate
imports its subject at module scope from a hard-coded path (`:39`), so the five
fixtures are never loaded -- the shipped gate has no subject-selection path at
all, which is why Q34-Q39's admission machinery has nothing in production to
guard. Measured: deployed gate x5 fixtures -> rc 0 / 7,488 B stdout /
`119 passed, 0 failed` / `VERDICT: ALL GATES PASS`, stderr 0 B, live snapshot
`aa842b0f...` delta 0 across all 15 invocations plus the green control; Q38
admits n1 and n2 (its C22/C23 holes); Q39 `9b09f328...` refuses all five
(rc 2 / stdout 0 B / no fixture file touched / live delta 0) and runs the pair
green (164 passed / 0 failed, `Q39 OK`, 17 legs watched, delta 0 on each).
Nothing deployed, no `cp`, `/root/.helm/bin/`, `decisions/` and `inbox/`
untouched. Deliverable `recoveries/helm-deployed-gate-admission.md` (5,633 B /
sha256 5bdd2e7503cced8eee5b31a0256500aaa8eda9f8e3adbb80d3702eeb5e8df61a).
Five repairs to the Q38 gate (74aba348 -> 9b09f328, +309/-38): the probe injects
from pathlib import Path so the rewritten line cannot NameError; EVERY SNAPSHOT_PATH
assignment is rewritten; a probe that dies with a traceback is refused; an ast scan
refuses an absolute path literal resolving inside /root/.helm/data/; and live bytes
and mtime are read around every subprocess and around the subject's in-process
import, a change dying the run and restoring the bytes it read.
Negative controls (q39-negatives.py, Q39-NEGATIVES.json): five fixtures, each run
under BOTH gates. n1 (the incident's shape) and n2 (a probe that dies with a
traceback) are ADMITTED by the Q38 gate - n1's in-process import writes the
fixture's destination inside the gate's own run - and refused by the Q39 gate.
Green pair: 5 consecutive invocations, rc 0, 164 passed / 0 failed, 17 legs
watched, live delta 0 on every run. Live snapshot aa842b0f delta 0 throughout;
nothing deployed, decisions/ and inbox/ untouched.
Q35's precondition reads a source marker (--deploy and SNAPSHOT_PATH.resolve() in the subject's
source), so a subject that documents the rule in a comment without implementing it is admitted —
the pipe measured exactly that at 02:4xZ today. The gate now, at helm-selftest.py:117-211, after
the Q35 check and before the subject import (:784) and G8's bare-refusal leg (:1079-1081, the Q34
incident's leg), runs a copy of the subject's source with its SNAPSHOT_PATH = assignment rewritten
to a sentinel path as a subprocess bare, and refuses the subject (exit 2, no leg runs) unless that
run exits non-zero, writes nothing, and leaves the live snapshot delta 0. The probe never imports
the subject into the gate's process.
Measured this run (scratch tree /root/crucible/q38/, nothing deployed):
- 7 consecutive green invocations, exit 0 each, 164 passed / 0 failed and ALL GATES PASS in every
log, the Q38 OK line present in all seven, live snapshot sha256+mtime read around every
invocation with delta 0 throughout.
- Discriminator on both sides: fake-documented-no-rule.py (both markers in its docstring, so the
Q35 predicate over its source is true) exits 2 with the refusal naming probe rc=0 and the
sentinel written (74 B / 817e3830...); fake-marker-only.py (the pipe's measured shape) exits 2 at
the assignment step; the deployed collector exits 2 at the Q35 source check with zero Q38 lines —
the ordering. The admission control: fake-marker-only.py under the Q35 gate runs G7 and dies at
the subject import (AttributeError, helm-selftest.py:688) — the admission measured end to end.
- Gate 1,044 -> 1,141 lines (+97/-0; DIFF.txt 108 lines / ac8e52bb...), sha256 643e5387... ->
74aba348...; collector byte-identical to the Q34/Q35 pair (4e45021d..., 720 lines).
- Live snapshot /root/.helm/data/snapshot.json 14,039 B / aa842b0f... / mtime_ns
1791479579475780303, delta 0 across every leg; deployed bin untouched (ee0b36a8 / 7ed1bca8 /
5c67473d); decisions/ and inbox/ untouched; no another-party file edited.
Section 4 consequence: the adoption pair is now collector 4e45021d... + gate 74aba348...
(superseding 643e5387...); the cp into /root/.helm/bin/ remains Alexander's.
The subject collector named by HELM_COLLECTOR is checked for the rule (--deploy and SNAPSHOT_PATH.resolve() in its source) at helm-selftest.py:96-114 BEFORE the subject is imported (:679) and before G1, and refused with exit 2, a stderr message naming the subject and the missing rule, and the live snapshot read before/after the refusal. Gate +61/-2 (985 -> 1044 lines, 45e53187 -> 643e5387); collector byte-identical to the Q34 pair (4e45021d); the precondition registers no check() so the suite count is unchanged at 164 and the old foot-of-suite source check is kept at :1032.
Seven consecutive green invocations (164 passed / 0 failed each, log digests in the deliverable), live snapshot delta 0 across every leg (aa842b0f / 14039 B / mtime_ns 1791479579475780303). Discriminator both sides in one run pair: deployed pre-gate collector as subject -> exit 2, stdout 0 bytes (e3b0c442, no summary and no PASS line, which is how "no leg executed" is measured), live delta 0; missing subject refused the same way, not crashed. Mechanism probe from this tree (q35-mechanism.py, mech-probe.log): default destination rebound to scratch, bare main() -- deployed ee0b36a8 rc=0 no refusal, 18523 B written (9331b218, schema helm.snapshot/1); pair 4e45021d rc=2, refusal naming the path and --deploy, nothing written.
Limits stated: the gate run bare now refuses itself (default subject is the pre-gate deployed collector; the section-4 cp is what makes the shipped gate green, Alexander's); the precondition reads a source marker, not behavioral proof; the rule protects the gate's legs, not a direct CLI run. Nothing deployed; decisions/ and inbox/ untouched.
- reproduced the defect first: python3 helm-render.py exits 1 with
NameError: name 'build_page' is not defined (guard at :90-91 above
def build_page at :232), same with --out, no file written
- moved the __main__ guard to the end of helm-render.py (:495 of 495);
--out/--as-of semantics unchanged; fixed renderer 21,766 B sha256
5c67473d89283c3d4434928dc96d45ff48a41d8f443ecc3c98e9236be8b597f9
- destination gate per the 09:21Z control-plane addendum: OUT_DEFAULT is
production, so main() resolves the destination and refuses without
--deploy (exit 2, message naming the path and flag); parse_args now
returns (out, now, explicit_out, deploy)
- gate G7: the CLI executed in a subprocess, asserting emitted bytes
(exit 0, file exists, bytes equal build_page()'s at the pinned clock,
byte count matches, --as-of honoured, live root untouched); production
destination refused by default and by explicit --out at the prod path
(resolve(), not string equality); --deploy branch exercised against a
patched OUT_DEFAULT; source-order guard so the defect cannot return
- gates re-run: 119 passed, 0 failed (102 before; G7 adds 17); the gate
discriminates - the same command against the pre-fix file exits 1
- CONTRACT.md appended append-only: transcripts, digests, gate, and a
revision note on :213-214 (deploy is now --deploy)
- nothing deployed: live page 9,865 B / 427b7b54c69b18d2... and snapshot
aa842b0fd88037f8... unchanged before and after every run; --deploy
alone never executed
recoveries/helm-render-aging.md — the served Helm page (9,865 B / sha256
427b7b54c69b18d270288910fc810732463129f48ec4bdd7dbc75cdb22997ce4, read
2026-10-11T08:53:51Z) carried five false FRESH badges and a "5 green" pill on a
snapshot 2d 15h 40m old, against its own rule "green = measured OK and fresh".
The honest reading was 0 green / 6 not green. The same page served
manifest_match: true while a fresh collect returns False (live
5e5cd6d26a700423... vs held f27326e8b13d1dec...). No Helm cron job exists.
helm-render.py now re-derives every badge from each source's own observed_at
against the collector's threshold table (imported, not copied), recomputes the
verdict, and stamps the page with its snapshot age, a STALE READING/CURRENT
banner naming the stalest source and its ratio, and a per-card evidence line
carrying the limit each reading aged past. --as-of pins the render clock.
Roster identity was filename_body.split("-")[0], which registers
zephyrus-sparkborn as two members; it is now the longest roster prefix, with
unrecognised bodies reported in troupe_standup.unrecognised_bodies rather than
silently attributed. Fresh collect: 4 members, unrecognised_bodies: [].
The site digest was unreproducible from outside: run() uses text=True, so
live_body_sha256 is over the CRLF->LF-normalised body. 217,162 wire bytes /
9a5ee1328d4a3fedd... vs 217,149 normalised / 5e5cd6d26a700423..., delta 13 = the
13 CRLF pairs, lone CR 0, raw.replace(CRLF,LF) == normalised. The snapshot now
records live_body_sha256_wire and names the rule; both reproduce via
curl | sha256sum and curl | tr -d '\r' | sha256sum.
helm-selftest: 102 passed, 0 failed, six gates. Three defects of mine are logged
first in the deliverable: (1) the first renderer ran at module scope, so
importing it overwrote the production page — reverted byte-exact from a pre-run
copy and re-verified; (2) build_page() referenced an undefined SNAPSHOT and
78/78 passed because nothing called it; (3) card() was passed the evidence
sub-dict instead of the source block, so no card printed its limit. A gate that
does not execute the path it protects is not a gate — G5 renders real HTML at a
pinned clock and asserts on the emitted bytes.
Nothing deployed: /var/www/alexander-whitestone/helm/index.html unchanged at
9,865 B / 427b7b54c69b18d2... throughout; staged pages live in
/root/crucible/helm/. Deploy is one command and Alexander's under section 4.
/root/.helm/data/snapshot.json not clobbered (aa842b0fd88037f8... before and
after). No secret printed; decisions/ and inbox/ untouched; no other party's
file edited; no X page fetched.
32 emit sites in build_blocks.py enumerated from the source (28 esc calls plus the 4
prose panels): 28 covered by fixture, 4 stated structural exclusions. 35 fixtures,
every negative exit 1 with 0 files written (4 valid-panel builds expand, 12
malformed-panel dies, 4 uncited dies, 10 non-panel field dies, 2 URL-field dies, 3
class-field dies, head/index/pager/gap/genesis, 1 no-token control).
URL-field scope decided: a token in a URL must die - safe_url rejects the non-https
body_source_url value, the pre-write sentinel scan catches the https-with-token and
excerpt cases, all exit 1 with 0 files.
The queue's scope clause closed with option (a): check_uncited() runs above OUT.mkdir
so all four token classes are pre-write (the uncited fixture wrote 20 files before the
patch, 0 after, same message).
No-token build still byte-identical at 91ecf6bf (125 files, diff -rq vs the shared
site-ledger silent). Shared tree untouched at 97fedb5d with blocks.json 63c9cee6; live
index 200 / 34,488 B / 4f764ef4dfb9. Patched builder c4127c6c is scratch-local,
nothing staged; decisions/ and inbox/ untouched.
Merlin