{
  "notes": "EPISODE 6 (2026-11-07). Read 29 results (r2 x16, r2b x5, th-a x4, m5-map, r1 x2). PROMOTION 2: best = CH = ChengHua926/amm-challenge commit d34a5199c59a4c44d5336a25f1436b4ae1f21104 contracts/src/Strategy.sol (raw.githubusercontent.com path; getName \"no_cubic\"), sha256 6dd68f77a70900319460215374143dbd5d924198450a46d9f5f91f6b1e3d35c3. Paired vs YQ on 400000..401999 (ep4 fresh block, no tuning by us): +0.962 se 0.021 n 2000 (worst -4.28 seed 401412); score 0..999 = 525.525882178 (se 2.79; first edges 478.313720, 598.726153, 412.970257); 400000..401999 = 524.037. CH is YQ retuned without the cubic tox term: ACT/SIZE_DECAY 0.53 (YQ 0.7), DIR_DECAY 0.75, SIGMA_DECAY 0.69, PHAT_ALPHA 0.27/0.06, GATE_SIGMA_MULT 7.2, RET_CAP WAD/35, LAMBDA_CAP 1.82, BASE_FEE 4 bps, TOX_COEF 300, TOX_QUAD 15000, TRADE_TOX_BOOST 3500, STALE_ATTRACT_FRAC 1.05, TAIL_KNEE 600, TAIL_SLOPE_ATTRACT 0.85; slots 0-10 used, 11-31 free. Round 2 had a promotion: stop rule not triggered. Round 3 = 27 items (89 of 600 used) as CH deltas, confirmed on the EPISODE-6 FRESH BLOCK 600000..601999, tuning seeds 10000..19999.\n\nSCOREBOARD (paired mean_diff vs YQ 00fae418; r2 on 400000.., r2b/th-a on 500000..):\n- CH (promotion 2): +0.962 se 0.021 n 2000.\n- r2-fresh-a/kalman (YQ + Kalman innovation gate, sha 30703dfd): +0.196 se 0.014 n 2000; 0..999 524.78. Ported to CH in r3-d1/kalman-gate and r3-d3/combo-a.\n- r2-deep-b/tune-decay (DIR 0.7/ACT 0.6/SIZE 0.6 + toxEma capped at the half-band after a gap; sha 84f7c478): +0.182 se 0.017 n 1200 only. CH already has faster decays; the cap is r3-d1/decay-cap.\n- r2-deep-b/retail-alpha (GATE_SIGMA_MULT 10->5, sha f619d002): +0.237 se 0.037 n 300 only. The gate is max(mult*sigmaHat, 3%) and the 3% floor usually binds: r3-d1/gate-grid.\n- r2-simplify/ablate (YQ minus cubic tox, dir skew, sigma*tox; sha a8a761d4): +0.019 se 0.007 n 2000. YQ ablation costs: stale shift -115.6, lambda term -39.8, activity -1.86, flow-size -1.04, trade boost -0.42, tail -0.13; cubic, dir skew, sigma*tox free.\n- running-means (lambda running mean) +0.030 se 0.030 n 200: unresolved, low value.\n- Losers: vol-redo hybrid -0.061 se 0.007 (standalone vol -154.6); lambda-fix -1.27; linear-cma -3.16; freeze-est (sigma frozen) -2.51 (lambda frozen -6.2, size -8.3); yq-lite (6 slots) -17.5; phase -25 (n 30); alpha-first: PHAT_ALPHA 0.5 -12.4, 0.75 -53, 1.0 -120 (below 0.26 untested); th-local -134.6. Every standalone mechanism loses to the YQ family by 3 to 155: build only deltas on the best.\n- Blocked at the toolchain (n 0, unjudged; rerun as CH deltas in r3): sigma-arbs, tune-base, recenter, silence, tune-tox, norm-spot, linear-stale, th-killed, th-pia, th-pair, yq-replicate, pub-elizabeth. Causes: no cc, SOLCX folder missing, /tmp vanishing, rustup without /proc; every r3 brief carries the requester's recipe with the four fixes.\n- Unread: r2b-a/tune-asym, r2-fresh-a/arb-class (running), r2-measure/pub-shl0k28, r2-fresh-b/warmup (settled), r1x/*, anchors2 b items, other r1 items; the first three are in this read.\n- Round 1 vs starter (100000..101999): YQ +154.69 se 0.95; example-tuned +65.71; fair-centered +66.84; fixed 75/75 +10.61.\n\nCALIBRATION (900000..909999, report-only): YQ 522.520303864629 se 0.917 (first edges 442.453690, 367.758597, 554.500124); vanilla 342.26; starter 367.92. YQ's 0..999 score (524.63) is 2.1 above its calibration score, so the 525/527/528 thresholds are ~2 harder than 0..999 suggests; not reached. CH's number comes from r3-m1/ch-calib (expect ~523.5). BOARD MAP (m5-map, official API, 743 entries): SmokeTest30bps 338.60 (local 342.26), Starter 367.18 (local 367.92), Fixed75 378.94 (local 380.1), YQ claims 523.21 (local 524.63): board = local minus 0.7-3.7, so 1st (528.40) needs ~529.5-530 local on 0..999 = +4 over CH. YQ's '30 bps = 522.13' was its own cross-seed mean, not a board score: no simulator mismatch. Leaderboard and detail scores differ for the same id (367.18 vs 364.06): quote the leaderboard field. YQ reproduces 524.6271111458843 on 0..999 on three machines.\n\nROUND 3 ITEMS (all CH deltas): r3-d1 kalman-gate, decay-cap, alpha-grid, gate-grid, highfee; r3-d2 tune-base, tune-tox, tune-stale (+ATTRACT_FLOOR), tune-est, cma-residual (CMA-ES over all constants); r3-d3 timing-terms, sigma-elapsed, fees-used (+conditional alpha), combo-a (kalman+cap+ablate subsets); r3-f1 norm-attract, norm-phat (normalizer spot inferred from the router split), post-arb-pair (theory table as floor/cap), silence-clamp, two-print; r3-f2 th-killed, th-pia; r3-s1 ablate, lite9; r3-m1 ch-replicate (bit-identity + fresh CH vs YQ), ch-calib, ch-repo-scan (all 28 commits and param sets of ChengHua's repo vs CH), pub-scan (new public repos incl. elizabeth 7156ff03 vs CH).\n\nNEXT EPISODE (7): 1) Read r3-*/* (27) + tune-asym, arb-class, pub-shl0k28. Drop any item with paired.n 0 or under 500 (rerun its idea later; not a failure). Scoreboard per item vs CH on 600000..601999: mean_diff, se, n, sha256, 0..999 score, delta. 2) PROMOTION 3 = largest mean_diff >= 2 se with n >= 2000; a public file from ch-repo-scan or pub-scan that beats CH is the natural base (URL + sha travels in a brief). If several deltas clear, round 4's first item combines them ('CH + delta1 + delta2', each delta <= 1500 chars pasted from its result) and confirms on 700000..701999. If none clears, round 3 is a round without promotion (stop rule: two in a row). 3) ch-replicate: if CH's expected numbers do not match to 6 decimals, say in every brief that only in-item paired numbers count. ch-calib: record CH's calibration mean + se; say whether it reaches 525. 4) Spawn round 4 (~30 items, batches <= 5, names r4-*, fresh block 700000..701999, tuning seeds 20000..29999): 40% deepen the new best (combine clearing deltas, refine grids, `next` lines of positive items), 30% fresh (retail-absence evidence, sell-side router asymmetry, losing fresh ideas re-framed if their report suggests it), 15% simplify, 15% measure (replicate promotion 3 on another machine; calibration of the new best). Read list stays at 30. 5) Budget after this episode: 511 items, 4 episodes (7-10): rounds 4-5 in ep7-8, final confirmation + calibration in ep9, finish in ep10. Write-up: best .sol, sha256, paired gain over starter and over the previous best with se, ranked promotions (1 YQ +154.69 se 0.95 vs starter; 2 CH +0.962 se 0.021 vs YQ), citations (YQ repo, ChengHua repo, dipankar, elizabeth, Algebra medium post, Bruno I. LinkedIn, HackMD note, paradigm API).\n\nCARRIED FORWARD: seeds: `amm-match run --simulations N` = seeds 0..N-1 (MatchRunner._build_configs: numpy default_rng(seed) draws mean size, rate, sigma; Rust price seed = seed, retail seed+1); other ranges via amm_sim_rs.run_batch. Fresh block for episode e = e*100000..+1999 (ep7 = 700000..701999); tune only on 0..99999, each round its own 10000-block; promote only when paired mean_diff >= 2 se, n >= 2000, on the episode's fresh block vs the current best; 900000..909999 report-only. Rules: `contract Strategy is AMMStrategyBase`, imports ./AMMStrategyBase.sol + ./IAMMStrategy.sol only, slots 0..31, 250000 gas, solc 0.8.24 viaIR, max fee 10%, no loops. Simulator: 10000 steps; GBM sigma U(0.000882,0.001008) per sim; arb each step leaves spot at the band edge (AMM bought X: p = spot*(1-bid); sold X: p = spot/(1-ask)); Poisson(U(0.6,1.0)) retail, lognormal mean U(19,21) Y sigma 1.2, 50/50, router splits each order between us and the fixed 30 bps pool so marginal prices equalise (fee on input); both pools start at 100 X / 10000 Y; silence = no arb. Theory: post-bid-arb optimum 58.6/16.2 bps relaxing 1:48/18 2:42/20 4:34/22 8:28/25 16:27/26 32:26/26; a favourable side near 16 bps pays, zero does not. Never ask a worker about its machine (ep2 refusal). Brief <= 3000 chars filled: the r3 template is ~2400 (recipe ~1000, keep it) + idea <= 580. Timing 0.05-0.4 s/sim; some machines give 1 CPU or kill a process after 90 s: ask for chunked runs and the covered n. r1 code wave (no trunk) is harmless; leave it.",
  "spawn": [
    {
      "name": "r3-d1",
      "mode": "research",
      "brief": "AMM fee challenge round 3 (deepen), item {{key}}: one idea as a delta on the best, one Strategy.sol, measured paired. TOOLCHAIN (~15 min, inside the checkout, never /tmp, no root; block only if a step fails, naming it and its error): clone github.com/benedictbrady/amm-challenge at 6b6921f8d463314aa7c96234e1be25a25245f704 into your workspace; mkdir -p scratch/tmp; export TMPDIR=$PWD/scratch/tmp; install uv (astral.sh/uv/install.sh, UV_INSTALL_DIR=$PWD/scratch/uv) and Rust (sh.rustup.rs, RUSTUP_HOME=$PWD/scratch/rustup CARGO_HOME=$PWD/scratch/cargo exported, -y --profile minimal; 'no /proc/self/exe' = block at once), both on PATH; if `cc --version` fails: curl -Ls micro.mamba.pm/api/micromamba/linux-64/latest | tar -xj -C scratch bin/micromamba; MAMBA_ROOT_PREFIX=$PWD/scratch/mamba scratch/bin/micromamba create -y -p $PWD/scratch/cenv -c conda-forge gcc; set CC and CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER to that gcc (fallback: uv pip install ziglang + a `cc` wrapper running `python -m ziglang cc \"$@\"`); uv venv; uv pip install -e . maturin; maturin develop --release --uv --manifest-path amm_sim_rs/Cargo.toml; SOLCX_BINARY_PATH unset or mkdir -p'd; amm-match validate contracts/src/StarterStrategy.sol. BEST = CH: https://raw.githubusercontent.com/ChengHua926/amm-challenge/d34a5199c59a4c44d5336a25f1436b4ae1f21104/contracts/src/Strategy.sol, sha256 6dd68f77a70900319460215374143dbd5d924198450a46d9f5f91f6b1e3d35c3 (verify, validate; YQ-family, slots 0-10 used, 11-31 free). IDEA: {{idea}} MEASURE: per-seed edges via amm_sim_rs.run_batch, configs as MatchRunner._build_configs (numpy default_rng(seed) draws size, rate, sigma; Rust seeds seed, seed+1); paired = same seeds, diff = candidate - CH, se = sd/sqrt(n). Tune ONLY on seeds 10000..19999 (n >= 500 each). Freeze the candidate, measure it ONCE paired vs CH on 600000..601999 (n 2000, chunked; if fewer, say so), score it on 0..999 (CH = 525.525882178). Never run 900000..909999. amm-match validate must pass; slots 0..31; no loops; under 250000 gas. A losing result is a valid result. RESULT (one JSON): approach; tried [{variant, seeds, n, mean_diff, se}]; next; code (full .sol); code_sha256; delta (exact edits from CH, <= 1500 chars); score {seed_start 0, n, mean_edge, se}; paired {reference 'CH 6dd68f77', seed_start 600000, n, mean_diff, se, worst 5}; seconds_per_simulation; validate_ok; blocked (null or step + error); citations.",
      "items": [
        {
          "key": "kalman-gate",
          "vars": {
            "key": "kalman-gate",
            "idea": "Port the Kalman innovation gate (+0.20, se 0.014, n 2000 on YQ). New slot 11 kfVar: afterInitialize kfVar = 10*sigmaHat^2; on each new step kfVar += sigmaHat^2 (WAD math); replace the adaptiveGate test by: kfR = (firstInStep ? R1 : R2)*sigmaHat^2; accept the print when ret^2 <= G*(kfVar + kfR); after an accepted first-in-step print kfVar *= (1-PHAT_ALPHA). Keep CH's alphas; MIN_GATE goes. Start R1 11, R2 25, G 4 (fitted on YQ's 10*sigma gate; CH's is 7.2*sigma), regrid R1 in {6, 11, 16} and G in {3, 4, 5} on tuning seeds, refine the best cell. Deliver the best."
          }
        },
        {
          "key": "decay-cap",
          "vars": {
            "key": "decay-cap",
            "idea": "On YQ, faster DIR/ACT/SIZE decays plus a cap of toxEma at the half-band after a gap gave +0.18 (se 0.017, n 1200). CH already has ACT 0.53, SIZE 0.53, DIR 0.75, so test the cap alone first: after the toxEma decay line insert `if (elapsedRaw > 1) { uint256 hb = (prevBidFee + prevAskFee) / 2; if (toxEma > hb) toxEma = hb; }`. Then variants: cap at the protect-side previous fee; cap at 1.5*hb; cap only when elapsedRaw > 2; and ELAPSED_CAP 4 / 12 / 16 on the best cap. Deliver the best."
          }
        },
        {
          "key": "alpha-grid",
          "vars": {
            "key": "alpha-grid",
            "idea": "Grid PHAT_ALPHA (0.27) x PHAT_ALPHA_RETAIL (0.06): alpha in {0.18, 0.22, 0.27, 0.32}, retail in {0.03, 0.06, 0.09}, n 500 each on tuning seeds, then refine around the best cell with n 1000. On YQ alpha 0.5 lost 12 and 1.0 lost 120, so the optimum is low; values below 0.26 were never tried. Also test, at the best cell, alpha scaled by min(elapsedRaw, 4)/2 (more trust after a long gap)."
          }
        },
        {
          "key": "gate-grid",
          "vars": {
            "key": "gate-grid",
            "idea": "The pHat gate is max(GATE_SIGMA_MULT*sigmaHat, MIN_GATE) = max(7.2*sigmaHat, 3%); with sigmaHat near 0.1% the 3% floor dominates, so the gate rarely rejects. Grid MIN_GATE in {0.5%, 1%, 2%, 3%, 4.5%} x GATE_SIGMA_MULT in {4, 7.2, 12}, n 500 each; then RET_CAP in {WAD/50, WAD/35, WAD/20} at the best cell; then a separate gate for later prints (x0.5, x1, x2 of the first-print gate). On YQ, gate 5*sigma beat 10*sigma by +0.24 (se 0.04, n 300). Deliver the best."
          }
        },
        {
          "key": "highfee",
          "vars": {
            "key": "highfee",
            "idea": "A YQ ablation saw 1000-step mean fees of 200-290 bps on seeds 10879 and 10166 while the fee peaks at the 10% cap. Log per-call fees, pHat, spot, toxEma, actEma for CH on those two seeds and on the 5 seeds with the lowest CH edge among 10000..10499; say what drives the high-fee episodes (MIN_GATE 3% rejecting the correcting print, toxEma, actEma, dirState). Then test fixes: a cap on fMid before the stale shift in {150, 250, 400} bps; TOX_DECAY 0.8 when the previous fee was above TAIL_KNEE; MIN_GATE 1.5%. Deliver the best fix."
          }
        }
      ],
      "output": {
        "format": "json",
        "maxBytes": 64000
      }
    },
    {
      "name": "r3-d2",
      "mode": "research",
      "brief": "AMM fee challenge round 3 (deepen), item {{key}}: one idea as a delta on the best, one Strategy.sol, measured paired. TOOLCHAIN (~15 min, inside the checkout, never /tmp, no root; block only if a step fails, naming it and its error): clone github.com/benedictbrady/amm-challenge at 6b6921f8d463314aa7c96234e1be25a25245f704 into your workspace; mkdir -p scratch/tmp; export TMPDIR=$PWD/scratch/tmp; install uv (astral.sh/uv/install.sh, UV_INSTALL_DIR=$PWD/scratch/uv) and Rust (sh.rustup.rs, RUSTUP_HOME=$PWD/scratch/rustup CARGO_HOME=$PWD/scratch/cargo exported, -y --profile minimal; 'no /proc/self/exe' = block at once), both on PATH; if `cc --version` fails: curl -Ls micro.mamba.pm/api/micromamba/linux-64/latest | tar -xj -C scratch bin/micromamba; MAMBA_ROOT_PREFIX=$PWD/scratch/mamba scratch/bin/micromamba create -y -p $PWD/scratch/cenv -c conda-forge gcc; set CC and CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER to that gcc (fallback: uv pip install ziglang + a `cc` wrapper running `python -m ziglang cc \"$@\"`); uv venv; uv pip install -e . maturin; maturin develop --release --uv --manifest-path amm_sim_rs/Cargo.toml; SOLCX_BINARY_PATH unset or mkdir -p'd; amm-match validate contracts/src/StarterStrategy.sol. BEST = CH: https://raw.githubusercontent.com/ChengHua926/amm-challenge/d34a5199c59a4c44d5336a25f1436b4ae1f21104/contracts/src/Strategy.sol, sha256 6dd68f77a70900319460215374143dbd5d924198450a46d9f5f91f6b1e3d35c3 (verify, validate; YQ-family, slots 0-10 used, 11-31 free). IDEA: {{idea}} MEASURE: per-seed edges via amm_sim_rs.run_batch, configs as MatchRunner._build_configs (numpy default_rng(seed) draws size, rate, sigma; Rust seeds seed, seed+1); paired = same seeds, diff = candidate - CH, se = sd/sqrt(n). Tune ONLY on seeds 10000..19999 (n >= 500 each). Freeze the candidate, measure it ONCE paired vs CH on 600000..601999 (n 2000, chunked; if fewer, say so), score it on 0..999 (CH = 525.525882178). Never run 900000..909999. amm-match validate must pass; slots 0..31; no loops; under 250000 gas. A losing result is a valid result. RESULT (one JSON): approach; tried [{variant, seeds, n, mean_diff, se}]; next; code (full .sol); code_sha256; delta (exact edits from CH, <= 1500 chars); score {seed_start 0, n, mean_edge, se}; paired {reference 'CH 6dd68f77', seed_start 600000, n, mean_diff, se, worst 5}; seconds_per_simulation; validate_ok; blocked (null or step + error); citations.",
      "items": [
        {
          "key": "tune-base",
          "vars": {
            "key": "tune-base",
            "idea": "Two-pass coordinate search over the five base-fee constants BASE_FEE 4 bps, SIGMA_COEF 0.2, LAMBDA_COEF 12 bps, FLOW_SIZE_COEF 4842 bps, ACT_COEF 91843 bps: pass 1 steps of -25%/+25% on seeds 10000..10499, keep a step only when it clears 2 se, then -10%/+10%; pass 2 repeats on 11000..11499. Report every evaluation. Deliver the end point."
          }
        },
        {
          "key": "tune-tox",
          "vars": {
            "key": "tune-tox",
            "idea": "Two-pass coordinate search over the toxicity constants TOX_COEF 300 bps, TOX_QUAD_COEF 15000 bps, SIGMA_TOX_COEF 500 bps, TOX_BLEND_DECAY 0.051, TOX_DECAY 0.91, TOX_CAP WAD/5: pass 1 steps of -25%/+25% on seeds 10000..10499, keep a step only when it clears 2 se, then -10%/+10%; pass 2 on 11000..11499. Report every evaluation. Deliver the end point."
          }
        },
        {
          "key": "tune-stale",
          "vars": {
            "key": "tune-stale",
            "idea": "Two-pass coordinate search over the asymmetry constants STALE_DIR_COEF 6850 bps, STALE_ATTRACT_FRAC 1.05, TRADE_TOX_BOOST 3500 bps, TRADE_RATIO_CAP WAD/5, TAIL_KNEE 600 bps, TAIL_SLOPE_PROTECT 0.93, TAIL_SLOPE_ATTRACT 0.85, plus a new ATTRACT_FLOOR (lowest attract-side fee, start 0, try 5/10/16 bps; theory says a favourable side near 16 bps pays, zero does not): pass 1 steps of -25%/+25% on seeds 10000..10499, keep a step only when it clears 2 se, then -10%/+10%; pass 2 on 11000..11499. Report every evaluation. Deliver the end point."
          }
        },
        {
          "key": "tune-est",
          "vars": {
            "key": "tune-est",
            "idea": "Two-pass coordinate search over the estimator constants SIGMA_DECAY 0.69, LAMBDA_DECAY 0.99, LAMBDA_CAP 1.82, SIZE_BLEND_DECAY 0.828, ACT_BLEND_DECAY 0.985, SIGNAL_THRESHOLD WAD/650, DIR_IMPACT_MULT 4, STEP_COUNT_CAP 64, DIR_DECAY 0.75, ACT_DECAY 0.53, SIZE_DECAY 0.53 (decays stepped in 1-x space): pass 1 steps of -25%/+25% on seeds 10000..10499, keep a step only when it clears 2 se, then -10%/+10%; pass 2 on 11000..11499. Report every evaluation. Deliver the end point."
          }
        },
        {
          "key": "cma-residual",
          "vars": {
            "key": "cma-residual",
            "idea": "CMA-ES (uv pip install cma) over all of CH's tunable constants at once, each parametrised as CH value * exp(x) (decays in 1-x space), sigma0 0.1, popsize 10; objective = paired mean_diff vs CH on the fixed seeds 10000..10299 (common random numbers, se about 0.03-0.2), as many generations as fit in 35 minutes of wall time, with CH itself as the start point. Report the best-ever vector and the generation curve. Deliver the best-ever file (it is confirmed on the fresh block like any other)."
          }
        }
      ],
      "output": {
        "format": "json",
        "maxBytes": 64000
      }
    },
    {
      "name": "r3-d3",
      "mode": "research",
      "brief": "AMM fee challenge round 3 (deepen), item {{key}}: one idea as a delta on the best, one Strategy.sol, measured paired. TOOLCHAIN (~15 min, inside the checkout, never /tmp, no root; block only if a step fails, naming it and its error): clone github.com/benedictbrady/amm-challenge at 6b6921f8d463314aa7c96234e1be25a25245f704 into your workspace; mkdir -p scratch/tmp; export TMPDIR=$PWD/scratch/tmp; install uv (astral.sh/uv/install.sh, UV_INSTALL_DIR=$PWD/scratch/uv) and Rust (sh.rustup.rs, RUSTUP_HOME=$PWD/scratch/rustup CARGO_HOME=$PWD/scratch/cargo exported, -y --profile minimal; 'no /proc/self/exe' = block at once), both on PATH; if `cc --version` fails: curl -Ls micro.mamba.pm/api/micromamba/linux-64/latest | tar -xj -C scratch bin/micromamba; MAMBA_ROOT_PREFIX=$PWD/scratch/mamba scratch/bin/micromamba create -y -p $PWD/scratch/cenv -c conda-forge gcc; set CC and CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER to that gcc (fallback: uv pip install ziglang + a `cc` wrapper running `python -m ziglang cc \"$@\"`); uv venv; uv pip install -e . maturin; maturin develop --release --uv --manifest-path amm_sim_rs/Cargo.toml; SOLCX_BINARY_PATH unset or mkdir -p'd; amm-match validate contracts/src/StarterStrategy.sol. BEST = CH: https://raw.githubusercontent.com/ChengHua926/amm-challenge/d34a5199c59a4c44d5336a25f1436b4ae1f21104/contracts/src/Strategy.sol, sha256 6dd68f77a70900319460215374143dbd5d924198450a46d9f5f91f6b1e3d35c3 (verify, validate; YQ-family, slots 0-10 used, 11-31 free). IDEA: {{idea}} MEASURE: per-seed edges via amm_sim_rs.run_batch, configs as MatchRunner._build_configs (numpy default_rng(seed) draws size, rate, sigma; Rust seeds seed, seed+1); paired = same seeds, diff = candidate - CH, se = sd/sqrt(n). Tune ONLY on seeds 10000..19999 (n >= 500 each). Freeze the candidate, measure it ONCE paired vs CH on 600000..601999 (n 2000, chunked; if fewer, say so), score it on 0..999 (CH = 525.525882178). Never run 900000..909999. amm-match validate must pass; slots 0..31; no loops; under 250000 gas. A losing result is a valid result. RESULT (one JSON): approach; tried [{variant, seeds, n, mean_diff, se}]; next; code (full .sol); code_sha256; delta (exact edits from CH, <= 1500 chars); score {seed_start 0, n, mean_edge, se}; paired {reference 'CH 6dd68f77', seed_start 600000, n, mean_diff, se, worst 5}; seconds_per_simulation; validate_ok; blocked (null or step + error); citations.",
      "items": [
        {
          "key": "timing-terms",
          "vars": {
            "key": "timing-terms",
            "idea": "A linear policy fitted on YQ found a first-in-step term of -2.2 bps and +0.5 bps per idle step (cap 8). Add to CH after fMid: fMid = fMid + IDLE_COEF*min(elapsedRaw, 8) - (firstInStep ? FIRST_COEF : 0) (floor at 0). Grid IDLE_COEF in {0, 0.25, 0.5, 1} bps x FIRST_COEF in {0, 1, 2, 4} bps, n 500 each; refine the best. Deliver the best."
          }
        },
        {
          "key": "sigma-elapsed",
          "vars": {
            "key": "sigma-elapsed",
            "idea": "sigmaHat is an EMA of first-print |ret| that ignores how many steps elapsed. Replace it by a running variance per step: v = v*D + (1-D)*ret^2/elapsedRaw on first-in-step prints (elapsedRaw >= 1), sigmaHat = isqrt(v) (integer sqrt, WAD scaling), initialised at (0.00095)^2. Grid D in {0.69, 0.8, 0.9} x SIGMA_COEF in {0.1, 0.2, 0.3}, n 500 each. Keep the gate on the new sigmaHat. Deliver the best."
          }
        },
        {
          "key": "fees-used",
          "vars": {
            "key": "fees-used",
            "idea": "Theory: invert the band with the fees USED for the trade (the fees returned by the previous call, slots 0/1), not the fees being computed. Read CH's feeUsed and pImplied code and state whether it does; if not, fix it and measure. Then test a conditional alpha: when a first-in-step print has ret > K*sigmaHat (likely a true arb) use alpha A in {0.35, 0.5} instead of 0.27, K in {1, 2}; n 500 per cell. Deliver the best."
          }
        },
        {
          "key": "combo-a",
          "vars": {
            "key": "combo-a",
            "idea": "Combine three positive YQ deltas on CH and measure every subset: (a) Kalman innovation gate (slot 11 kfVar: init 10*sigmaHat^2, += sigmaHat^2 per new step, accept a print when ret^2 <= 4*(kfVar + (firstInStep ? 11 : 25)*sigmaHat^2), kfVar *= (1-PHAT_ALPHA) after an accepted first print, MIN_GATE dropped); (b) after a gap of more than one step cap toxEma at (prevBidFee+prevAskFee)/2; (c) remove dir skew (DIR_COEF, DIR_TOX_COEF) and the sigma*tox term. Measure a, b, c, ab, ac, bc, abc on seeds 10000..10999 (n 1000). Deliver the best subset."
          }
        }
      ],
      "output": {
        "format": "json",
        "maxBytes": 64000
      }
    },
    {
      "name": "r3-f1",
      "mode": "research",
      "brief": "AMM fee challenge round 3 (fresh), item {{key}}: one idea as a delta on the best, one Strategy.sol, measured paired. TOOLCHAIN (~15 min, inside the checkout, never /tmp, no root; block only if a step fails, naming it and its error): clone github.com/benedictbrady/amm-challenge at 6b6921f8d463314aa7c96234e1be25a25245f704 into your workspace; mkdir -p scratch/tmp; export TMPDIR=$PWD/scratch/tmp; install uv (astral.sh/uv/install.sh, UV_INSTALL_DIR=$PWD/scratch/uv) and Rust (sh.rustup.rs, RUSTUP_HOME=$PWD/scratch/rustup CARGO_HOME=$PWD/scratch/cargo exported, -y --profile minimal; 'no /proc/self/exe' = block at once), both on PATH; if `cc --version` fails: curl -Ls micro.mamba.pm/api/micromamba/linux-64/latest | tar -xj -C scratch bin/micromamba; MAMBA_ROOT_PREFIX=$PWD/scratch/mamba scratch/bin/micromamba create -y -p $PWD/scratch/cenv -c conda-forge gcc; set CC and CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER to that gcc (fallback: uv pip install ziglang + a `cc` wrapper running `python -m ziglang cc \"$@\"`); uv venv; uv pip install -e . maturin; maturin develop --release --uv --manifest-path amm_sim_rs/Cargo.toml; SOLCX_BINARY_PATH unset or mkdir -p'd; amm-match validate contracts/src/StarterStrategy.sol. BEST = CH: https://raw.githubusercontent.com/ChengHua926/amm-challenge/d34a5199c59a4c44d5336a25f1436b4ae1f21104/contracts/src/Strategy.sol, sha256 6dd68f77a70900319460215374143dbd5d924198450a46d9f5f91f6b1e3d35c3 (verify, validate; YQ-family, slots 0-10 used, 11-31 free). IDEA: {{idea}} MEASURE: per-seed edges via amm_sim_rs.run_batch, configs as MatchRunner._build_configs (numpy default_rng(seed) draws size, rate, sigma; Rust seeds seed, seed+1); paired = same seeds, diff = candidate - CH, se = sd/sqrt(n). Tune ONLY on seeds 10000..19999 (n >= 500 each). Freeze the candidate, measure it ONCE paired vs CH on 600000..601999 (n 2000, chunked; if fewer, say so), score it on 0..999 (CH = 525.525882178). Never run 900000..909999. amm-match validate must pass; slots 0..31; no loops; under 250000 gas. A losing result is a valid result. RESULT (one JSON): approach; tried [{variant, seeds, n, mean_diff, se}]; next; code (full .sol); code_sha256; delta (exact edits from CH, <= 1500 chars); score {seed_start 0, n, mean_edge, se}; paired {reference 'CH 6dd68f77', seed_start 600000, n, mean_diff, se, worst 5}; seconds_per_simulation; validate_ok; blocked (null or step + error); citations.",
      "items": [
        {
          "key": "norm-attract",
          "vars": {
            "key": "norm-attract",
            "idea": "Infer the 30 bps normalizer pool's spot: both pools start at config.py's 100 X / 10000 Y; amm_sim_rs/src/market/router.rs splits a retail order so both pools' marginal prices (fee on input) are equal after it, so a shared retail print gives the normalizer's post-trade spot from ours and the two fees; between prints it is arbed to within its 30 bps band of p. Keep the estimate in slots 11-12. Use it on the ATTRACT side only: set the attract fee so our marginal price undercuts the normalizer's by m in {1, 2, 4} bps, never below 0; never touch the protect side. Deliver the best m."
          }
        },
        {
          "key": "norm-phat",
          "vars": {
            "key": "norm-phat",
            "idea": "Infer the 30 bps normalizer pool's spot (both pools start at config.py's 100 X / 10000 Y; amm_sim_rs/src/market/router.rs splits a shared retail order so both pools' marginal prices with fee on input are equal, so its post-trade spot follows from ours and the two fees) and use it ONLY as a second fair-price observation: p lies within the normalizer's 30 bps band of its spot, tighter than ours when our fees exceed 30 bps. After CH's pHat update clamp pHat into that band (variant: blend toward its centre with w in {0.1, 0.3, 0.5}). Fees as CH. Deliver the best."
          }
        },
        {
          "key": "post-arb-pair",
          "vars": {
            "key": "post-arb-pair",
            "idea": "Theory: the immediate optimum after a bid-side arb against a 30 bps competitor is bid 58.6 / ask 16.2 bps, relaxing over n silent steps to 1: 48/18, 2: 42/20, 4: 34/22, 8: 28/25, 16: 27/26, 32: 26/26 (mirror for an ask-side arb). Delta on CH: when a first-in-step print has ret > 2*sigmaHat, store its timestamp and direction (slots 11-12); on every later call floor the protect side at s*P(n) and cap the attract side at s*A(n), n = steps since that arb, interpolating the table. Grid s in {0.6, 0.8, 1.0, 1.2}. Deliver the best s."
          }
        },
        {
          "key": "silence-clamp",
          "vars": {
            "key": "silence-clamp",
            "idea": "Silence evidence: a gap of k > 1 steps means no arb hit us, so p stayed inside the band we quoted during the gap. Store the post-trade spot of every call in slot 11. On a print after a gap, before CH's pHat update, clamp pHat into [spotPrev*(1 - bidUsed), spotPrev/(1 - askUsed)] (the fees returned by the previous call). Variant B: also shrink that print's gate to half. Variant C: apply the clamp also when the gap is exactly 1. Fees as CH. Deliver the best."
          }
        },
        {
          "key": "two-print",
          "vars": {
            "key": "two-print",
            "idea": "Use the second print within a step to reclassify the first. Store pHat before the first-in-step update in slot 11. If a second print in the same step moves the implied price the opposite way, the first was likely retail: move pHat back toward the stored value with weight u in {0.5, 1.0}. If a second print goes the same way, raise that print's alpha to {0.1, 0.2} instead of 0.06. Measure the four combinations and each half alone, n 500. Deliver the best."
          }
        }
      ],
      "output": {
        "format": "json",
        "maxBytes": 64000
      }
    },
    {
      "name": "r3-f2",
      "mode": "research",
      "brief": "AMM fee challenge round 3 (fresh), item {{key}}: one idea as a delta on the best, one Strategy.sol, measured paired. TOOLCHAIN (~15 min, inside the checkout, never /tmp, no root; block only if a step fails, naming it and its error): clone github.com/benedictbrady/amm-challenge at 6b6921f8d463314aa7c96234e1be25a25245f704 into your workspace; mkdir -p scratch/tmp; export TMPDIR=$PWD/scratch/tmp; install uv (astral.sh/uv/install.sh, UV_INSTALL_DIR=$PWD/scratch/uv) and Rust (sh.rustup.rs, RUSTUP_HOME=$PWD/scratch/rustup CARGO_HOME=$PWD/scratch/cargo exported, -y --profile minimal; 'no /proc/self/exe' = block at once), both on PATH; if `cc --version` fails: curl -Ls micro.mamba.pm/api/micromamba/linux-64/latest | tar -xj -C scratch bin/micromamba; MAMBA_ROOT_PREFIX=$PWD/scratch/mamba scratch/bin/micromamba create -y -p $PWD/scratch/cenv -c conda-forge gcc; set CC and CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER to that gcc (fallback: uv pip install ziglang + a `cc` wrapper running `python -m ziglang cc \"$@\"`); uv venv; uv pip install -e . maturin; maturin develop --release --uv --manifest-path amm_sim_rs/Cargo.toml; SOLCX_BINARY_PATH unset or mkdir -p'd; amm-match validate contracts/src/StarterStrategy.sol. BEST = CH: https://raw.githubusercontent.com/ChengHua926/amm-challenge/d34a5199c59a4c44d5336a25f1436b4ae1f21104/contracts/src/Strategy.sol, sha256 6dd68f77a70900319460215374143dbd5d924198450a46d9f5f91f6b1e3d35c3 (verify, validate; YQ-family, slots 0-10 used, 11-31 free). IDEA: {{idea}} MEASURE: per-seed edges via amm_sim_rs.run_batch, configs as MatchRunner._build_configs (numpy default_rng(seed) draws size, rate, sigma; Rust seeds seed, seed+1); paired = same seeds, diff = candidate - CH, se = sd/sqrt(n). Tune ONLY on seeds 10000..19999 (n >= 500 each). Freeze the candidate, measure it ONCE paired vs CH on 600000..601999 (n 2000, chunked; if fewer, say so), score it on 0..999 (CH = 525.525882178). Never run 900000..909999. amm-match validate must pass; slots 0..31; no loops; under 250000 gas. A losing result is a valid result. RESULT (one JSON): approach; tried [{variant, seeds, n, mean_diff, se}]; next; code (full .sol); code_sha256; delta (exact edits from CH, <= 1500 chars); score {seed_start 0, n, mean_edge, se}; paired {reference 'CH 6dd68f77', seed_start 600000, n, mean_diff, se, worst 5}; seconds_per_simulation; validate_ok; blocked (null or step + error); citations.",
      "items": [
        {
          "key": "th-killed",
          "vars": {
            "key": "th-killed",
            "idea": "Killed-kernel relaxation: during a silence of n steps the posterior mean of p drifts from the last implied price toward the centre of the band quoted during the gap as exp(-3*pi^2*sigma^2*n/(2*W^2)), W = bidUsed + askUsed, variance saturating at W^2*(1/4 - 2/pi^2). On a print after a gap, before CH's update, move pHat toward that band centre by that factor (previous spot and fees used in slots 11-12; WAD exp by a short series) and widen fMid by c*sqrt(variance), c in {0, 0.1, 0.3}. Grid a kernel scale k in {0.5, 1, 2} on the exponent. Deliver the best."
          }
        },
        {
          "key": "th-pia",
          "vars": {
            "key": "th-pia",
            "idea": "Arb-probability gate. Replace CH's hard gate on first-in-step prints by a soft weight: P(arb) from the likelihood ratio of a normal prior on log(pImplied/pHat) with variance s^2*sigmaHat^2*elapsedRaw (the price moved) against a retail explanation where the print's amountY is lognormal(mean 20*Y_reserve/10000, sigma 1.2) and the implied move is noise of scale tox; alpha = PHAT_ALPHA*P(arb) (and sigmaHat update weighted the same). Grid the prior scale s in {1, 2, 4} and the retail noise scale in {0.5, 1}. Deliver the best."
          }
        }
      ],
      "output": {
        "format": "json",
        "maxBytes": 64000
      }
    },
    {
      "name": "r3-s1",
      "mode": "research",
      "brief": "AMM fee challenge round 3 (simplify), item {{key}}: one idea as a delta on the best, one Strategy.sol, measured paired. TOOLCHAIN (~15 min, inside the checkout, never /tmp, no root; block only if a step fails, naming it and its error): clone github.com/benedictbrady/amm-challenge at 6b6921f8d463314aa7c96234e1be25a25245f704 into your workspace; mkdir -p scratch/tmp; export TMPDIR=$PWD/scratch/tmp; install uv (astral.sh/uv/install.sh, UV_INSTALL_DIR=$PWD/scratch/uv) and Rust (sh.rustup.rs, RUSTUP_HOME=$PWD/scratch/rustup CARGO_HOME=$PWD/scratch/cargo exported, -y --profile minimal; 'no /proc/self/exe' = block at once), both on PATH; if `cc --version` fails: curl -Ls micro.mamba.pm/api/micromamba/linux-64/latest | tar -xj -C scratch bin/micromamba; MAMBA_ROOT_PREFIX=$PWD/scratch/mamba scratch/bin/micromamba create -y -p $PWD/scratch/cenv -c conda-forge gcc; set CC and CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER to that gcc (fallback: uv pip install ziglang + a `cc` wrapper running `python -m ziglang cc \"$@\"`); uv venv; uv pip install -e . maturin; maturin develop --release --uv --manifest-path amm_sim_rs/Cargo.toml; SOLCX_BINARY_PATH unset or mkdir -p'd; amm-match validate contracts/src/StarterStrategy.sol. BEST = CH: https://raw.githubusercontent.com/ChengHua926/amm-challenge/d34a5199c59a4c44d5336a25f1436b4ae1f21104/contracts/src/Strategy.sol, sha256 6dd68f77a70900319460215374143dbd5d924198450a46d9f5f91f6b1e3d35c3 (verify, validate; YQ-family, slots 0-10 used, 11-31 free). IDEA: {{idea}} MEASURE: per-seed edges via amm_sim_rs.run_batch, configs as MatchRunner._build_configs (numpy default_rng(seed) draws size, rate, sigma; Rust seeds seed, seed+1); paired = same seeds, diff = candidate - CH, se = sd/sqrt(n). Tune ONLY on seeds 10000..19999 (n >= 500 each). Freeze the candidate, measure it ONCE paired vs CH on 600000..601999 (n 2000, chunked; if fewer, say so), score it on 0..999 (CH = 525.525882178). Never run 900000..909999. amm-match validate must pass; slots 0..31; no loops; under 250000 gas. A losing result is a valid result. RESULT (one JSON): approach; tried [{variant, seeds, n, mean_diff, se}]; next; code (full .sol); code_sha256; delta (exact edits from CH, <= 1500 chars); score {seed_start 0, n, mean_edge, se}; paired {reference 'CH 6dd68f77', seed_start 600000, n, mean_diff, se, worst 5}; seconds_per_simulation; validate_ok; blocked (null or step + error); citations.",
      "items": [
        {
          "key": "ablate",
          "vars": {
            "key": "ablate",
            "idea": "Ablation of CH with no retuning: remove alone each of dir skew (DIR_COEF, DIR_TOX_COEF), the sigma*tox term, TOX_QUAD, trade boost, tail compression, the ACT term, the lambda term, the flow-size term, and measure each on seeds 10000..10999 (n 1000) paired vs CH; keep a removal when mean_diff > -1 se (on YQ dir skew and sigma*tox were free, the rest cost). Then on the stripped file test one tail slope 0.89 instead of 0.93/0.85. Deliver the stripped file with dead code and constants removed, and the ranked cost table."
          }
        },
        {
          "key": "lite9",
          "vars": {
            "key": "lite9",
            "idea": "Smallest CH that keeps its score: a 6-slot standalone YQ-lite lost 17.5 because it replaced the lambdaHat*sizeHat + actEma fee level. Keep that block, pHat with gate, sigmaHat, and the stale shift; then drop cumulatively, cheapest first, dir skew, tail compression, sigma*tox, TOX_QUAD, trade boost, keeping a drop only if it costs under 0.05 (n 1000, seeds 10000..10999). Deliver the smallest file within 0.1 of CH, with its slot count and constant count."
          }
        }
      ],
      "output": {
        "format": "json",
        "maxBytes": 64000
      }
    },
    {
      "name": "r3-m1",
      "mode": "research",
      "brief": "AMM fee challenge round 3 (measurement), item {{key}}: no new strategy, no tuning. TOOLCHAIN (~15 min, inside the checkout, never /tmp, no root; block only if a step fails, naming it and its error): clone github.com/benedictbrady/amm-challenge at 6b6921f8d463314aa7c96234e1be25a25245f704 into your workspace; mkdir -p scratch/tmp; export TMPDIR=$PWD/scratch/tmp; install uv (astral.sh/uv/install.sh, UV_INSTALL_DIR=$PWD/scratch/uv) and Rust (sh.rustup.rs, RUSTUP_HOME=$PWD/scratch/rustup CARGO_HOME=$PWD/scratch/cargo exported, -y --profile minimal; 'no /proc/self/exe' = block at once), both on PATH; if `cc --version` fails: curl -Ls micro.mamba.pm/api/micromamba/linux-64/latest | tar -xj -C scratch bin/micromamba; MAMBA_ROOT_PREFIX=$PWD/scratch/mamba scratch/bin/micromamba create -y -p $PWD/scratch/cenv -c conda-forge gcc; set CC and CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER to that gcc (fallback: uv pip install ziglang + a `cc` wrapper running `python -m ziglang cc \"$@\"`); uv venv; uv pip install -e . maturin; maturin develop --release --uv --manifest-path amm_sim_rs/Cargo.toml; SOLCX_BINARY_PATH unset or mkdir -p'd; amm-match validate contracts/src/StarterStrategy.sol. BEST = CH: https://raw.githubusercontent.com/ChengHua926/amm-challenge/d34a5199c59a4c44d5336a25f1436b4ae1f21104/contracts/src/Strategy.sol, sha256 6dd68f77a70900319460215374143dbd5d924198450a46d9f5f91f6b1e3d35c3 (verify, validate; YQ-family, slots 0-10 used, 11-31 free). TASK: {{idea}} Seeds: per-seed edges via amm_sim_rs.run_batch, configs as MatchRunner._build_configs (numpy default_rng(seed) draws size, rate, sigma; Rust seeds seed, seed+1); paired = same seeds, se = sd/sqrt(n). Chunk the runs; if one cannot finish in 40 minutes report the covered prefix and its n. RESULT (one JSON): task; files [{name, url, commit, sha256, validate_ok}]; runs [{file, seed_start, n, mean_edge, se, first10 edges to 6 decimals, worst 5}]; paired [{a, b, seed_start, n, mean_diff, se, worst 5}]; table (when asked); seconds_per_simulation; matches_expected; blocked (null or step + error); citations.",
      "items": [
        {
          "key": "ch-replicate",
          "vars": {
            "key": "ch-replicate",
            "idea": "Replicate promotion 2 on another machine. Fetch CH and YQ (https://raw.githubusercontent.com/jiayaoqijia/amm-challenge-yq/3e9dc7d5a6192c88b562a0f8d9c172ca566ec94d/contracts/src/Strategy.sol, sha256 00fae418c49cd681ad0879c6f96ebed0163fab5a660b38030f11e6947a39afd4), validate both. Run CH on seeds 0..999 (expected 525.525882178; first edges 478.313720, 598.726153, 412.970257), paired CH vs YQ on 400000..401999 (expected +0.962049503, se 0.021230303) and on 600000..601999 (fresh, n 2000). Say whether every expected number matches to 6 decimals, and give the fresh paired result."
          }
        },
        {
          "key": "ch-calib",
          "vars": {
            "key": "ch-calib",
            "idea": "Calibration score of the current best, report only. Run CH on seeds 900000..909999 (n 10000, in chunks, 40-minute cap: if cut, report the covered prefix and its n) with per-seed edges; report mean, se, first 10 edges to 6 decimals, 5 worst. YQ on the same set was 522.520303864629 (se 0.9170; first edges 442.453690, 367.758597, 554.500124): also run YQ on the covered prefix and give the paired CH-YQ mean_diff and se there."
          }
        },
        {
          "key": "ch-repo-scan",
          "vars": {
            "key": "ch-repo-scan",
            "idea": "Scan the ChengHua repository: every commit of https://github.com/ChengHua926/amm-challenge (28; hash, date, message), every strategy file and parameter set under contracts/ and scratch/ at the newest commit (e.g. scratch/results/*.json such as best_params_baseline.json), any score the author reports. Build each distinct variant (newest commit's Strategy.sol first, then param sets applied to CH), validate, measure each paired vs CH on seeds 600000..601999 (n 2000 if at most 4 variants, else n 500 each and n 2000 for the best). Table: commit, file, sha256, n, mean_diff, se; full code and delta of any that beats CH."
          }
        },
        {
          "key": "pub-scan",
          "vars": {
            "key": "pub-scan",
            "idea": "Find public strategies not yet measured: GitHub code search for 'AMMStrategyBase' and 'afterSwap', forks of benedictbrady/amm-challenge, repos named amm-challenge pushed since 2025-10, beyond jiayaoqijia, dipankar, ChengHua926, shl0k28, horacepan; include https://raw.githubusercontent.com/eliizabethzhang/market-making-challenge/7156ff039f0ecd9ad62328664d997a762cf02cf0/contracts/src/Strategy.sol (never measured). For each Strategy.sol: pin commit, sha256, validate, score seeds 0..199; measure the top 3 paired vs CH on 600000..601999 (n 2000). Table: repo, commit, sha256, author's claim, n, mean_diff, se; full code and delta of any that beats CH."
          }
        }
      ],
      "output": {
        "format": "json",
        "maxBytes": 64000
      }
    }
  ],
  "read": [
    "r3-d1/kalman-gate",
    "r3-d1/decay-cap",
    "r3-d1/alpha-grid",
    "r3-d1/gate-grid",
    "r3-d1/highfee",
    "r3-d2/tune-base",
    "r3-d2/tune-tox",
    "r3-d2/tune-stale",
    "r3-d2/tune-est",
    "r3-d2/cma-residual",
    "r3-d3/timing-terms",
    "r3-d3/sigma-elapsed",
    "r3-d3/fees-used",
    "r3-d3/combo-a",
    "r3-f1/norm-attract",
    "r3-f1/norm-phat",
    "r3-f1/post-arb-pair",
    "r3-f1/silence-clamp",
    "r3-f1/two-print",
    "r3-f2/th-killed",
    "r3-f2/th-pia",
    "r3-s1/ablate",
    "r3-s1/lite9",
    "r3-m1/ch-replicate",
    "r3-m1/ch-calib",
    "r3-m1/ch-repo-scan",
    "r3-m1/pub-scan",
    "r2b-a/tune-asym",
    "r2-fresh-a/arb-class",
    "r2-measure/pub-shl0k28"
  ],
  "cancel": [],
  "wake": {
    "batches": [
      "r3-d1",
      "r3-d2",
      "r3-d3",
      "r3-f1",
      "r3-f2",
      "r3-s1",
      "r3-m1"
    ],
    "afterMinutes": 300
  },
  "finish": false
}