Research log Small Model Experimentation
GitHub

State-Track Installation (Stage 9)

Finished2026-07-17 → Agentic Breadth InstallationBenchmark GeneralizationPosttraining and AdaptationStructured Execution and CompilersGitHub ↗
Installed transfer: a new, unrelated skill lifted the aggregate where replay had stalled (single seed)

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 the current model and folds it in, and each round so far has raised the model's overall score on sealed exams. Two levers exist. The 'replay round' re-teaches the model its own accumulated review deck (nothing new) - and at the previous stage that lever finally STOPPED helping: on a model already saturated with its old notes, more review just shuffles strength between subjects. The other lever is to install a genuinely NEW skill from a freshly designed practice set. The one time the team did that (an enumeration skill) it added about three points. This round bets that a different NEW skill - keeping a running tally of several named counters as a list of update instructions is applied - still adds where replay is now stuck.

The question

On the chain's best (and replay-saturated) model, does installing one brand-new skill - track 3-6 counters through a short list of updates, then answer a final-state question - raise the sealed-exam score without any subject collapsing, where simply re-teaching the old review deck stopped helping?

What we found

The believed-unlikelier but hoped-for outcome landed. After the reliable 'just replay again' lever hit its ceiling, this tried a genuinely different lever: teach the model one new, universal skill — keeping a running tally of named counters through a list of updates — using training data that looks nothing like any benchmark. On the sealed exam the new model scored 0.326 aggregate versus the parent's 0.300 and the raw base's 0.168, and crucially no task family dropped by more than a rounding step. The gains showed up on exactly the kinds of tasks where tracking state should help (siftstack +0.2, lockpick +0.1, mirage +0.1). So the pre-registered rule reads INSTALLED_TRANSFER: a fresh transferable skill can still add where more-of-the-same replay cannot. Two honest asterisks keep this from being a victory lap: it is ONE exam seed, and the parent's own score bounces between 0.30 and 0.36 seed-to-seed, so the 0.026 gain has to survive a multi-seed confirmation (the same check that recently exposed an earlier headline as noise) before we trust it. And the ultimate goal — beat the raw base model on EVERY family — is still not met, because one family (warren) sits below base, a weakness inherited from the parent. Real signal, properly hedged; the next step is to confirm it across seeds.

Why it matters

The chain is the program's flagship: a fully documented, contamination-free recipe that turned a 0.08 base into a 0.36 model. Its cheapest lever (replay) just hit a ceiling. This one sealed exam tells the program whether the OTHER lever - installing a designed new skill - still raises the floor on a saturated parent, or whether the parent itself is tapped out and the next push needs a different parent or a bigger dose. That decision is worth one exam.

Candidate vs parent0.326 vs 0.300+0.026 aggregate, no family past slack
VerdictINSTALLED_TRANSFERfirst add since replay bounded
Gains vs parentsiftstack +0.2lockpick +0.1, mirage +0.1
Caveatsingle seedparent swings 0.30-0.36; confirm across seeds
On this page
  1. Results at a glance
  2. Overview
  3. Report
    1. What this cell asks
    2. Why this design
    3. The frozen design
    4. Honest priors (frozen before the event)
    5. Verification state at freeze
    6. Results
    7. Interpretation
  4. Experiment log
  5. Data files
  6. Reproduce
  7. Related

Results at a glance 1

A divergent skill adds where replay could not (INSTALLED_TRANSFER, single seed) The frozen two-state rule fired INSTALLED_TRANSFER: a divergent single-skill dose (state-tracking through declarative updates, 160 rows, seed 87) on the count_walk parent beat both parent (+0.0256) and base on aggregate with NO family below the one-episode slack. This is the first NEW aggregate-adding move class since replay compounding bounded at stage 8, and it validates the core doctrine — install a universal skill via a designed curriculum that looks nothing like the eval, prove by transfer. Gains land on agentic families reachable by state-tracking: siftstack +0.2, lockpick +0.1, mirage +0.1 vs parent; only sub-episode dips elsewhere. TWO HONEST CAVEATS: (1) single seed — the parent's own aggregate swings 0.30-0.36 across sealed seeds (0.3004 here vs 0.3626 at 78168) and state_track's 0.3260 sits inside that band, so the lift needs a fresh eval-only multi-seed confirmation (the same discipline that correctly killed the menders reading) before state_track is crowned the durable reference; (2) the ultimate every-family-beats-base bar is still unmet — warren 0.200 < base 0.367, a count_walk-inherited weakness.

