Research log Small Model Experimentation
GitHub

Count-Walk Replay Compound (Stage 8)

Finished2026-07-17Agentic Breadth InstallationPosttraining and AdaptationGitHub ↗
Bounded: replay compounding stops adding at stage 8 — the first time this reliable move failed

The one idea you need

The team has spent months building one model through a documented chain of training rounds, like coats of varnish: each round trains a small add-on on top of the current model and folds it in, and each documented round so far has raised the model's overall score on sealed exams. One reliable trick in that chain is the 'replay round': re-teach the model its own accumulated practice problems (nothing new, just the full review deck) and fold that in. At the last stage this exact trick added about two points even as a control. The open question is whether the trick has run out: the current model is the best in the chain, and re-teaching an already-good student their old notes must stop helping at some point.

The question

Does an eighth coat of varnish still shine - if the current best model gets one more replay round over the full 2,240-problem review deck, does its sealed-exam score go up without any subject collapsing, or has the replay trick hit diminishing returns?

What we found

The believed-likelier outcome, delivered cleanly. 'Replay compounding' — retraining on the accumulated replay mixture — had lifted the aggregate score at every previous link in this model's build chain, so it was the safest broad move available. On the eighth link it stopped working: the new model scored 0.342 versus the parent's 0.363, a genuine drop, and one task family (warren) fell far enough to trip the guardrail on its own. The pre-registered rule reads that as BOUNDED: the move has hit diminishing returns on this particular parent, which is already saturated with replay data, so more of the same just reshuffles strength between families instead of adding it (two families up, three down, net negative). The parent model stays the reference. The useful part is the knowledge: we now know the cheap reliable lever has a ceiling here, so the next push has to be a different KIND of move, not another dose of the same one. The new model still crushes the raw base model by 0.238 and wins 8 of 10 families against it.

Why it matters

The chain is the program's flagship artifact: a fully documented, contamination-free recipe that turned a 0.08 base into a 0.36 model. Knowing exactly where its cheapest move stops working is worth one sealed exam: if replay still compounds, the floor rises for free; if it is bounded, the program stops burning exams on re-rolls and must invent a genuinely new move class.

Candidate vs parent0.342 vs 0.363aggregate dropped 0.021 — a real loss
VerdictBOUNDEDwarren also dipped 0.15 past the family slack
Chain historyfirst missreplay added aggregate at every prior stage
vs base (desc.)+0.2388 family wins, 1 tie, 1 loss — descriptive only
On this page
  1. Results at a glance
  2. Overview
  3. Report
    1. What this cell asks
    2. The frozen design
    3. Honest priors (frozen before the event)
    4. Verification state at freeze
    5. Results
    6. Interpretation
  4. Experiment log
  5. Data files
  6. Reproduce
  7. Related

Results at a glance 1

Stage 8: replay compounding hits diminishing returns (BOUNDED) The frozen two-state rule fired BOUNDED: a fresh replay adapter on the count_walk composite (stage 8, seed 86) dropped the aggregate 0.0206 below the parent (0.3420 vs 0.3626 — a real loss, the 1e-12 tie guard inactive) AND warren dipped 0.15 past the one-episode family slack. Either condition alone fires BOUNDED; both did. This is the first stage in the documented chain where replay compounding — which added aggregate at every prior stage — failed to add: replay on an already replay-saturated parent redistributes rather than accumulates (lockpick +0.1, toolsmith +0.07 offset by menders -0.1, mirage -0.1, warren -0.15). The count_walk composite remains the program reference artifact; further aggregate pushes need a different move class. Descriptive only: the candidate still beats base by 0.238 (8 family wins, 1 tie, 1 loss vs base).

aggregate score · arm →

00.10.20.30.4basebase0.104count_walk (parent)count_walk (parent)0.363replay_compound (candidate)replay_compound (candidate)0.342
Data table
armaggregate at sealed seed 78168
base0.104
count_walk (parent)0.363
replay_compound (candidate)0.342

Numbers from experiments/qwen35_4b_count_walk_replay_compound/runs/benchmark/medium_tb1024_seed78168_compound/summary.json

In the author’s words from the Overview

