Genesis: blind mode, a product domain, and eighteen defects a real run found

[Birfy]

Follow-up to #185, which merged. agentdescent/ is still untouched.

#185 shipped the port and measured it on four library domains with oracle or frozen-suite scoring. This PR is what a fifth domain — a product, grown by a third-party model through real Claude Code sessions — exposed. Most of the commits are defects a run found, each one costing a wrong number before it was understood, and each commit message carries the run that produced it.

1. Blind mode: the agents write the tests

The port had upstream's test relationship backwards. Here a human wrote the assertions and the failing source was pasted into the executor's prompt. Upstream's agents write their own tests — "tests are the definition of done" — and c-testsuite / LLVM / Csmith are the experimenter's external benchmark, applied afterwards.

So the acceptance suite now lives outside the repository (TestSuite.hidden) and the prompt on failure is the requirement text plus the assertion's name, never its source:

{requirement heading}

ACCEPTANCE: the trained animal turns toward the rewarded odour.

Two things a frozen suite cannot say are now enforced by own_review, inside the episode, by the parent:

• a child whose own tests fail has not finished, whatever the hidden suite thinks;
• a child that wrote an implementation file and no test anywhere under its node has not finished either.

own_test_failures runs those agent-written tests in one interpreter — the mix test upstream's manager actually runs.

2. fly: a Drosophila brain, three assays, and a page to watch it learn on

The fifth domain, and the first with no reference implementation and no hand-written tree. The repository starts with one frozen file, REQUIREMENTS.md, written in Chinese; everything else — the CONTEXT.md tree, the code, the tests, and fly.py itself — is grown.

The requirement is connectome-grounded rather than a toy: AL divisive normalisation (Olsen–Wilson 2010), ~5% KC sparse coding via APL, MB compartments with the γ1pedc/PPL1 and γ5β′2a/PAM pairs, depression-only plasticity with timing-dependent sign (Handler 2019), MBON→DAN feedback (Felsenberg 2018), lateral-horn innate valence, and a CX ring attractor (EPG wedges, PEN shift, Δ7 inhibition, PFL3→DNa02 steering).

fly.py deliberately is not frozen. #185's own deviation table called the frozen jqx entry point "a choice, and a defensible one" — not something upstream has. Upstream's contract is implicit in the objective: "build a C compiler" pins cc -o foo foo.c, which is why c-testsuite runs at all. "A fly simulator" pins nothing, so the calling convention has to be said — but it belongs to the requirement ("how I will invoke it"), not to the repository ("here is code for you"). It is now §4 of REQUIREMENTS.md, and the agents write the file.

3. Over-decomposition, and the threshold that fixed it

An architect given a product built 600 nodes at depth 8, 75% of them routers that forward and do nothing — apl, one neuron, was given two children.

The fix is a declaration, not a cap: the architect must state how many files each child holds, and a child of two files or fewer is not a directory. Trees then came out at 14–25 nodes and depth 3–5 — upstream's archive shows 26 nodes and observed depth 5 — and converged on their own, never reaching the node budget.

Three more Phase 1 defects, all found by watching a tree come out wrong:

symptom	cause
five brain regions silently vanished on resume	the routing table only dropped refused children, never added forgotten ones — and one node's table held API-Surface prose
an architect at …/cell_types/mushroom_body redesigned the whole library from the top	resume handed every child the parent's objective instead of its own routing line
every node cost a model call twice	parallelising the level re-asked inside _apply, and resume was decided after dispatch — spending the call it exists to save

Phase 1 now designs a level at a time over a state snapshot, and prints each node as it lands.

4. An executor session that can reach a third-party endpoint

--executor claude-code spawned the CLI with an inherited environment. Inside a managed Claude Code session that environment carries CLAUDE_CODE_REMOTE, which puts the CLI on the host's session ingress and makes it ignore the ANTHROPIC_BASE_URL and key it was handed. Every episode sent the host's token to a third-party endpoint and got 401: one run opened 28 sessions, failed 23, and wrote no files at all.

What the CLI reports for this is Authentication error · This may be a temporary network issue, please try again — neither — and the stderr beside it names an unrecognised model for query_source: generate_session_title, which is the session-title side query, not the agent turn, and prints identically on runs that work. I read that line as the cause and was wrong; bisection over the environment showed CLAUDE_CODE_REMOTE is the single switch.

cli_env drops those variables, but only when the run actually points somewhere else; a session on the host's own provider is untouched. The credential only ever travels from the environment into a child's env=.