aggregate score · arm →

00.10.20.30.4basebase0.168count_walk (parent)count_walk (parent)0.3state_track (candidate)state_track (candidate)0.326
Data table
armaggregate at sealed seed 78169
base0.168
count_walk (parent)0.3
state_track (candidate)0.326

Numbers from experiments/qwen35_4b_state_track_install/runs/benchmark/medium_tb1024_seed78169_install/summary.json

In the author’s words from the Report · “Interpretation”

Design-frozen. INSTALLED_TRANSFER promotes the composite to program reference artifact and shows the divergent-skill move class adds where replay is bounded; BOUNDED extends the install-not-equal-convert law to this skill and redirects to a different dose/parent. Either way the chain's stage-9 boundary — does a divergent skill add where replay could not — becomes a measured fact.

Overview

Lifecycle 30 — stage 9 of the documented zero-root chain: a DIVERGENT single-kind installation dose of a NEW transferable skill — STATE-TRACKING UNDER DECLARATIVE UPDATES — onto the count_walk composite. ONE fresh rank-32/alpha-64 adapter trains on a fresh 160-row single-kind state-tracking curriculum (data/sft_state_track.jsonl, sha 66a8d5be…) from the count_walk composite parent at fresh seed 87 with the chain's frozen QLoRA 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 78169 under the frozen two-directional INSTALLED_TRANSFER / BOUNDED consequence.

HONEST SCOPE: single seed (the parent itself swings 0.30-0.36 across sealed draws) and the /goal bar is unmet (warren 0.200 < base 0.367); the six-seed successor qwen35_4b_state_track_confirmation replicated it only DIRECTIONALLY (+0.0207, p ≈ 0.16), and the edge did NOT transfer to the real coding harness. No claim-ledger entry was ever filed for this cell, and the "Pending" Results/Interpretation sections below are stale — see experiment_log.md and runs/benchmark/medium_tb1024_seed78169_install/summary.json.

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 enumeration-SKILL dose beat the stage-6 parent by +0.032 mean aggregate — the divergent-skill precedent this cell repeats), lifecycle 29 (qwen35_4b_count_walk_replay_compound — replay compounding BOUNDED at stage 8: on a replay-saturated parent, another replay dose redistributes rather than adds), and lifecycle 22 (qwen35_4b_zero_root_lineage_rebuild — the contamination-free six-stage chain this cell extends).

Question

Does a DIVERGENT transferable skill (state-tracking execution) add held-out aggregate on the replay-saturated count_walk parent, where another dose of replay just BOUNDED? Frozen two-state consequence; the modal BOUNDED path (the skill installs locally but does not convert to held-out aggregate at this dose) is a finding about the install-not-equal-convert boundary, not a failure.

Hypothesis

Replay is bounded on this parent, but a NON-OVERLAPPING skill can still add: the chain's only prior divergent-skill dose (count_walk) beat its parent on 4 of 5 sealed draws (mean +0.032). If a 160-row single-kind state-tracking curriculum installs a transferable execution skill that lifts held-out families, the candidate lands INSTALLED_TRANSFER and becomes the program reference artifact. Honest priors (preregistration): P(aggregate strictly > parent) ≈ 0.4-0.5, but the strict no-family-below-by->0.1 clause historically binds, so P(INSTALLED_TRANSFER) ≈ 0.30-0.40 and BOUNDED is the modestly likelier verdict.