Program: agentic_breadth_installation Program question: can DESIGNED synthetic curricula install universal, transferable agentic skills into the one 4B — provably, on fully documented lineage? Prior anchors: lifecycle 27 (qwen35_4b_count_dont_walk_enumeration — built the count_walk parent, tree d5fdc55c…; its replay control replay_ctl7 is the direct precedent: a pure replay stream onto the stage-6 composite beat the parent on 4 of 5 sealed draws, mean +0.018), lifecycle 28 (qwen35_4b_count_walk_menders_confirmation — AMBIGUOUS on menders, contrast closed; count_walk topped the aggregate on 2 of 4 seeds, mean 0.3634 over the four), and lifecycle 22 (qwen35_4b_zero_root_lineage_rebuild — the contamination-free six-stage chain this cell extends). … Read the full result →

Overview

Lifecycle 29 — stage 8 of the documented zero-root chain: REPLAY COMPOUNDING onto the count_walk composite. ONE fresh rank-32/alpha-64 adapter trains on the FULL 2,240-row replay pool (data/sft_blend.jsonl, sha 25a9595f…) from the count_walk composite parent at fresh seed 86 with the chain's established replay-refresh recipe, merges through the vendored external merger, must pass a two-arm three-screen pooled_k3 retention non-drift gate, and only a locally promoted candidate may consume the ONE sealed medium seed 78168 under the frozen two-directional COMPOUNDED / BOUNDED consequence.

Research Program

  • Program: agentic_breadth_installation
  • Program question: can DESIGNED synthetic curricula install universal, transferable agentic skills into the one 4B — provably, on fully documented lineage?
  • Prior anchors: lifecycle 27 (qwen35_4b_count_dont_walk_enumeration — built the count_walk parent, tree d5fdc55c…; its replay control replay_ctl7 is the direct precedent: a pure replay stream onto the stage-6 composite beat the parent on 4 of 5 sealed draws, mean +0.018), lifecycle 28 (qwen35_4b_count_walk_menders_confirmation — AMBIGUOUS on menders, contrast closed; count_walk topped the aggregate on 2 of 4 seeds, mean 0.3634 over the four), and lifecycle 22 (qwen35_4b_zero_root_lineage_rebuild — the contamination-free six-stage chain this cell extends).

Question

Does replay compounding still add aggregate at stage 8 — a fresh adapter over the full replay pool trained ON the count_walk composite and merged back — or does the replay-compounding law hit diminishing returns on this parent? Frozen two-state consequence; the modal BOUNDED path (aggregate up but one family dipped by more than an episode) is a finding about the law's boundary, not a failure.

Hypothesis

The chain added aggregate at every documented stage, and the stage-7 replay control proved the exact move class (replay pool onto a composite) adds ~+0.02 mean aggregate. If the pool's value is not yet exhausted at a 0.357-mean parent, the candidate lands COMPOUNDED and becomes the program reference artifact feeding the raised-floor confirmation. Honest priors (preregistration): P(aggregate strictly > parent) ≈ 0.5-0.6, but the strict no-family-below-by->0.1 clause historically binds on ~4 of 5 draws, so P(COMPOUNDED) ≈ 0.25-0.40 and BOUNDED is the believed-likelier verdict.

