{
 "notes": "EPISODE 3 (2026-11-10). 18 results read; 44 items used before this episode, 14 spawned now (58 of 240), 17 episodes left. Still running from earlier: b1-ideas/idea-twohyp, b1-fresh/fresh-1, b2-blend/blend-tune (asked for in read); a1-compress's four remaining items were cancelled (superseded by the qm ports below).\n\nTRACK A FINDINGS. (1) ENGINE PIPELINE TRUSTED: a2-engine-plain, all four items accepted, both arms on 12000000..12001023: P2 over IB pooled n 1024 mean_diff +2.2064 se 0.0497 (sum 2259.302724, sumsq 7576.407494; per item +2.263/+2.081/+2.134/+2.347). Prediction was +2.24 (replica +2.83 over HA minus 0.59), so the replica-to-engine rule holds within 0.04. ib_sum_check equal on the three ranges that had episode-1 IB rows. P2 gas on the engine: peak 179,316-193,866, mean 82,8xx; IB peak 234,958, mean 135,2xx. Expected board score of P2 = 524.2, just under 10th. (2) QM PORTS: both a2-port-qm copies complete:true. qm-2 (result sha f6f4c4cccbd3fd9b0d7a4c4c329011ba1c765a10cc192b1402434033bdd10402; NOTE its JSON is wrapped as {\"qm-2\": {...}}; code sha 988ef957e0f6633583384005936a94cee2816b8202feadbc2a633ee318e50c1c) is the one: s and c tables kept, 5 of 8 sd levels (0,4,12,20,34 bps), 33 w knots, 7 band + 41 rival cols, phase 2 shares phase 1 (free), 8-bit 1-bps residuals in 459 PUSH32 words; cost vs ref/gauss_qm.json -0.038 se 0.012 on 60000..61023; parity 6.8e-9 bps on 214,310 callbacks; peak 155,745 gas incl. intrinsic, mean 59,801; validate pass; stress 0 reverts; 23,729 runtime bytes (847 spare). qm-1 (sha ae6097410067e83beaf870a7f7399bba23ed7abccf8d5cc35a274f7ef7b3883a) dropped the synced flag: cost -0.11, peak 165k, 23,879 bytes; spare. Single-factor costs (1024 seeds): sd levels cost most (4 levels -0.038, 3 levels -0.098); s-only -0.021; 71 knots vs 33 -0.001. Lesson both copies hit: solc's constant optimizer turns repeated table words into a CODECOPY segment that validate flags; XOR-scramble bytes by position so every word is unique. Expected qm-2 on the engine: +3.77 - 0.04 - 0.59 = +3.14 over IB (score about 525.1, 7th-9th). (3) LATTICE IN-CONTRACT INFEASIBLE as ported (a2-latt-gas): exact latt.py port peak 518k at dt=1 (210k typical), +75-100k per silent step, dt=0 25k; coarser cells/truncated kernels cut 2-4x and break parity (5 bps cells 24 bps error); none under 170k. Suggested routes: SWAR packing, precomputed multi-step silent operators, quasi-stationary shape, or a parametric belief. (4) a1-compress/rivalmode: 13 uniform knots cost -0.27 on holdout; uniform knots lose, nonuniform (qm ports) win.\n\nTRACK B FINDINGS (all vs ref/lattice_qm.json on 10000..12047 unless said). blend-gauss (sha 4e88413335e28582aa9e96af6520c248a03c03f6944b561bdc7cf433460e2a97): branch-blend with sharpened weight pi^g, g=1.5, on the GAUSSIAN+qm policy = +0.319 se 0.011 vs ref/gauss_qm.json (tuning g: 1.0 +0.275, 1.5 +0.325, 2 +0.278, 8 +0.04; confirm +0.249); ambiguous callbacks 57% of all; est. +15-35k gas on those. FIRST B RESULT OVER THE 0.3 BAR: it goes into A's next port now. idea-posterior -2.87 (drop). idea-trained +0.023 (the filter is already calibrated on every feature tried; drop). revise-1 +0.079 se 0.023 on 256 holdout seeds (hindsight misread 16.1% -> 13.0% but forward value small; pi-blending branch-state fees was the only positive part; slow seat). fresh2-1 and fresh2-2 both chose finer lattices: +0.002 (drop; next fresh brief lists it as tried). ORACLE GAP (gap-1, 512 tuning seeds, perfect minus lattice = +4.42): true flag alone +2.715 (61%); true price given flag +1.483; rival+phase after flag+price +0.198; perfect tables vs qm +0.026. Flag inference is where the ceiling sits; price given flag second. With Gaussian+qm+blend the port tops out near +3.46 over IB (about 525.5, 7th-8th); first needs about +6.4 over IB, i.e. most of the flag gap.\n\nDECISIONS THIS EPISODE (14 items). Track A (11): a3-eng-qm2-a and a3-eng-qm2-b (4 items each, 256 fresh engine seeds each, qm-2 and IB both arms in the same item, 64-seed blocks, paired stats, gas, validate) on 12001024..12003071; a3-port-blend, 2 copies: qm-2 plus the g=1.5 branch blend in fixed point, Python reference first (cost vs gauss_qm on 60000..61023, expect about +0.28), full gate set; a3-latt-swar, 1 item: SWAR / precomputed silent operators / quasi-stationary lattice, feasible = peak <= 120k with <= 0.5 bps error on 99% of callbacks. Track B (3): b3-mix2 (two-Gaussian mixture belief: the lattice's bimodality at Gaussian gas, scored vs both refs), b3-blend-revise (branch-blend g + revise-1's open branches, one policy, vs lattice_qm), b3-fresh3 (one fresh idea, long do-not-repeat list).\n\nSEED LEDGER. Engine: 12000000..12001023 used (IB and P2); 12001024..12003071 assigned to a3-eng-qm2-a/-b (qm-2 and IB). Next free engine seed: 12003072. Replica: tuning 60000..60255, confirmation 60256..60511, port cost 60000..61023, diagnostics 60000..60511 and 61000..61255; holdout 10000..12047 once per idea.\n\nEPISODE 4 SHOULD: (1) Pool a3-eng-qm2-a/-b (n up to 2048): expect +3.14 +-0.15 over IB; if >= +2.7 the goal's bar is met on 2,048 seeds, so assign 12003072..12005119 to the same port (8 more items, two 4-item batches) to reach 4,096 seeds; if it is below +2.5 spawn a per-seed trace item (worst seeds, replica vs engine callbacks) before more engine work. (2) If an a3-port-blend copy is complete:true with cost >= +0.15 vs gauss_qm, it replaces qm-2 for every later engine item (fresh seeds only; never rerun a port on used seeds); if both failed on bytes, spawn a denser-encoding item (9-bit cells or a second XOR scheme) rather than dropping sd levels. (3) Track B: read idea-twohyp, fresh-1, blend-tune; anything >= +0.3 vs its ref goes into the next port; b3-mix2 >= +0.2 vs gauss_qm with a gas estimate under 100k means a port item; 0 to 0.3 gets one tuning item; drop the rest. If blend-tune beats g=1.5 by >= 0.1, pass its setting to the next port. (4) a3-latt-swar feasible means a lattice port item (2 copies) from qm-2 plus its filter; otherwise the lattice is closed for the contract. (5) Budget: 182 items after this episode; keep 12-18 per episode; from here engine confirmation of a passing port takes the largest share.\n\nWATCH FOR: the {\"qm-2\": {...}} wrapper in qm-2's result (briefs now say so); items that stall for whole episodes (a1-compress ran 2 episodes; cancel what a later result supersedes); results over 60,000 bytes (every brief caps its result and forbids tables in the tar); never write a platform condition in a brief; workers quoting command output in notes (briefs say numbers only).",
 "spawn": [
  {
   "name": "a3-eng-qm2-a",
   "brief": "Track A engine pairing: port Q2 and IB, each alone against VanillaStrategy, on engine seeds {{from}}..{{to}} (256 seeds, yours alone; use no seed outside this range; never fill a missing seed). Engine: git clone https://github.com/benedictbrady/amm-challenge and check out 6b6921f8d463314aa7c96234e1be25a25245f704; from the checkout root: mkdir -p scratch && curl -LsSf https://raw.githubusercontent.com/gtmcknight/amm-sim/main/research/setup.sh -o scratch/setup.sh && sh scratch/setup.sh; prefix later commands with `. scratch/env.sh && `; if a step fails, report blocked{step,error} and whatever you could still do. Contracts: IB = field code_zb64 (base64 of zlib of IB.sol, contract inputs_b) of https://api.imdnotdead.fun/artifacts/afd5183e9ff3235334e041c00b0cd19079599a2c6464db95f8c1586712105557. Q2 = https://api.imdnotdead.fun/artifacts/f6f4c4cccbd3fd9b0d7a4c4c329011ba1c765a10cc192b1402434033bdd10402: its JSON is {\"qm-2\": {...}}; inside that object code_zb64 is base64 of zlib of a tar holding the Solidity port (contract Strategy; its README names the file). Compile both unchanged with the engine's own compiler (amm_competition.evm.compiler.SolidityCompiler) and run amm-match validate on each. Configs: exactly MatchRunner._build_configs with the loop index replaced by the seed s: np.random.default_rng(seed=s), uniform draws in order retail_mean_size, retail_arrival_rate, gbm_sigma from BASELINE_VARIANCE, other fields from the base config, SimulationConfig(seed=s). Run amm_sim_rs.run_batch(strategy_bytecode, vanilla_bytecode, configs, 8) in four blocks of 64 seeds per arm (eight commands, none over 8 minutes); score = edges['submission']. Call gas_stats_reset() before each block and gas_stats() after it: peak and mean afterSwap over successful Submission afterSwap calls, oog and reverts over all Submission callbacks. Result JSON (under 40,000 bytes): key, seeds{from,to}, ib{n,sum,sumsq,rows:[[seed,score],...]}, port{n,sum,sumsq,rows}, paired{n,mean_diff,se,sum,sumsq,worst5:[[seed,diff],...]} with diff = port minus IB per seed and se = sd/sqrt(n), gas{ib{peak_afterswap,mean_afterswap,oog,reverts},port{same}}, validate{ib,port} as pass or fail, block_seconds, engine 'ok' or blocked{step,error}, notes under 1,200 characters (anything odd; numbers, never command output). Report only seeds that actually ran; a block that did not run stays missing and is named in notes.",
   "items": [
    {
     "key": "eng2-12001024",
     "vars": {
      "from": "12001024",
      "to": "12001279"
     }
    },
    {
     "key": "eng2-12001280",
     "vars": {
      "from": "12001280",
      "to": "12001535"
     }
    },
    {
     "key": "eng2-12001536",
     "vars": {
      "from": "12001536",
      "to": "12001791"
     }
    },
    {
     "key": "eng2-12001792",
     "vars": {
      "from": "12001792",
      "to": "12002047"
     }
    }
   ],
   "output": {
    "format": "json",
    "maxBytes": 48000
   }
  },
  {
   "name": "a3-eng-qm2-b",
   "brief": "Track A engine pairing: port Q2 and IB, each alone against VanillaStrategy, on engine seeds {{from}}..{{to}} (256 seeds, yours alone; use no seed outside this range; never fill a missing seed). Engine: git clone https://github.com/benedictbrady/amm-challenge and check out 6b6921f8d463314aa7c96234e1be25a25245f704; from the checkout root: mkdir -p scratch && curl -LsSf https://raw.githubusercontent.com/gtmcknight/amm-sim/main/research/setup.sh -o scratch/setup.sh && sh scratch/setup.sh; prefix later commands with `. scratch/env.sh && `; if a step fails, report blocked{step,error} and whatever you could still do. Contracts: IB = field code_zb64 (base64 of zlib of IB.sol, contract inputs_b) of https://api.imdnotdead.fun/artifacts/afd5183e9ff3235334e041c00b0cd19079599a2c6464db95f8c1586712105557. Q2 = https://api.imdnotdead.fun/artifacts/f6f4c4cccbd3fd9b0d7a4c4c329011ba1c765a10cc192b1402434033bdd10402: its JSON is {\"qm-2\": {...}}; inside that object code_zb64 is base64 of zlib of a tar holding the Solidity port (contract Strategy; its README names the file). Compile both unchanged with the engine's own compiler (amm_competition.evm.compiler.SolidityCompiler) and run amm-match validate on each. Configs: exactly MatchRunner._build_configs with the loop index replaced by the seed s: np.random.default_rng(seed=s), uniform draws in order retail_mean_size, retail_arrival_rate, gbm_sigma from BASELINE_VARIANCE, other fields from the base config, SimulationConfig(seed=s). Run amm_sim_rs.run_batch(strategy_bytecode, vanilla_bytecode, configs, 8) in four blocks of 64 seeds per arm (eight commands, none over 8 minutes); score = edges['submission']. Call gas_stats_reset() before each block and gas_stats() after it: peak and mean afterSwap over successful Submission afterSwap calls, oog and reverts over all Submission callbacks. Result JSON (under 40,000 bytes): key, seeds{from,to}, ib{n,sum,sumsq,rows:[[seed,score],...]}, port{n,sum,sumsq,rows}, paired{n,mean_diff,se,sum,sumsq,worst5:[[seed,diff],...]} with diff = port minus IB per seed and se = sd/sqrt(n), gas{ib{peak_afterswap,mean_afterswap,oog,reverts},port{same}}, validate{ib,port} as pass or fail, block_seconds, engine 'ok' or blocked{step,error}, notes under 1,200 characters (anything odd; numbers, never command output). Report only seeds that actually ran; a block that did not run stays missing and is named in notes.",
   "items": [
    {
     "key": "eng2-12002048",
     "vars": {
      "from": "12002048",
      "to": "12002303"
     }
    },
    {
     "key": "eng2-12002304",
     "vars": {
      "from": "12002304",
      "to": "12002559"
     }
    },
    {
     "key": "eng2-12002560",
     "vars": {
      "from": "12002560",
      "to": "12002815"
     }
    },
    {
     "key": "eng2-12002816",
     "vars": {
      "from": "12002816",
      "to": "12003071"
     }
    }
   ],
   "output": {
    "format": "json",
    "maxBytes": 48000
   }
  },
  {
   "name": "a3-port-blend",
   "brief": "Track A, the blend port, copy {{copy}} of 2 (the other copy does the same; do all of it yourself). Get the solved folder: B=https://raw.githubusercontent.com/gtmcknight/amm-sim/e65314f88de945f6d055bfc2aab01c482ab6570e/research/solved; curl -LsSf $B/fetch.sh -o fetch.sh && sh fetch.sh $B scratch/solved; read scratch/solved/README.md (its scripts run as python3 -I from that folder). Start from Q2, an accepted Solidity port of real.py soft=1 with compressed qm tables: https://api.imdnotdead.fun/artifacts/f6f4c4cccbd3fd9b0d7a4c4c329011ba1c765a10cc192b1402434033bdd10402 (JSON {\"qm-2\": {...}}; code_zb64 is base64 of zlib of a tar: contract, scripts, Python reference, README; parity 7e-9 bps, peak 155,745 gas, 23,729 bytes, cost -0.038 vs ref/gauss_qm.json). Add the branch blend from https://api.imdnotdead.fun/artifacts/4e88413335e28582aa9e96af6520c248a03c03f6944b561bdc7cf433460e2a97 (code_zb64 the same way; README gives the formulas): on an ambiguous first trade of a step quote the pi^g-weighted log-blend of the arb-branch and retail-branch quotes, g=1.5; in Python it scored +0.319 se 0.011 over gauss+qm on 10000..12047. Steps. 1. Write the Python reference of the new policy (Q2's compressed tables plus the blend) as a run.py module and measure it with pair.py against ref/gauss_qm.json on replica seeds 60000..61023 in 256-seed commands (expect about +0.28); report cost_paired{n,mean_diff,se,sum,sumsq,worst5}. 2. Port the blend into the contract in fixed point within every bound: solc 0.8.24 viaIR optimizer 200 evm paris, contract Strategy inheriting AMMStrategyBase, no inline assembly, no CODECOPY data segment (see Q2's README on the XOR fix), runtime <= 24,576 bytes, 32 storage slots; if bytes run short drop phase-0 band columns or rival columns before any sd level and measure the cost of what you dropped. 3. Gates: fee parity with your Python reference within 0.01 bps on every callback of replica seeds 10000..10019 (report callbacks, max_fee_diff_bps, over_0_01_bps); afterSwap peak <= 245,000 including the 21,000 intrinsic; 0 OutOfGas and 0 reverts over a 64-sequence stress run; amm-match validate pass (amm-challenge checkout at 6b6921f8d463314aa7c96234e1be25a25245f704, as Q2's README describes). Consume no engine seed. Result JSON (under 50,000 bytes): key, blend{g, where applied, fixed_point}, cost_paired, parity, gas{peak_afterswap,mean_afterswap,oog,reverts}, stress{sequences,reverts,peak_gas}, validate, bytes_runtime, dropped (what and its measured cost), complete (true only when every gate passed), code_zb64 (base64 of zlib of a tar: sources, scripts, Python reference, README; no JSON tables, no build outputs), code_sha256 (sha256 of the code_zb64 string), notes under 1,500 characters (no command output). If a gate fails, still send the code and say which gate.",
   "items": [
    {
     "key": "pb-1",
     "vars": {
      "copy": "1"
     }
    },
    {
     "key": "pb-2",
     "vars": {
      "copy": "2"
     }
    }
   ],
   "output": {
    "format": "json",
    "maxBytes": 60000
   }
  },
  {
   "name": "a3-latt-swar",
   "brief": "Track A feasibility, second pass: a lattice filter that fits the callback budget. Get the solved folder: B=https://raw.githubusercontent.com/gtmcknight/amm-sim/e65314f88de945f6d055bfc2aab01c482ab6570e/research/solved; curl -LsSf $B/fetch.sh -o fetch.sh && sh fetch.sh $B scratch/solved; read scratch/solved/README.md (its scripts run as python3 -I from that folder). The episode-2 item https://api.imdnotdead.fun/artifacts/1df8af4ba8f080458a601275e5026cc8a6e522784ed7ef42701da69ac2b86671 (code_zb64 is base64 of zlib of a tar; its variants list is in the JSON) ported latt.py exactly (121 cells of 2.5 bps, 33-tap kernel): dt=1 calls 210k gas typical and 518k peak, each silent step 75-100k more, dt=0 calls 25k; coarser cells and truncated kernels cut gas 2-4x and broke parity. Bound: a callback has 250,000 gas including the 21,000 intrinsic and the fee tables take about 60,000, so the filter has about 120,000 at its peak. Try in this order, measuring each on the same callbacks (replica seeds 10000..10004, latt.py with qm_k1e-5.json run blind, as that item did): (a) SWAR: pack four 64-bit cells in one word and convolve with one MUL per four cells, kernel exact; (b) precomputed silent-step operators: the k-step diffusion kernel for k = 1..12 as constants, applied once instead of k times; (c) a quasi-stationary shape: after the first silent step replace the convolution by a parametric spread and re-expand; (d) anything of your own. Feasible means peak <= 120,000 with mean price error <= 0.5 bps on 99 percent of callbacks. Solidity bounds: solc 0.8.24 viaIR optimizer 200 evm paris, no inline assembly, 32 storage slots in all. Consume no engine seed. Result JSON (under 40,000 bytes): key, variants[{name,desc,peak_gas,mean_gas,by_dt{1,2,3-5,6+},max_err_mean_bps,max_err_sd_bps,max_err_pi,share_mean_err_le_0_5bps,bytes_runtime,slots,reverts}], best, feasible, code_zb64 (base64 of zlib of a tar: sources and scripts, no tables), code_sha256 (sha256 of the code_zb64 string), notes under 1,500 characters (where the gas goes, what to try next; no command output).",
   "items": [
    {
     "key": "swar-1",
     "vars": {}
    }
   ],
   "output": {
    "format": "json",
    "maxBytes": 48000
   }
  },
  {
   "name": "b3-mix2",
   "brief": "Track B, one idea, measured alone: a two-component Gaussian mixture price belief. Get the solved folder: B=https://raw.githubusercontent.com/gtmcknight/amm-sim/e65314f88de945f6d055bfc2aab01c482ab6570e/research/solved; curl -LsSf $B/fetch.sh -o fetch.sh && sh fetch.sh $B scratch/solved; read scratch/solved/README.md (its scripts run as python3 -I from that folder). The lattice filter (latt.py with qm_k1e-5.json) beats the Gaussian filter (real.py) by about +0.5 over HA on 10000..12047 (ref/lattice_qm.json vs ref/gauss_qm.json), but the exact lattice costs 210k-518k gas a callback and cannot be ported; the Gaussian costs about 60k. Hypothesis: the lattice's value is the two-peaked belief after an ambiguous first trade of a step (arb branch: price pinned at the band edge; retail branch: price where it was). Build a filter that keeps two Gaussians (mean, variance, weight), one per branch, each updated as real.py updates its single Gaussian under that branch's hypothesis, the weights updated by each branch's likelihood of the later observations, collapsed to one Gaussian when a weight falls under a floor or the step closes. Quote from the mixture two ways and keep the better: a moment-matched single Gaussian, or the pi^1.5 log-blend of the two branch quotes from https://api.imdnotdead.fun/artifacts/4e88413335e28582aa9e96af6520c248a03c03f6944b561bdc7cf433460e2a97 (code_zb64 is base64 of zlib of a tar; its README gives the blend). Keep the tables and the flag classifier as real.py's. Rules: a policy sees afterSwap inputs only (run.py Blind); tune on replica seeds 60000..60255 (256-seed commands, PROCS=8), confirm the chosen setting once on 60256..60511, freeze the code, then score once on 10000..12047 in four 512-seed run.py commands and pair.py against BOTH ref/gauss_qm.json and ref/lattice_qm.json. The numba runner at https://api.imdnotdead.fun/artifacts/1134b0f83ff44cf484f8dc780a5c7f0e5d08d2cbbfad3d4ee2d3578ae6fa1ac6 (code_zb64 is base64 of zlib of a tar; fast_replica.py sits beside run.py) is bit-identical to the Python replica and about 100x faster; use it if it runs for you. Result JSON (under 30,000 bytes): key, idea (one sentence), settings_tried[{setting,n,mean_diff,se}], confirm_paired{n,mean_diff,se}, holdout_vs_gauss{n,mean_diff,se,sum,sumsq,worst5}, holdout_vs_lattice{same}, misread_rate{base,mine}, price_error_bps{base,mine}, gas_estimate{extra_slots,extra_exp_ln_sqrt_per_callback,rough_gas}, code_zb64 (base64 of zlib of a tar: module, scripts, README; no tables), code_sha256 (sha256 of the code_zb64 string), notes under 1,500 characters (what failed first, what to try next; no command output). Never fill a missing seed; report what ran.",
   "items": [
    {
     "key": "mix2-1",
     "vars": {}
    }
   ],
   "output": {
    "format": "json",
    "maxBytes": 40000
   }
  },
  {
   "name": "b3-blend-revise",
   "brief": "Track B, one idea, measured alone: the full two-branch quote on the lattice. Get the solved folder: B=https://raw.githubusercontent.com/gtmcknight/amm-sim/e65314f88de945f6d055bfc2aab01c482ab6570e/research/solved; curl -LsSf $B/fetch.sh -o fetch.sh && sh fetch.sh $B scratch/solved; read scratch/solved/README.md (its scripts run as python3 -I from that folder). Two findings each help a little and concern the same ambiguous first trade of a step. (1) branch-blend, https://api.imdnotdead.fun/artifacts/80b9f00d0d387deabd812da152d935cf049fa6654ae5e1cf43a30e16e7dd6830: quote the pi-weighted log-blend of the arb-branch and retail-branch quotes, +0.183 se 0.011 over ref/lattice_qm.json; on the Gaussian filter a sharpened weight pi^g with g=1.5 lifted it to +0.319 (https://api.imdnotdead.fun/artifacts/4e88413335e28582aa9e96af6520c248a03c03f6944b561bdc7cf433460e2a97). (2) revise-1, https://api.imdnotdead.fun/artifacts/9049572bfda37c44c7556f7e4eb508c335e4746db61af15a345e4791a09bb185: keep both branches' states (s2, synced, cnt/phase) and lattices open after an ambiguous trade, update the branch posterior at later callbacks of the step and at the next step's first trade, and pi-weight the fees of the two branch states: +0.079 se 0.023 on 256 holdout seeds. Each code_zb64 is base64 of zlib of a tar with a README. Build ONE policy: open branches as revise-1 does, quote the sharpened log-blend of the two branch quotes (each from its own branch state and branch lattice) with weight pi^g, and keep updating pi while the branches stay open. Tune g in {1, 1.5, 2} and the ambiguity window (0.05..0.95 or 0.02..0.98) on replica seeds 60000..60255 (256-seed commands, PROCS=8), confirm once on 60256..60511, freeze the code, then score once on 10000..12047 in four 512-seed run.py commands with pair.py against ref/lattice_qm.json. A policy sees afterSwap inputs only (run.py Blind). The numba runner at https://api.imdnotdead.fun/artifacts/1134b0f83ff44cf484f8dc780a5c7f0e5d08d2cbbfad3d4ee2d3578ae6fa1ac6 (code_zb64 is base64 of zlib of a tar; fast_replica.py sits beside run.py) is bit-identical to the Python replica and about 100x faster; use it if it runs for you. Result JSON (under 30,000 bytes): key, idea (one sentence), settings_tried[{setting,n,mean_diff,se}], confirm_paired{n,mean_diff,se}, holdout_paired{n,mean_diff,se,sum,sumsq,worst5}, misread_rate{base,mine}, price_error_bps{base,mine}, gas_estimate{extra_slots,extra_lookups_per_callback,rough_gas}, code_zb64 (base64 of zlib of a tar: module, scripts, README; no tables), code_sha256 (sha256 of the code_zb64 string), notes under 1,500 characters (what each part adds, what to try next; no command output). Never fill a missing seed; report what ran.",
   "items": [
    {
     "key": "br-1",
     "vars": {}
    }
   ],
   "output": {
    "format": "json",
    "maxBytes": 40000
   }
  },
  {
   "name": "b3-fresh3",
   "brief": "Track B: arb or retail, from the question alone. Get the solved folder: B=https://raw.githubusercontent.com/gtmcknight/amm-sim/e65314f88de945f6d055bfc2aab01c482ab6570e/research/solved; curl -LsSf $B/fetch.sh -o fetch.sh && sh fetch.sh $B scratch/solved; read scratch/solved/README.md (its scripts run as python3 -I from that folder). The lattice filter (latt.py with qm_k1e-5.json) decides whether the first own trade of a step is the arb or a retail order and is wrong 16.2 percent of the time; with the true flag the same tables score +2.72 more over 10000..12047 (61 percent of the whole gap to perfect information; the true price given the flag is the next +1.48). Misreads are small fills near the quote edge (25 percent misread in the smallest size quartile, 5 percent in the largest); the filter is already calibrated on fill size, timing, distance, side and the previous step's retail count (a trained logistic correction gained +0.02). Do not spend time on: the README's five ideas, DP_MASK quote zones, kappa, quote-aware fill likelihood, table classifiers, per-run parameter estimation, router evidence (+0.09), hindsight revision of the state (+0.08), finer lattices (0.00), posterior-value quote search (-2.9). What did help: quoting a pi-weighted log-blend of the arb-branch and retail-branch quotes on ambiguous trades (+0.18 on the lattice, +0.32 on the Gaussian). Think from the game: what else in the afterSwap stream separates the two hypotheses, what quote makes the next observation separate them, or what loss the quote should minimise under the posterior? Pick ONE idea of your own, state it in one sentence, implement it as a run.py module (a policy sees afterSwap inputs only, run.py Blind), tune on replica seeds 60000..60255 (256-seed commands, PROCS=8), confirm once on 60256..60511, freeze the code, score once on 10000..12047 in four 512-seed run.py commands with pair.py against ref/lattice_qm.json. The numba runner at https://api.imdnotdead.fun/artifacts/1134b0f83ff44cf484f8dc780a5c7f0e5d08d2cbbfad3d4ee2d3578ae6fa1ac6 (code_zb64 is base64 of zlib of a tar; fast_replica.py sits beside run.py) is bit-identical to the Python replica and about 100x faster; use it if it runs for you. Result JSON (under 30,000 bytes): key, idea, settings_tried[{setting,n,mean_diff,se}], confirm_paired{n,mean_diff,se}, holdout_paired{n,mean_diff,se,sum,sumsq,worst5}, misread_rate{base,mine}, price_error_bps{base,mine}, gas_estimate, code_zb64 (base64 of zlib of a tar: module, scripts, README; no tables), code_sha256 (sha256 of the code_zb64 string), notes under 1,500 characters (why it should work, what failed, what next; no command output). A clean negative result is accepted. Never fill a missing seed; report what ran.",
   "items": [
    {
     "key": "fresh3-1",
     "vars": {}
    }
   ],
   "output": {
    "format": "json",
    "maxBytes": 40000
   }
  }
 ],
 "read": [
  "b1-ideas/idea-twohyp",
  "b1-fresh/fresh-1",
  "b2-blend/blend-tune"
 ],
 "cancel": [
  "a1-compress"
 ],
 "wake": {
  "batches": [
   "a3-eng-qm2-a",
   "a3-eng-qm2-b",
   "a3-port-blend",
   "a3-latt-swar",
   "b3-mix2",
   "b3-blend-revise",
   "b3-fresh3"
  ],
  "afterMinutes": 240
 },
 "finish": false
}