Setup

  • Model: Qwen/Qwen3.5-4B (revision 851bf6e8…), always.
  • Treatment: state_track — fresh r32/a64 QLoRA on data/sft_state_track.jsonl (160 rows, single kind u_state_track, sha-pinned, zero skips enforced, max forward 775 tokens) 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 87, 20 optimizer steps (scripts/train_trial.py, fail-closed). The ONLY designed delta is the curriculum.
  • The curriculum: scripts/gen_state_track_curriculum.py (seed 87) — each row tracks 3-6 invented named registers through K∈{4..8} declarative updates across four surfaces (plain / terse / X += 3 / narrated), then answers a final-state query. EXECUTION of given updates (execute-vs-induce law). Truth-audited by independent re-derivation (byte-matched) + answer recomputation; banned-vocabulary audit vs the ten benchmark families and the reference inventory; ZERO canonical-user-message overlap with the replay pool, the eleven predecessor gate files, and the retention screens (unit-tested).
  • 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) plus the full 9 GB weights hash at BOTH stage boundaries.
  • Merge: scripts/merge_trained_arm.py → scripts/merge_adapter.py (cb9af8b4…) --base-model count_walk → large_artifacts/qwen35_4b_state_track_install/merged/state_track.
  • Local gate: retention-only, TWO arms (parent vs candidate; the new kind is deliberately NOT held out locally — transfer is priced by the sealed event), three pooled_k3 screens at fresh seeds 88063/88064/88065 (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 three reference cells' eleven gate files (data/predecessor_gates/, seeds 88052-88062). Write-ahead local ledger.
  • Sealed event: medium, tb 1024, fresh seed 78169, three arms in frozen order base → count_walk → state_track 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 (8e2d5420…), with train_trial.py (9396cff7…) and eval_local_vllm.py (8350c61a…) pinned symmetrically; one-seed write-ahead ledger with byte-equal crash reconciliation.
  • FROZEN CONSEQUENCE (no third state): INSTALLED_TRANSFER iff candidate aggregate strictly > parent AND no family below parent by more than 0.1 (candidate_family >= parent_family - 0.1 - 1e-9) AND candidate aggregate strictly > base; aggregate comparisons carry a 1e-12 tie guard — claim: "a divergent transferable skill installs and adds aggregate on the replay-saturated parent; state_track becomes the program reference; the divergent-skill move class is not bounded where replay is." BOUNDED otherwise — claim: "the divergent-skill dose does not add aggregate at this dose on this parent; count_walk remains the reference; the install-not-equal-convert law extends to this skill." Goal gate vs base recorded descriptively.
  • Hidden-label boundary: only scripts/run_benchmark_aggregate.py runs; benchmarks/ contents are never parsed or read as data.

Run

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

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

Regenerate the frozen curriculum (byte-identical; seed 87):

.venv/bin/python -B experiments/qwen35_4b_state_track_install/scripts/gen_state_track_curriculum.py --seed 87 --rows 160

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 (~5min GPU)
.venv/bin/python -B experiments/qwen35_4b_state_track_install/scripts/run.py --stage train
# needs reports/local_design_review.md with PASS_CONTROL_MERGE (~10min)
.venv/bin/python -B experiments/qwen35_4b_state_track_install/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_state_track_install/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_state_track_install/scripts/run.py --stage benchmark

Standalone lineage verification (also inside smoke):

.venv/bin/python -B experiments/qwen35_4b_state_track_install/scripts/rebuild_lineage.py --verify-inputs
# full GPU rebuild of stages 1-9 (~4h):
.venv/bin/python -B experiments/qwen35_4b_state_track_install/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_seed78169_install/summary.json carrying the frozen INSTALLED_TRANSFER / BOUNDED consequence.

Interpretation

Design-frozen. INSTALLED_TRANSFER promotes the composite to program reference artifact and shows the divergent-skill move class adds where replay is bounded; BOUNDED extends the install-not-equal-convert law to this skill and redirects to a different dose or parent. Either way the chain's stage-9 boundary becomes a measured fact.

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), the designed curriculum generator (gen_state_track_curriculum.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 frozen state_track curriculum (sft_state_track.jsonl) and its token-exposure receipt (state_track_token_receipt.json), the standalone lineage package (lineage/), stage-7/8 production inputs, the parent provenance copy (provenance/count_walk_merge.json), the three reference cells' eleven 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/ — 197 unit tests (curriculum generator truth audit + contamination/overlap drills, consequence truth table + lattice sweeps + the 1e-12 aggregate tie guard, two-sided retention bands, benchmark ledger open/close/reconcile/double-consume, local write-ahead ledger, arm authentication tamper drills, sibling-original absent/divergent drills, normalized-pin probes for all three fill-slot files, stage-prerequisite refusal drills, lineage package integrity over stages 1-9, cross-module frozen constants, vLLM runner contract).

Report

Rendered from reports/report.md

Lifecycle 30. 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 9 of the documented zero-root chain: does a DIVERGENT transferable SKILL — one fresh rank-32/alpha-64 adapter trained on a fresh 160-row single-kind STATE-TRACKING curriculum (data/sft_state_track.jsonl, sha 66a8d5be…) ON the count_walk composite parent (tree d5fdc55c…) at fresh seed 87, merged back onto that composite — add held-out aggregate on the replay-saturated parent, where another dose of replay just BOUNDED at stage 8?

Why this design

Replay compounding BOUNDED at stage 8: on a replay-saturated parent it redistributes rather than adds. But count_walk — a fresh enumeration-SKILL dose — beat its own parent by +0.032 mean aggregate, so a NON-OVERLAPPING skill can add where replay cannot. state_track is a divergent transferable skill chosen to share no structure with any chain curriculum: it installs state-tracking EXECUTION (execute-vs-induce law: execution is installable).

The frozen design

  • Treatment. The chain's frozen QLoRA 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 trainer (train_think.py, sha e0eca2a2…) with --model-path on the composite; 20 optimizer steps; zero row skips enforced (corpus max forward 775 < 4,096, measured in-cell). Fresh training seed 87 (also the curriculum construction seed; grep-fresh; chain seeds 42/43/44/47/51/55/85/86 are taken). The ONLY designed delta is the curriculum.
  • The curriculum. scripts/gen_state_track_curriculum.py, seed 87: 160 rows, single kind u_state_track at full concentration. Each row tracks 3-6 invented named registers through K in {4..8} declarative updates across four surfaces (plain / terse / X += 3 / narrated), then answers a final-state query. Truth-audited by independent re-derivation (byte-matched) and answer recomputation; banned-vocabulary audit vs the ten families and the reference inventory; ZERO canonical-user-message overlap with the replay pool, the eleven predecessor gate files, and the retention screens (unit-tested). Balanced across surfaces / query types / chain lengths / register counts; think tokens mean 168, max 265.
  • 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; the new kind is deliberately NOT held out locally — transfer is priced by the sealed event): three pooled_k3 screens at fresh seeds 88063/88064/88065, 104 rows each; TWO-SIDED bands on integer screen sums (correct ±15, parsed ±9, cap contacts ±9). Promotion only if all three hold.
  • Sealed event. Medium / tb1024 / fresh seed 78169, three arms in frozen order (base → count_walk → state_track) 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 (8e2d5420…) so every guard call site is byte-frozen pre- and post-fill. One-seed write-ahead ledger; byte-equal crash reconciliation.
  • Frozen consequence (no third state). INSTALLED_TRANSFER 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 only prior divergent-skill dose (count_walk) beat its parent on 4 of 5 sealed draws (mean +0.032) — the reason this move is believed. But the parent is now the chain's best (0.357-mean), the dose is a narrow single kind at 20 steps, and the per-family slack clause historically binds (~4/5 draws). Frozen priors: P(aggregate strictly > parent) ≈ 0.4-0.5; P(INSTALLED_TRANSFER) ≈ 0.30-0.40; BOUNDED is the modestly likelier verdict and is a finding about the install-not-equal-convert boundary (the skill installs locally but may not convert to held-out aggregate at this dose), not a failure.