Setup

  • Model: Qwen/Qwen3.5-4B (revision 851bf6e8…), always.
  • Treatment: replay_compound — fresh r32/a64 QLoRA on data/sft_blend.jsonl (2,240 rows, sha-pinned, zero skips enforced) via --model-path on the count_walk composite; epochs 1, lr 1e-5, bs 1, ga 8, maxlen 4096, w_think 0.2, w_close 0.2, seed 86, 280 optimizer steps (scripts/train_trial.py, fail-closed).
  • Parent: large_artifacts/qwen35_4b_count_dont_walk_enumeration/merged/count_walk (tree d5fdc55c…, weights ddd7bc4b…), authenticated fail-closed pre-training and pre-merge against the IN-CELL sha-pinned provenance copy of lifecycle 27's merge receipt (840edca0…, data/provenance/count_walk_merge.json; the committed sibling original is a verification aid — byte-identical when present, skipped with a recorded note when absent) plus the full 9 GB weights hash at BOTH stage boundaries (train_trial.py and merge_trained_arm.py).
  • Merge: scripts/merge_trained_arm.py → scripts/merge_adapter.py (cb9af8b4…) --base-model count_walk → large_artifacts/qwen35_4b_count_walk_replay_compound/merged/replay_compound.
  • Local gate: retention-only (no axis kind exists), TWO arms (parent vs candidate), three pooled_k3 screens at fresh seeds 88060/88061/88062 (104 rows each, 8 per each of 13 skills), TWO-SIDED bands on integer screen sums: correct ±15, parsed ±9, cap contacts ±9. All three must hold to promote. Freshness audit against sha-pinned in-cell copies of the two reference cells' eight gate files (data/predecessor_gates/, seeds 88052-88059). Write-ahead local ledger (runs/local/local_events.jsonl): every engine event opens before launch and sha-pins its raw artifacts after validation; a torn or discarded attempt refuses any new local pass.
  • Sealed event: medium, tb 1024, fresh seed 78168, three arms in frozen order base → count_walk → replay_compound through the trusted gateway (53cf6533…); three TODO-pin slots for the candidate (tree/weights/committed merge receipt) fail closed while unfilled; run_benchmark.py frozen by check_design.py's three-slot NORMALIZED hash (11a6cc14…), with train_trial.py (97c06297…) and eval_local_vllm.py (1b294792…) pinned symmetrically on their own fill slots; one-seed write-ahead ledger with byte-equal crash reconciliation.
  • FROZEN CONSEQUENCE (no third state): COMPOUNDED iff candidate aggregate strictly > parent AND no family below parent by more than 0.1 (candidate_family >= parent_family - 0.1 - 1e-9; every family independently gets at most one episode of slack — the rule caps depth per family, not the number of families using slack) AND candidate aggregate strictly > base; aggregate comparisons carry a 1e-12 tie guard on the gateway-reported floats (a true rational tie rendered one ulp apart resolves BOUNDED) — claim: "replay compounding holds at stage 8; the composite becomes the program reference artifact and feeds the raised-floor confirmation." BOUNDED otherwise — claim: "the replay-compounding law hits diminishing returns at stage 8 on this parent; the count_walk composite remains the reference; further aggregate pushes need a different move class." Goal gate vs base (10/10 strict wins) recorded descriptively for both treated arms.
  • Hidden-label boundary: only scripts/run_benchmark_aggregate.py runs; benchmarks/ contents are never parsed or read as data (audited by check_design.py --check and a unit test).

Run

Smoke (fast, no GPU; verifies every pin, the lineage package, the gate design, and runs the unit tests):

PYTHONDONTWRITEBYTECODE=1 .venv/bin/python -B experiments/qwen35_4b_count_walk_replay_compound/scripts/run.py --smoke

Staged (each requires clean pushed green main plus its committed review verdict; receipts committed between stages):

# needs reports/compute_review.md with PASS_CONTROL_TRAINING (~45min GPU)
.venv/bin/python -B experiments/qwen35_4b_count_walk_replay_compound/scripts/run.py --stage train
# needs reports/local_design_review.md with PASS_CONTROL_MERGE (~10min)
.venv/bin/python -B experiments/qwen35_4b_count_walk_replay_compound/scripts/run.py --stage merge
# fill the three TODO pins from the committed merge receipt, commit, then:
# needs reports/local_design_review.md with PASS_LOCAL_EVENT (~30min GPU)
.venv/bin/python -B experiments/qwen35_4b_count_walk_replay_compound/scripts/run.py --stage local
# needs reports/benchmark_design_review.md with PASS_BENCHMARK_EVENT + promotion (~10min GPU)
.venv/bin/python -B experiments/qwen35_4b_count_walk_replay_compound/scripts/run.py --stage benchmark

Standalone lineage verification (also inside smoke):

.venv/bin/python -B experiments/qwen35_4b_count_walk_replay_compound/scripts/rebuild_lineage.py --verify-inputs
# full GPU rebuild of stages 1-8 (~4h):
.venv/bin/python -B experiments/qwen35_4b_count_walk_replay_compound/scripts/rebuild_lineage.py

Ops note (torn ledger / partial receipts): never edit receipts by hand; audit the preserved artifacts, then --stage benchmark --resume — the summary regenerates deterministically and must reconcile byte-identically before the ledger closes.

Results

Pending: the GPU stages have not run. The terminal artifact will be runs/benchmark/medium_tb1024_seed78168_compound/summary.json carrying the frozen COMPOUNDED / BOUNDED consequence.

Interpretation

Design-frozen. COMPOUNDED promotes the composite to program reference artifact and funds the raised-floor confirmation cell; BOUNDED closes the replay-compounding move class at stage 8 on this parent and redirects aggregate pushes to a different move class. Either way the chain's stage-8 boundary becomes a measured fact instead of an assumption.