Two smaller ones beside it: an executor session now runs the model the run asked for (it previously took the CLI's default unless --provider happened to be claude-cli, so a run could be on two models in silence), and --max-turns no longer overrides upstream's 2048-root / 128-child split with its own parser default.

5. Two ways a run reported success it had not earned

An empty suite is not a passing suite. own_test_failures returns [] when the repository holds no test files, which reads as "everything passes" — and that answer is the precondition for complete_task. A root agent used it: sixteen implementation files, zero tests, acceptance reward 0.000, and it claimed the objective delivered five times and was believed every time. That is backwards from the rule the same class already enforces on every child; require_tests applies it wherever the answer is a gate, and stays off where the question is really "did anything break".

A reasoning model's thinking is spent from --max-tokens too. The architect asked for a repository design and got 1708 characters of JSON that stopped mid-word. The run reported architect designed 0 nodes, 1 replies unusable and then grew an entire phase 2 with no tree at all — a shape that looks like a bad model or a parser bug and is neither. Measured on the architect prompt: 4096 emits ~15k output tokens across attempts in 148s and truncates about half the time; 16000 takes 264s and parses. Disabling thinking is the other lever and the worse one — it changes what the model produces, not only how much.

--max-tokens and --timeout are now declared and honoured in examples/_common.py, which is what that module exists for. They arrive together because raising one alone only moves the failure: the call that now fits takes 264s, and claude()'s 120s default would have timed it out three times over. Both are opt-in by naming a default — nine ports already declare --max-tokens themselves with numbers they measured (4096, 16000, 32000), so declaring it unconditionally is an argparse conflict that takes those entry points down at import. That is how I found them: six tests across porous, openevolve and metasearch, caught before this was pushed.

6. Session isolation: a session launched from a session is not that session

A session spawned from inside a Claude Code session inherits that session's equipment, and equipment is priced per turn whether or not it is reachable. Measured against one endpoint with the same one-line prompt: 31 850 input tokens plain, 31 099 with this port's own permission flags, 1 317 bare. The middle number is the mechanism — permission flags say what may be called, and every other schema is sent anyway. From the transcript's own snapshot the system prompt is 5 720 characters and the tool schemas are 178 742, of which Artifact alone is 64 168.

Identity leaked with it. Inherited, every session in a run is the host: one run's episodes each wrote a transcript named with the host's session id, and their TodoWrite state — keyed by that id — landed in the host's task list, two hundred entries of "Implement src/brain package". HOST_SESSION_VARS drops the identity variables and CLAUDE_CONFIG_DIR moves the whole CLI state directory out of ~/.claude.

--bare is what removes the schemas, and it has a trap: it also removes the Write tool, and --allowedTools cannot put it back (that flag is an auto-approve list, not a whitelist — a manager reached for Edit 41 times without it ever being listed). available_tools swaps Write for Edit, which creates files that do not exist.

The sandbox is the engine's own sandbox_container: docker/podman, read-only root, --cap-drop ALL, no network unless asked, one CLI home per container. It exists because the prompt is a rule and not a wall — four of twelve episodes in one run ran find / and read a previous run's output from /tmp, one of them opening the very _cli.py that answered the acceptance failure it had been asked to reproduce.

7. Four the throughput of a real run exposed

The file-count cap was eating whole episodes. SpatialContract caps a proposal at max_files_per_diff, and the cap rejects the diff, not the files over the line — so an episode one file past it contributes nothing. At 6, counting distinct paths written across 309 productive sessions, 11% of the episodes that did work lost all of it; the largest was carrying 23 files. Nothing said so: the two existing counters are about authority (wrote outside its subtree, mistook a file for a node) and neither moves for this, so a run that lost an eighth of its work and a run whose agents had nothing to say printed the same header. The drop is now counted (discarded_diffs=N (M files)), and the cap stops pretending to be a trust region — the trust region is the node's subtree, enforced edit by edit, and twelve files under one node are not more dangerous than six. For a session executor it is a runaway guard at 64; a single completion asked for whole files keeps 6, because there six really is one.

The blind failure read as an order at every node. It ended "write your own test that reproduces this, put it beside the code it covers, and make both pass". Every agent in a rollout is shown the same text, so at a leaf it reads as an instruction to fix the import here: eight different nodes each wrote their own _cli.py, 79 writes between them, src/brain/olfactory/_cli.py alone 21 times. Only the one at the repository root could ever have resolved it. The evidence now says it is the repository's, not necessarily yours — judge it against what you own, and name the path in the final message if the fix belongs elsewhere.

The growth phase printed nothing. Between Growing the world and the final summary the run was silent, and for a formation run that is hours. Finding out whether anything was being accepted meant reading CLI transcripts and looking inside live containers — and a live worktree holds the base state plus whatever the session has written since, which is not the accepted state, so readings drawn that way are wrong more often than not. evolve() already takes an on_round hook; the run now passes one and prints a line per merger sweep. RoundInfo.reasons goes on the end because committed=0 has two causes that need opposite fixes: the gate refused the work, or the work never reached the gate.

A rollout was an hour, and the workers spent it on the same tree. RecursiveDelegation.propose is a walk of the whole Context Tree with one Claude Code session per node, and it was a for loop. On an 8-node tree at five to fifteen minutes a session that is about an hour per rollout — py-spy on a live run showed all four workers still inside their first propose() after 75 minutes, three levels deep in nested _episode frames, with three files in the accepted state. That reads as an acceptance problem and is not one: the parent gate accepts a tie, four of the five reviews that had run said ACCEPT, and the staleness policy keeps a card whose reward is merely unchanged. Nothing was being rejected; nothing had finished. And --workers counts whole tree walks, so four workers were four independent descents of the same eight nodes — two of them on src/brain/navigation at the same moment, doing the same node's work, of which one result could survive.

Siblings now run concurrently and are folded in delegations order, so the proposal a rollout returns is unchanged. The spatial contract is what makes that safe rather than a merge problem: a child writes only under its own subtree, so two siblings cannot touch the same path. The knobs say which parallelism you are asking for:

flag	what it multiplies
--workers	whole tree walks at once (keep small; they duplicate each other)
--node-workers	siblings one manager runs at once
--max-sessions	hard bound on what the endpoint sees; defaults to their product

The bound lives in run_cli rather than in the thread pools: sessions are the scarce thing, a pool per level would multiply, and sessions never nest — a manager's own session runs before and after its children's, never during — so one semaphore there covers the whole tree with no way for a parent to deadlock on its own children. Every counter the port reports is now incremented under a lock; x += 1 is a read and a write with a bytecode boundary between them, and these numbers are the port's evidence.

8. What is not claimed

Runs died on endpoint problems rather than code, and every one of them first looked like a code bug:

symptom	actual cause
23/28 sessions failed, 0 edits	CLAUDE_CODE_REMOTE (§4)
258/276 sessions failed, 1293/2009 model calls failed	402 Insufficient Balance — the account ran out mid-run
10 nodes, 9 replies unusable	429 AccountQuotaExceeded — a 5-hour quota, except Exception counting it as a parse failure
the last run stopped after phase 2 began	78 × AccountQuotaExceeded against 53 × AccountRateLimitExceeded

So there is no end-to-end fly number in this PR, and none is claimed. The domain, the blind mode and every fix above are exercised by the offline tests; the product itself has not been grown to completion on a healthy endpoint.

What the last run did confirm before the quota ran out: the sibling parallelism (concurrency 1 → 6, six sessions on six distinct nodes, no two on the same node, the semaphore holding at its bound) and the isolation fix (4 868 input tokens on a first turn against 31 850 before it, session_context empty, no skill listing, agent listing or user identity in the prompt).

One question is deliberately left open: an earlier run reported claude code edits=298 but landed 37 files with truncated_edits=56, and an endpoint dying mid-run produces the same shape, so whether that gap is a real defect in the edit-collection path can only be judged on a run that stays healthy.

The md, minilang and stackvm numbers in #185 are unchanged by this PR.

Verification

pytest -q                                            # full suite green
python -m examples.genesis.genesis_recursive_worlds --domain fly --dry-run
python -m examples.genesis.genesis_recursive_worlds --domain fly --architect --complete-task \
    --executor claude-code --workers 1 --node-workers 6 --max-tokens 16000 --timeout 600 --model ...

tests/test_genesis_example.py covers blind mode, own_review, the file-count threshold, both routing-table directions, resume, cli_env, the empty-suite gate, the diff-cap discard and its counter, the growth-phase progress hook, sibling concurrency with an ordered fold, and the session bound. --dry-run crosses no boundary and the default run needs no key.

🤖 Generated with Claude Code

https://claude.ai/code/session_016CjFJhQ2Wxq9Vr3Fu38KrW

[chatgpt-codex-connector]

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.