Verification state at freeze

  • run.py --smoke green: check_design (three normalized pins, gateway sha, five frozen corpora incl. the state_track curriculum, no-benchmark-reads audit), rebuild_lineage.py --verify-inputs (extended manifest c05b0eb6…; 7 stage datasets + 2 arm streams + the stage-8 pool + the stage-9 curriculum + 7 provenance receipts + trainers/merger/wrappers), gen_local_gate.py --check (instruments + freshness over eleven predecessor gates + code pins), and all 197 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; a corrupted ledger re-derivation, a banned token, and a mutated kind in the curriculum generator.

Results

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

Interpretation

Design-frozen. INSTALLED_TRANSFER promotes the composite to program reference artifact and shows the divergent-skill move class adds where replay is bounded; BOUNDED extends the install-not-equal-convert law to this skill and redirects to a different dose/parent. Either way the chain's stage-9 boundary — does a divergent skill add where replay could not — becomes a measured fact.

Experiment log 2

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

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

Stage 9 of the documented zero-root chain: a DIVERGENT single-kind installation dose of a NEW transferable skill — STATE-TRACKING UNDER DECLARATIVE UPDATES — 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,169 is unconsumed.

  • Why this design. Replay compounding BOUNDED at stage 8 (lifecycle 29): on a replay-saturated parent, another replay dose redistributes rather than adds. But count_walk (a fresh enumeration-SKILL dose) beat its zero-root parent by +0.032 mean aggregate, so a NON-OVERLAPPING transferable skill can add where replay cannot. This cell tests that with a divergent skill (state-tracking execution) sharing no structure with any chain curriculum. Machinery cloned byte-identically from the just-finished lifecycle-29 cell (qwen35_4b_count_walk_replay_compound); adapted names count_walk→state_track, seeds, and — the one designed delta — the curriculum generator.
  • The curriculum (the designed delta). New generator scripts/gen_state_track_curriculum.py, construction seed 87: 160 rows, single kind u_state_track at full concentration (dilution law). Each row tracks 3-6 neutral invented named registers through K∈{4..8} declarative updates (increase / decrease / set / set-to-scaled / set-to-sum / move / double) across four surfaces (plain / terse / X += 3 / narrated), then answers a final-state query (value / largest / smallest / pairwise-larger). Think target shows the ledger line-by-line then the answer — EXECUTION of given updates (execute-vs-induce law). Fail-closed truth audit: every ledger re-derived by a SECOND independent interpreter and byte-compared; every answer recomputed from that independent state; constant-KIND asserted; banned-vocabulary audit rejects any collision with the ten benchmark families (+ obvious surface words) or the reference universal-curriculum / machine-formalism inventory. Corpus sha 66a8d5bec184a8a9cba20c2ea088e0216ac4cdbd0820541ee310170eb386e3ab; balanced 40/40/40/40 across query types and surfaces, 32 per chain length, 40 per register count; estimated think tokens mean 168 / max 265. Token exposure measured in-cell (data/state_track_token_receipt.json, composite tokenizer): forward 83,919/epoch, nonzero target 58,478, max forward 775 < 4,096 → zero skips guaranteed and enforced.
  • Contamination clean. Banned-vocab audit passes (register names and content collide with nothing in the inventory). ZERO canonical-user-message overlap (unit-tested) with data/sft_blend.jsonl (the replay pool), the eleven predecessor gate files (seeds 88052-88062), and the fresh retention screens.
  • Treatment frozen. One fresh rank-32/alpha-64 adapter (state_track) on the 160-row curriculum from the count_walk composite parent via --model-path, with the chain's frozen QLoRA recipe (epochs 1, lr 1e-5, bs 1, ga 8, maxlen 4096, w_think 0.2, w_close 0.2) at the fixed FRESH training seed 87 (also the curriculum construction seed; grep-fresh; chain seeds 42/43/44/47/51/55/85/86 taken). 20 optimizer steps.
  • Parent authentication frozen. Fail-closed pre-training and pre-merge: committed lifecycle-27 merge receipt (840edca0…), byte-identical in-cell provenance copy, inner receipt / tokenizer / size pins, then the full 9 GB weights hash (ddd7bc4b…).
  • Local gate frozen and generated. Retention-only, TWO arms (parent first, then candidate); the new kind is deliberately NOT held out locally — transfer is priced by the sealed event (install-by-transfer doctrine). Three pooled_k3 screens at fresh seeds 88063/88064/88065 (104 rows each, 8 per each of 13 skills, canonical gen_curriculum.py). Seed audit: everything <= 88062 known-taken (the replay-compound cell holds 88060-88062); 88063/88064/88065 verified grep-fresh; no substitution. TWO-SIDED bands on integer screen sums: correct ±15, parsed ±9, cap contacts ±9. Design receipt + task/input files generated model-free and pinned (gen_local_gate.py --check green, receipt sha 48c98bae…); freshness audit clean over eleven predecessor gates and prior local seeds 88000-88062.
  • Sealed event frozen. Medium / tb1024 / fresh seed 78169 (benchmark seeds spent through 78,168 — the replay-compound cell's seed; grep-fresh; no substitution), three arms in frozen order base → count_walk → state_track through the trusted gateway (53cf6533…). The candidate's tree/weights/committed-receipt pins are three fail-closed TODO slots (None); run_benchmark.py is frozen by check_design.py's three-slot NORMALIZED hash (8e2d5420…) — every byte outside the slots, every guard call site included, byte-frozen pre- and post-fill. train_trial.py (9396cff7…) and eval_local_vllm.py (8350c61a…) pinned symmetrically. One-seed write-ahead ledger; byte-equal crash reconciliation.
  • Consequence frozen (two-directional, no third state). INSTALLED_TRANSFER iff candidate aggregate strictly > parent AND no family strictly below 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 k/10 and k/60 lattices) AND candidate aggregate strictly > base. BOUNDED otherwise. Frozen claims in the preregistration. Goal gate vs base recorded descriptively.
  • Honest priors frozen. The only prior divergent-skill dose (count_walk) beat its parent 4/5 sealed draws (mean +0.032), but from a higher parent with a narrow single-kind dose at 20 steps, and the family-slack clause historically binds (~4/5 draws): P(aggregate > parent) ≈ 0.4-0.5, P(INSTALLED_TRANSFER) ≈ 0.30-0.40; BOUNDED is the modestly likelier verdict and is a finding about the install-not-equal-convert boundary, not a failure.
  • Standalone package extended. Copied byte-identically: the full data/lineage/ package (six stage datasets + seven provenance receipts), the stage-7/8 production inputs, lineage_trainers/ ×3, train_think.py, merge_adapter.py, rebuild_clean_chain.py, and lifecycle 27's wrappers into scripts/stage7_wrappers/. The manifest was extended with the stage9_state_track_install block (arm, curriculum sha, seed 87, optimizer_steps 20, trainer/merger shas, count_walk parent pins, three null post-merge TODO slots) while carrying lifecycle 28/29's blocks unchanged as chain history; new byte pin c05b0eb6…. rebuild_lineage.py now replays stages 1-9; --verify-inputs green (stage9_dataset=1).
  • Verification at freeze. run.py --smoke green end-to-end (check_design --check, rebuild_lineage --verify-inputs, gen_local_gate --check, 197 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, ledger double-consume, and — for the generator — a corrupted ledger re-derivation, a banned token, and a mutated kind.

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

2026-07-17 — Sealed event 78169: INSTALLED_TRANSFER; cell closed

  • Three arms at 78169 (medium tb1024): base 0.1675, count_walk parent 0.3004, state_track candidate 0.3260. Candidate beats parent (+0.0256) AND base on aggregate, with NO family below the one-episode slack (families_below_slack=[]) -> frozen verdict INSTALLED_TRANSFER. First NEW aggregate-adding move class since replay bounded at stage 8; validates the core doctrine (install a universal skill via a designed synthetic curriculum that looks nothing like the eval, prove by transfer).
  • Per-family vs parent: siftstack +0.2, lockpick +0.1, mirage +0.1; ties on chronicle/menders/rites/warren; sub-episode dips sirens -0.1, toolsmith -0.03, stockade -0.014 (all within slack). The gains are on agentic families plausibly reached by state-tracking transfer.
  • HONEST SCOPE (recorded at closure): (1) SINGLE SEED. The parent's own aggregate swings 0.30-0.36 across sealed seeds (0.3004 here vs 0.3626 at 78168), and state_track's 0.3260 sits inside that band — the +0.0256 could be partly seed noise. Per the confirmation doctrine (which correctly killed the menders reading in lifecycle 28), a fresh eval-only multi-seed confirmation on the same committed composites is required before crowning state_track the durable reference. (2) The ultimate /goal bar (every family strictly > base) is NOT met: warren 0.200 < base 0.367 — a count_walk-inherited weakness state_track did not fix (goal gate vs base: 6 wins, 3 ties, 1 loss on warren).
  • state_track composite: tree 45fd2925..., weights b4bafbb7.... Funded successor: eval-only multi-seed confirmation of the aggregate lift.

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_state_track_install/scripts/run.py --smoke

Full run

.venv/bin/python -B experiments/qwen35_4b_state_track_install/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 ↗