Knowledgebase Update

  • Program evidence updated: pending the sealed event.
  • Program backlog updated: pending.
  • Claim ledger updated: pending.

Artifacts

  • scripts/ — fail-closed staged harness (run.py), trainer wrapper (train_trial.py), merge wrapper (merge_trained_arm.py), gate design/generator (gen_local_gate.py), gate rule (check_local.py), evaluator (eval_local_vllm.py), sealed-event runner (run_benchmark.py), design checker with the three-slot normalized pin (check_design.py), lineage rebuilder (rebuild_lineage.py), vendored production copies (train_think.py, merge_adapter.py, lineage_trainers/, stage7_wrappers/, rebuild_clean_chain.py, gen_curriculum.py).
  • data/ — the standalone lineage package (lineage/), stage-7 production inputs, the stage-8 training pool (sft_blend.jsonl), the parent provenance copy (provenance/count_walk_merge.json), the two reference cells' eight sha-pinned gate-file copies (predecessor_gates/), and the frozen local gate (local_design_receipt.json, local_tasks_seed8806*.jsonl, local_input_seed8806*.jsonl).
  • reports/preregistration.md — the frozen contract with honest priors.
  • reports/artifact_manifest.yaml — external artifacts and reproduction paths.
  • tests/ — 176 unit tests (consequence truth table + lattice sweeps + the 1e-12 aggregate tie guard over the demonstrated 1-ulp rational-tie pairs, two-sided retention bands, benchmark ledger open/close/reconcile/ double-consume, local write-ahead ledger open/refuse/complete, arm authentication tamper drills, sibling-original absent/divergent drills, normalized-pin probes for all three fill-slot files, stage-prerequisite one-line refusal drills, lineage package integrity, cross-module frozen constants, vLLM runner contract).

Report

Rendered from reports/report.md

Lifecycle 29. Model-free construction is complete and frozen; no GPU stage has run and no seed has been consumed. This report records the frozen design; the results section fills only after the sealed event.

What this cell asks

Stage 8 of the documented zero-root chain: does REPLAY COMPOUNDING — one fresh rank-32/alpha-64 adapter trained on the FULL 2,240-row replay pool (data/sft_blend.jsonl, sha 25a9595f…) ON the count_walk composite parent (tree d5fdc55c…) at fresh seed 86, merged back onto that composite — still add held-out aggregate, or does the replay-compounding law hit diminishing returns on this parent?

The frozen design

  • Treatment. The chain's established replay-refresh recipe, unchanged: epochs 1.0, lr 1e-5, rank 32/alpha 64, batch 1, grad-accum 8, max-length 4,096, w_think 0.2, w_close 0.2, via the vendored stage-7 trainer (train_think.py, sha e0eca2a2…) with --model-path on the composite; 280 optimizer steps; zero row skips enforced (pool max forward 3,193 < 4,096). Fresh training seed 86 (grep-fresh; chain seeds 42/43/44/47/51/55/85 are taken).
  • Fail-closed authentication. The parent authenticates pre-training and pre-merge against the committed lifecycle-27 merge receipt (sha 840edca0…, byte-identical in-cell copy) plus tokenizer/size pins and the full 9 GB weights hash; the benchmark runner recomputes the full on-disk tree sha256 of every arm at the seed-consuming boundary.
  • Local gate. Retention-only, TWO arms (parent vs candidate; no axis kind exists for a pool treatment): three pooled_k3 screens at fresh seeds 88060/88061/88062, 104 rows each; TWO-SIDED bands on integer screen sums (correct ±15, parsed ±9, cap contacts ±9). Promotion only if all three hold; the aggregate question belongs exclusively to the sealed event.
  • Sealed event. Medium / tb1024 / fresh seed 78168, three arms in frozen order (base → count_walk → replay_compound) through the trusted gateway (53cf6533…). Three TODO-pin slots (candidate tree / weights / committed merge receipt) fail closed while unfilled; run_benchmark.py is frozen by a three-slot NORMALIZED hash (d619d5df…) so every guard call site is byte-frozen pre- and post-fill. One-seed write-ahead ledger; byte-equal crash reconciliation (the summary is a pure function of the receipts).
  • Frozen consequence (no third state). COMPOUNDED iff candidate aggregate strictly > parent AND no family strictly below parent by more than 0.1 (candidate_family >= parent_family - 0.1 - 1e-9, exact at both lattice boundaries) AND candidate aggregate strictly > base. BOUNDED otherwise. The frozen claims and the goal-gate-vs-base descriptive reading are in the preregistration.

