Tooling: opt-in parallel layer-end controls for the frontier1042 leaver chain, byte-identical receipts, 3.1x (extends #1059, no new kappa)

[thakrarsagar]

Tooling (verification engineering). No new κ, no change to any pinned file, and no check is weakened. Extends merged #1059 to the leaver variant of the frontier1042 chain.

What

A cold make frontier1094-verify (the selected verifier) runs verify_frontier1042.py as its baseline1042-cold stage. The recorded frontier1042 run took 1162 s, and 530 s of that are the chain's five layer-end-control steps (lec-p6n, lec-promo, lec-jx, lec-hyb, lec-frames). Each step runs the Q6Reviewer-signed layer_end_controls_leaver.py v2 (4ba676f1…) through the pinned run_portable.py (322d29d4…). That script audits the unmutated word and 95 mutants with PR635's hpe_audit_and_transport.run (c9a05ff2…), one audit after another.

research/frontier1042-lec-parallel/ adds an opt-in, drop-in parallel runner for these steps. Merged #1059's runner is hardcoded to the T37 variant layers_p6n/layer_end_controls.py (fc58c569…), so it cannot run these steps. This runner accepts both variants by digest, and checks the T37 one against the archived T37 receipt as well. Scripts are accepted by digest, so the 3 + 10 byte-identical copies on main are covered, as are the 4ba676f1 copies in open #1104 (d8982686) and #1107 (6123fc5d).

How

The pinned launcher, the scripts and PR635's audit are run unedited, after a digest check.

1. Record. The pinned script runs once with a stand-in audit module that only records each trial word's exact bytes. That pass decides nothing, and its receipt is discarded.
2. Evaluate. The real audit evaluates every distinct word in a spawn pool, keyed by the sha256 of the exact bytes plus the routing path.
3. Replay. The pinned script runs again. Its own assertions see the real outcomes and the captured audit output for the identical bytes, and it writes the receipt. The trial sequence must match the recorded one.

chain_lec.py runs the five steps as reproduce_leaver_chain.py's lec() does, sharing one outcome table. The k8 X4 exchange is the identity, so lec-jx re-audits exactly lec-promo's words and audits nothing new. Before each step it binds the word to the chain's recipe pins. After each step it applies lec()'s CHAIN-PINS-k8 checks: the pins-file digest, PASS status, 95 rejected controls and the not-applicable sites.

Evidence (verify.py; the serial bullet needs --serial)

• Archived receipts. All five receipts equal the maintainer receipts in community-frontier1042-audit/selected-replay.tar.gz byte for byte. Only the recorded input path (word) is rewritten, and it must occur exactly once. The T37 receipt is checked the same way against t37-replay.tar.gz.
• Pinned serial reference (--serial). All six receipts are byte-identical to the pinned serial steps on the same paths. The logs are identical except for the audit's own wall-clock "seconds" value.
• Controls. No control leaves a receipt.
  • C1: a corrupted unmutated word fails at the script's own first assertion.
  • C2: a forged acceptance of one mutant fails with cold-end mutation accepted.
  • C3: a forged reason fails with rejected for the wrong reason.
  • C4: a one-byte change to the script or to the audit is refused before any work.
• Unit tests (7). They cover the placeholder, the pins, the recipe pin set and the jx == promo identity. They also check that run_pinned restores global state, that the portable gzip header reaches the trial words, that the routing key keeps a symlink's own suffix, that a killed worker fails the wait, and that the real audit accepts the word and rejects a corruption.

Benchmark

macOS arm64, 10 cores, Python 3.14.8, --jobs 10, on a shared machine. The raw receipt from the committed code is BENCHMARK-macos-arm64.json. These numbers are descriptive only.

	Recorded serial	Pinned serial	Parallel
five frontier1042 steps	529.5 s	314.3 s	100.2 s (3.1×)
T37 variant	77.0 s	81.2 s	26.2 s (3.1×)

Two earlier runs of the same algorithm, before the review fixes, gave 266.7 → 97.1 s and 293.5 → 143.6 s. The remaining cost is the pinned script's own mutant construction, which by design runs twice: once in the record pass and once in the replay.

Scope and honesty notes

• Opt-in, not wired. reproduce_leaver_chain.py and verify_frontier1042.py are manifest-pinned and unchanged. In lec(), wiring would mean running lec_parallel.py WORD ROUTING OUT instead of the launcher plus script. That is the maintainers' call.
• Who benefits. No pending claim reruns these steps, because claims reuse the k8 chain. The steps run when the chain is rebuilt, for a batch's shared candidate replay and for the selected replay, and in cold frontier1042-verify runs.
• Phases steps. The verifier's three phases steps (cells, chain and slots stages; 469 s) call the same pinned phases_full.py that merged Tooling: opt-in parallel exact U8 phase recipes, byte-identical; 5.7x alone, 28.8x with merged PR662 evaluator (no new kappa) #1041's runner accepts. This PR does not re-measure them.
• No Makefile targets. research/community-batch1099-audit pins the Makefile by exact digest, so an append would fail scripts/verify_pr_reconciliation.py. That check passes on this branch.
• Tooling: opt-in parallel U8 layer-end controls, byte-identical receipt, 3.0x on 10 cores (no new kappa) #1059 (merged). It is a separate package, so Tooling: opt-in parallel U8 layer-end controls, byte-identical receipt, 3.0x on 10 cores (no new kappa) #1059's pinned files and receipts stay untouched.
• Tooling: fast exact HPE transport audit for the layer-end controls, 2.53x, 480/480 trials cross-checked (seed 93, no new kappa) #1137 (Wronskode, open, head e3b8fa39) targets the same five steps differently. It is a faster exact re-implementation of the audit, cross-checked against the pinned one, with 2.53× on a single process. This PR keeps PR635's pinned audit unchanged and spends cores instead. The two compose partly. Here the audits mostly overlap the record pass, with 0.8–2.2 s of wait per audited step. A faster audit would remove that wait and reduce CPU contention, but not the floor, which is the pinned script's own mutant construction and runs twice.
• Recorded replay. The recorded frontier1094 replay (58 s) reused the completed frontier1042 baseline. These steps run on cold verifies and on chain rebuilds.

Reproduce

python3 -B research/frontier1042-lec-parallel/verify.py --work NEW_DIR            # ~3 min
python3 -B -m unittest discover -s research/frontier1042-lec-parallel -p test_package.py
python3 -B research/frontier1042-lec-parallel/verify.py --work NEW_DIR --serial   # + pinned serial (~9 min)

The expected last line of verify.py is PASS_FRONTIER1042_LEC_PARALLEL. It needs standard-library Python 3.11+ and no network.

Assignment, credit and disclosure

• Assignment. Track 85–94 (verification engineering), seed 89 (OS CSPRNG). Base ce7ad1b6.
• Selection. Six read-only scout subagents and three judges compared candidates: the T37 audit fast copy, emit, stage DAG, mid-size stages, cold Conditional κ = 0.001661634653669567: four paired read exchanges on PR741's frame-coalesced word #799, and a repo-wide sweep. A three-lens recheck against the new main then chose this one, and two adversarial review subagents checked the package. Their fixes are in the second commit.
• Credit.
  • Q6Reviewer: the signed layer-end scripts.
  • DreamingOfClouds: the original controls.
  • PR635's authors: the audit.
  • LeaverSAT and LeaverSAT2: the k8 cells and recipes.
  • ColdWitness: the chain driver.
  • icekylinx: gauge44.
  • Jeremy Kothe, Rohan Arun and Hao Yan: frontier1042.
  • Douglas Colkitt, with OpenAI Codex: maintainer orchestration and the archives.
  • Prior concurrency tooling: Tooling: 1.54-1.71x faster #741 complex replay by running independent pinned stages concurrently #853, Tooling: schedule isolated test modules concurrently with identical receipts (3.3-3.9x faster verify-tests, no new kappa) #921 (navinor), Tooling: overlap bit589 and complex741 in the #741 ancestry replay, 17% (50% with --complex-jobs 3) less wall time (no new kappa) #1101 (rcfc-jreed), Tooling: opt-in parallel exact U8 phase recipes, byte-identical; 5.7x alone, 28.8x with merged PR662 evaluator (no new kappa) #1041 and Tooling: opt-in parallel U8 layer-end controls, byte-identical receipt, 3.0x on 10 cores (no new kappa) #1059.
  • Wronskode: Tooling: fast exact HPE transport audit for the layer-end controls, 2.53x, 480/480 trials cross-checked (seed 93, no new kappa) #1137, the concurrent fast-audit approach.
• AI disclosure. Prepared by Sagar Thakrar (thakrarsagar) with substantial AI assistance from Claude (Anthropic) via Claude Code. New material is Apache-2.0.

[Mister-Meeseeks]

100-PR batch review at 99d4f42f7cfe5f60d14316ef18e9455c38eaa290.

Merged to main, preserving the original contributor commits and package attribution.

Reviewed scope: Opt-in leaver layer-end parallel control runner; exact mutation coverage and pinned reasons must finish before accepting the claimed complete comparison.

The pinned scoped command passed; the batch ledger contains its command, input hashes, environment and log. This incorporates the research/tooling contribution and does not change the selected κ or discharge the inherited multiplication-theorem assumptions.

Batch review, attribution and evidence. Thank you for the contribution.