Honest priors (frozen before the event)

The stage-7 replay control is the exact move-class precedent: it beat its parent on 4 of 5 sealed draws (mean +0.018). But the per-family slack clause historically binds: dips beyond one episode appeared on ~4 of 5 candidate-vs-parent draws across the chain's sealed history. Frozen priors: P(aggregate strictly > parent) ≈ 0.5-0.6; P(COMPOUNDED) ≈ 0.25-0.40; BOUNDED is the believed-likelier verdict and is a finding about the law's boundary (the modal path: aggregate up, one family down by two episodes), not a failure.

Verification state at freeze

  • run.py --smoke green: check_design (normalized pin, gateway sha, frozen corpora, no-benchmark-reads audit), rebuild_lineage.py --verify-inputs (extended manifest 45d1a0d9…; 7 stage datasets + 2 arm streams + the stage-8 pool + 7 provenance receipts + trainers/merger/wrappers), gen_local_gate.py --check (instruments + freshness + code pins), and all 127 unit tests.
  • Boundary drills refuse: every staged gate without its committed review verdict; the sealed runner with unfilled TODO pins; a tampered parent merge receipt in a scratch copy; fake/incomplete composite trees; NaN gateway scores; ledger double-consume.

Results

Pending the staged reviews and GPU stages. Terminal artifact: runs/benchmark/medium_tb1024_seed78168_compound/summary.json with the frozen verdict, claims, per-family tables, and the descriptive goal gate.

Interpretation

Pending. Both branches are priced in the preregistration: COMPOUNDED promotes the composite to program reference artifact and feeds the raised-floor confirmation; BOUNDED closes the replay-compounding move class at stage 8 on this parent and redirects further aggregate pushes to a different move class.

Experiment log 3

Show the running log (3 entries, 2026-07-17)

2026-07-17 — design freeze (lifecycle 29; model-free, no seed consumed)

Stage 8 of the documented zero-root chain: REPLAY COMPOUNDING onto the count_walk composite. Everything below is model-free construction; no GPU stage has run, no review has been sought yet, and the sealed seed 78,168 is unconsumed.

  • Treatment frozen. One fresh rank-32/alpha-64 adapter (replay_compound) on the FULL 2,240-row replay pool (data/sft_blend.jsonl, sha 25a9595f…, byte-identical lifecycle-27 copy; max forward 3,193 tokens, zero skips enforced) from the count_walk composite parent via --model-path, with the chain's established replay-refresh recipe (epochs 1, lr 1e-5, bs 1, ga 8, maxlen 4096, w_think 0.2, w_close 0.2 — identical to stages 1/4 and the stage-7 arms) at the fixed FRESH training seed 86. Seed audit: 42/43/44/47/51/55/85 are the chain's taken training seeds; 86 verified grep-fresh in training-seed contexts repo-wide; no substitution required.
  • Parent authentication frozen. Fail-closed pre-training and pre-merge: committed lifecycle-27 merge receipt (sha 840edca0…), byte-identical in-cell provenance copy (data/provenance/count_walk_merge.json), inner receipt / tokenizer / size pins, then the full 9 GB weights hash (ddd7bc4b…). Cloned from the reference cell's train_trial.py / merge_trained_arm.py pattern, adapted to this parent.
  • Local gate frozen and generated. Retention-only (no axis kind exists for a pool treatment), TWO arms (count_walk parent first, then the candidate), three pooled_k3 screens at fresh seeds 88060/88061/88062 (104 rows each, 8 per each of 13 skills, canonical gen_curriculum.py). Seed audit: everything <= 88059 known-taken (reference cell holds 88056-88059); 88060/88061/88062 verified grep-fresh; no substitution. TWO-SIDED bands on integer screen sums: correct ±15, parsed ±9, cap contacts ±9 (means ±5/±3/±3). Design receipt + task files + runner inputs generated model-free and pinned (gen_local_gate.py --check green); freshness audit: zero canonical-user-message overlap with every in-cell corpus (including the training pool), the reference cell's four frozen gate files, and regenerated prior local seeds 88000-88059.
  • Sealed event frozen. Medium / tb1024 / fresh seed 78168 (benchmark seeds spent through 78,167; grep-fresh; no substitution), three arms in frozen order base → count_walk → replay_compound through the trusted gateway (53cf6533…). The candidate's tree/weights/committed-receipt pins are three fail-closed TODO slots; run_benchmark.py is frozen by check_design.py's three-slot NORMALIZED hash (d619d5df…) — every byte outside the slots, every guard call site included, is byte-frozen pre- and post-fill. One-seed write-ahead ledger; byte-equal crash reconciliation (the summary payload is a pure function of the receipts; a preserved summary must reconcile byte-identically before the ledger closes).
  • Consequence frozen (two-directional, no third state). COMPOUNDED iff candidate aggregate strictly > parent AND no family strictly below the parent by more than 0.1 (candidate_family >= parent_family - 0.1 - 1e-9; exactly 0.1 below passes, 0.10000001 fails; unit-tested over the full k/10 and k/60 lattices) AND candidate aggregate strictly > base. BOUNDED otherwise. Frozen claims in the preregistration. Goal gate vs base (10/10 strict wins) recorded descriptively for both treated arms.
  • Honest priors frozen. The stage-7 replay control is the exact move-class precedent (beat its parent 4/5 sealed draws, mean +0.018), but the family-slack clause historically binds (~4/5 draws show a dip beyond one episode): P(aggregate > parent) ≈ 0.5-0.6, P(COMPOUNDED) ≈ 0.25-0.40; BOUNDED is the believed-likelier verdict and is a finding about the law's boundary, not a failure. Menders is NOT re-litigated (lifecycle 28 closed that contrast); it appears only descriptively.
  • Standalone package extended. Copied byte-identically: the full data/lineage/ package (six stage datasets + seven provenance receipts), the stage-7 production inputs, lineage_trainers/ ×3, train_think.py, merge_adapter.py, rebuild_clean_chain.py, and lifecycle 27's wrappers into scripts/stage7_wrappers/ (shas a83240a0… / b566c486… unchanged). The manifest was extended with the stage8_replay_compound block (arm, pool sha, seed 86, trainer/merger shas, parent pins, recipe, three null post-merge TODO slots) and the stage-7 block's wrapper paths re-pointed; new byte pin 45d1a0d9…. rebuild_lineage.py now replays stages 1-8; --verify-inputs green.
  • Verification at freeze. run.py --smoke green end-to-end (check_design --check, rebuild_lineage --verify-inputs, gen_local_gate --check, 127 unit tests). Boundary drills refuse: every staged gate without its committed review verdict, the sealed runner with unfilled TODO pins, a tampered parent merge receipt in a scratch copy, fake and incomplete composite trees, NaN gateway scores, and ledger double-consume.

Next: commit + push, seek the adversarial compute review (PASS_CONTROL_TRAINING) for --stage train.

2026-07-17 — review-driven design hardenings (pre-freeze; still model-free, no seed consumed)

Construction review surfaced two majors and six minors against the still-uncommitted cell; all applied before the first commit. Frozen task and corpus content is UNCHANGED (all six gate task/input files regenerated byte-identically: sources 836c971b…/4149e399…/ 7a143b41…, runner inputs 122c631e…/e2b6acb4…/26b3761a…); only code, receipts, and docs moved.

  • MAJOR 1 — aggregate tie guard. The strict aggregate comparisons in run_benchmark.consequence_reading were unguarded against ulp-level rendering of TRUE rational ties: distinct per-family multisets with exactly equal rational aggregates float-render 1 ulp apart (demonstrated: parent [1.0,0.1,0.6,0.8,0.1,0.0,0.1,1.0,0.8,0.1] vs candidate [0.9,0.2,0.6,0.8,0.1,0.0,0.1,1.0,0.8,0.1], both exactly 0.46, rendering 0.45999999999999996 vs 0.46000000000000008), flipping BOUNDED to COMPOUNDED. Python 3.12 sum() is Neumaier-compensated (order is not the mechanism) and math.fsum does not fix it; the fix is the explicit AGG_TIE_EPSILON = 1e-12: strictly-above means (candidate - other) > 1e-12, |delta| <= 1e-12 is a tie and ties are BOUNDED. Real aggregate differences are >= ~1.7e-3. Truth-table unit tests added over both demonstrated 1-ulp flip orderings (both must read BOUNDED) and a genuine +0.002 win (stays COMPOUNDED); the frozen-semantics sentence added to the preregistration.
  • MAJOR 2 — standalone reproduction path (owner's standalone directive: cross-experiment files are verification aids, NEVER the reproduction path). Every sibling-original requirement became: the IN-CELL sha256 pin is the hard fail-closed gate; a PRESENT sibling must be byte-identical (divergence fails loudly as tamper evidence); an ABSENT sibling is skipped with a recorded note ("absent, in-cell pin authoritative"). Applied to rebuild_lineage.py (verify_provenance_receipts), gen_local_gate.py (parent receipt + predecessor gates), train_trial.py (check_parent_provenance, note recorded in the training receipt), eval_local_vllm.py (inherited-arm receipt now the in-cell copy), and run_benchmark.py (require_count_walk_parent_provenance; the sibling is HEAD-checked only when present). The four predecessor gate files gained sha-pinned in-cell copies under data/predecessor_gates/ so the overlap audit runs identically without siblings. Drills: a sibling-free checkout passes rebuild_lineage.py --verify-inputs AND gen_local_gate.py --check (verified live by temporarily relocating the three sibling cells); divergent-present still fails (unit drills).
  • Minors. (1) Slack-gloss wording corrected everywhere: every family independently gets at most one episode (0.1) of slack below the parent — the rule caps depth per family, not the number of families using slack. (2) Local write-ahead ledger (runs/local/local_events.jsonl): an opened record (arm, seed, seed list, design-receipt sha, monotonic index) appended BEFORE every engine event, a receipts record sha-pinning the raw artifacts after validation; a torn/discarded attempt refuses any new local pass; open/refuse/complete unit-tested. (3) merge_trained_arm.py preflight now hashes the full 9 GB merge-base weights against ddd7bc4b… (mirroring train_trial.py); README now matches reality. (4) Overlap audit extended with the enumerative-repair cell's four gate files (seeds 88052-88055), same load pattern, in-cell copies; local design receipt regenerated (bd6a8f47…). (5) run.py require_pushed_checkpoint catches the git cat-file probe and refuses one-line (stage prerequisite is not committed at HEAD: <path>); the three stage drills re-run green (one-line refusals, no tracebacks). (6) Pin symmetry: check_design.py now normalized-hash-pins ALL three fill-slot files — run_benchmark.py (three slots, re-frozen 11a6cc14… after the tie guard), train_trial.py (PUBLISHED_ARM_HASHES single-line sorted-key dict slot, 97c06297…), eval_local_vllm.py (EXPECTED_TRAINED_TREE_SHA256 slot, 1b294792…) — one-byte non-slot edits fail --check, legal slot fills do not (probed in tests).
  • Verification after the fixes. check_design.py --check green twice; gen_local_gate.py --check green; task files byte-identical (shas above); unit tests 127 → 176, all green; run.py --smoke green end-to-end; rebuild_lineage.py --verify-inputs green (now reporting sibling-original status); make check green from repo root.

2026-07-17 — Sealed event 78168: BOUNDED; cell closed

  • Three arms at 78168 (medium tb1024): base 0.1040, count_walk parent 0.3626, replay_compound candidate 0.3420. The candidate's aggregate fell 0.0206 BELOW the parent (aggregate_strictly_beats_parent=False, tie guard inactive — a real loss, not a tie) AND warren dipped 0.15 below parent (families_below_slack=[warren]). Either condition alone fires BOUNDED; both did.
  • Frozen consequence: BOUNDED — "the replay-compounding law hits diminishing returns at stage 8 on this parent; the count_walk composite remains the reference; further aggregate pushes need a different move class." This is the first chain stage where replay compounding failed to add aggregate.
  • Descriptive (never gating): the candidate still beats base by 0.238 (goal gate vs base 8 strict wins, tie on menders, one loss on rites); per-family vs parent it is a net-negative reshuffle (lockpick +0.1, toolsmith +0.07; menders -0.1, mirage -0.1, warren -0.15, stockade -0.025). Replay on an already replay-saturated parent redistributes rather than adds.

Data files 1

Result tables and metrics copied from the experiment folder — preview inline or open the raw file.

Reproduce

Smoke test

PYTHONDONTWRITEBYTECODE=1 .venv/bin/python -B experiments/qwen35_4b_count_walk_replay_compound/scripts/run.py --smoke

Full run

.venv/bin/python -B experiments/qwen35_4b_count_walk_replay_compound/scripts/run.py --stage train|merge|local|benchmark (staged; each needs clean pushed main plus its committed review verdict)

Run steps are documented inside the experiment folder (README and scripts).

Browse the experiment folder on GitHub ↗