Skip to content

Official Codebase of 3DCodeVerse

Python

argon variant v2: the scene loop accepts iteration 4 on the empty overlay

gaoypeng382d2644ef45
diff --git a/eval/bench/data/loop/argon_scene/ledger.jsonl b/eval/bench/data/loop/argon_scene/ledger.jsonl
new file mode 100644
index 00000000..da3a5d92
--- /dev/null
+++ b/eval/bench/data/loop/argon_scene/ledger.jsonl
@@ -0,0 +1,3 @@
+{"ts":"2026-10-15T14:51:19.135961+00:00","iteration":1,"languages":["scene_threejs","scene_blender"],"variant":"argon","version_from":1,"version_to":1,"variant_hash":"eab96d9b3360","battery_sha":"bfacb4b6924b","verdicts":{"scene_threejs":"inconclusive","scene_blender":"inconclusive"},"decision":"rollback","cost_usd":318.9451,"tree_commit":"af4d24ea683eb4891622021e8bbc9bc46e5b8e78","tree_dirty":true,"note":"inconclusive (threejs -0.112±0.168 n=14, blender -0.001±0.188 n=15; blender measured defects fell: interpenetration 0.43→0.13, must-missing 0.33→0.07; threejs lost two zones to build-time crashes and two runs failed at 0 rounds). Superseded by D106 de-templating: the Before-you-return block moves into the iteration-2 overlay."}
+{"ts":"2026-10-15T19:40:00.813912+00:00","iteration":3,"languages":["scene_threejs","scene_blender"],"variant":"argon","version_from":1,"version_to":1,"variant_hash":"eab96d9b3360","battery_sha":"e4110fd0cdf7","verdicts":{},"decision":"rollback","cost_usd":246.3576,"tree_commit":"6ab513f1a4400e1ddfab1e47b20e6ceda1cd8002","tree_dirty":true,"note":"it3 vs it2 (same judge): threejs -0.056±0.072, blender -0.013±0.206; driven by hung single-shot asset calls (ladder never passed its timeout: 3/15 threejs and 8/15 blender asset stages ran 32-71 min); runs with a normal asset stage: threejs -0.021, blender +0.071. Fixed in 6ab513f1."}
+{"ts":"2026-10-16T09:07:57.343206+00:00","iteration":4,"languages":["scene_threejs","scene_blender"],"variant":"argon","version_from":1,"version_to":2,"variant_hash":"b0efd44507da","battery_sha":"fe55d34261fb","verdicts":{},"decision":"accept","cost_usd":245.1626,"tree_commit":"01415794fe8f1ad03fe7f37ab68fdc04571ceaeb","tree_dirty":true,"note":"it4 vs it0 (same argon judge @medium, n=15): blender 0.755->0.832 +0.077±0.098 (9W/4L), threejs 0.792->0.785 -0.007±0.158; first run with the ladder timeout fix 6ab513f1 (asset stages <=30 min, were up to 71). Overlay empty since D106 (the it1 zone briefs withdrawn); the gain is harness code D106-D108."}
diff --git a/harness/codeverse3d/prompts/variants/argon/tracks/scene_zone.j2 b/harness/codeverse3d/prompts/variants/argon/tracks/scene_zone.j2
deleted file mode 100644
index d0a2092e..00000000
--- a/harness/codeverse3d/prompts/variants/argon/tracks/scene_zone.j2
+++ /dev/null
@@ -1,165 +0,0 @@
-# Zone `{{ zone_name }}` of `{{ title }}` — write `{{ zone_file }}`
-
-Scene: {{ spec_prompt }} · Setting: {{ setting }} · Mood: {{ mood }}
-
-## This zone
-- Description (the brief's facts in it are binding; its counts are the layout's intent, checked against the census): {{ zone_description }}
-- Bbox: {{ zone_bbox }} — the planned contents are measured against it and the plan bounds (a planned
- content entirely outside the bounds + max(5 m, 10 % of the span) is `out_of_bounds`, a WARN; scenery
- may continue past it as the place implies), and every placed root object is seated on the surface
- it stands on — terrain via `heightAt`, or a structure (a shelf, a roof, a deck). Deliberately
- airborne things carry `userData.placement = 'free'`.
-{% if interior %}- INTERIOR: the enclosure (walls, ceiling, roof) is `env.js`'s — do not build walls or a roof here.
- Fixtures on a wall sit flush against its inner face; a window or door is an OPENING env cuts, so
- glazing and door leaves go in the opening, not through the wall.
-{% endif %}- Contents (asset names to place): {{ zone_contents | join(', ') if zone_contents else '(none — build local detail from primitives)' }}
-- Every builder returns its asset AT THE SIZE the asset API states; place it at scale 1. The
- placement gate measures every placed thing as ONE object, parts included, against the plan's
- `approx_size_m`: a WARN beyond 2.5 × (or under 1 / 2.5), an ERROR beyond 4 × (`scale`), and the
- judge's `wrong_scale` on top (measured 2026-09-08, round 0: a 1.15 m stove placed at 3.60 m,
- 0.48 m oil lamps at 0.03 m — both cost the round; a stove whose flue was pulled up to the roof
- read as a 4.8 m stove — three runs lost their round to it). Never re-scale to "fit", never
- stretch a part of a placed clone; a chimney, pipe or cable that must reach further is a
- SEPARATE object you add beside it.
-
-{% if layout is defined and layout %}## Zone director's layout (the contents it names are measured as present; its positions and counts are the director's proposal in world metres — keep them unless the place reads better otherwise)
-{{ layout }}
-
-{% endif %}Neighbouring zones (their builders place there; a thing of yours running into a thing of theirs
-is an `interpenetration` row like any other):
-{% for n in neighbours %}- {{ n }}
-{% endfor %}
-{% if shared is not defined or shared %}
-Authored cameras that will photograph this scene — nothing this zone builds may sit inside or
-right against one (`scene_views` reports `camera_in_geometry`, the eye's clearance from every
-surface — ≥ 0.5 m — and `camera_blocked`: 6 of the 9 sight rays ending within 1.5 m); what, if
-anything, frames a shot is this zone's choice:
-{{ cameras }}
-
-## Assets available (sizes are measured, meters w×h×d)
-{{ asset_api }}
-
-Those paths are written relative to `src/`; **from `src/zones/` prefix them with `../`**
-(`import { buildStoneLantern } from '../assets/stone_lantern.js';`). The terrain comes from the
-environment (`ctx.heightAt`, or `import { heightAt } from '../env.js'`), and so does whatever else
-`env.js` chose to export (shared materials, a water level, a route — its names, read
-`src/env.js`). A GLB asset is already loaded for you at `ctx.assets['<snake_name>']` — add
-`.clone()` of it, never `loaders.gltf` again. A clone that carries clips (a keyframed Blender part) plays
-them by itself; set `clone.userData.clipOffset = <seconds>` to de-phase copies. There is no `ctx.rand` and no `ctx.MATS`.
-
-## Contract
-{{ frame_doc }}
-{{ contract }}
-
-### The harness assembles `src/scene.js` and calls YOUR module like this — nothing else runs
-```js
-const ctx = { THREE, scene, renderer, loaders, heightAt, env, assets };
-const g = await build(ctx); // the export MUST be named `build`, one argument
-scene.add(g); // g must be a THREE.Group / Object3D
-if (g.userData.update) g.userData.update(t, dt); // the ONLY animation hook that runs
-```
-So `{{ zone_file }}` exports `export function build(ctx) → THREE.Group` named `"{{ zone_name }}"`.
-`build{{ zone_name }}` and `userData.tick` are never called: if an asset carries its own
-`userData.update`, cache it at build time and call it from the zone's `userData.update`.
-`ctx` also gives you `ctx.env` (whatever `buildEnv` returned) and `ctx.heightAt`.
-
-## What is measured on this zone
-1. **The description's contents are present.** `check_placement` compares what is placed against
- the plan: a planned asset not placed is `missing_content`, an empty group is `zone_empty`, a zone
- under half the instances its layout counted gets an INFO `density_note`; the judge
- compares the frame against the description (`missing_planned_element`, `empty_zone`). Where
- the description gives no count, dress to what this setting would contain — the judge flags
- `undressed_scene` by perception, not by number. Place props where the setting puts them;
- regular arrangements only where the brief or setting implies them (a formal parterre, a row of
- parked scooters, a colonnade), otherwise expect the judge to read an unmotivated grid or ring
- as identical copies (`monotonous_vegetation`, `diorama_look`).
-2. **Repeated things read as individuals** where the setting has natural variety (judge:
- `monotonous_vegetation`, "identical copies", "primitive stacks"); the brief decides whether they
- grow in clusters, rows, an orchard or a canopy. The assets' `variant` / `seed` / `hue` options
- exist for this; several geometries plus scale / hue / yaw variation is one way.
-3. **Everything is seated.** `check_placement` reports a foot > 0.05 m above its surface
- (0.02 m indoors) as `floating` (ERROR at 0.08 m) and > 0.10 m below as `sunken` (ERROR at
- 0.20 m); two boxes sharing > 10 % of the smaller one as `interpenetration` (ERROR at 35 %).
- One placed thing = one direct child of the zone group: a Group holding several props is
- measured as ONE box, their union, and every prop inside it reads as interpenetrating it; a
- prop built from parts is one Group; many of one thing is one `InstancedMesh`. A scattered
- instance inside a placed thing is an interpenetration at 100 % of the smaller box — scatter
- clear of what you placed. A wide flat thing on a slope is measured at its lowest vertices
- against the ground under THEM: conform each piece to `heightAt` or split it. How a seam reads
- is the setting's call; the judge flags a visibly hovering base as `floating_asset` / `sunken_asset`
- and a ground feature that reads as a plate lying on the ground as `flat_ground`.
-4. **The cameras stay clear.** No authored camera may be inside or blocked by what this zone
- builds (`camera_in_geometry`, `camera_blocked`; both cap the run at 0.50); how you keep the
- near field clear is yours.
-5. **Motion that shows.** The harness differences the t = 0 and t = 1.5 s frames of every camera
- and reports the number: a camera moves when ≥ 0.4 % of its pixels change by more than 8/255
- (or ≥ 0.08 % by more than 60/255); no authored camera moving is `no_motion` (ERROR) and the
- judge's `nothing_moves` (−0.05 and the animation criterion). Sub-centimetre sway is invisible
- at 1024×576. What moves is the brief's; give this zone at least one motion big enough to see
- across the frame, everything a pure function of `t`, driven from `userData.update`. Particles
- must be soft-edged (judge `hard_edged_particles`: bare `PointsMaterial` squares, a chain of
- spheres for a steam jet, polygon sparks all fire it, and with it the brief's "soft particle
- effect" must-item) — the library's volumes or a radial-alpha sprite both pass.
-6. **Budget.** Stay inside the draw-call / triangle budget `scene_probe` reports (WARN above 5 000
- draws, ERROR above 15 000; 3 000 000 unique triangles); `InstancedMesh` / `mergeStatic` are the cheap
- ways to repeat.
-
-## Before you return — what the argon scenes of iteration 0 lost their points to
-Thirty argon three.js scenes were measured on 2026-10-15 (mean 0.76). Every point below is one
-tool call away and cost whole rounds:
-1. **Your LAST `check_placement` of this session shows 0 ERROR rows for this zone.** Every
- session ran the check; the rounds that still shipped 29 interpenetration + 9 sunken ERRORs
- edited again afterwards and never re-checked. Edit → `build` → `check_placement` → fix EVERY
- row it names (move the smaller thing until no pair shares more than the gate's 10 %; lower /
- raise by the stated metres) → `build` → `check_placement` again until clean → only then
- `scene_views`.
-2. **One placed thing = one direct child of the zone group.** A `…MidProps` / `…Dressing` /
- `SeamDressing` Group holding several props is measured as ONE asset whose box is their union,
- so every prop inside it reads as interpenetration (11 of 29 rows). Add each prop to the zone
- group itself; a prop built from parts is one Group; hundreds of one thing are one InstancedMesh.
-3. **Scatter clear of what you placed**: a scattered rock, fern or crate inside a placed table,
- rockery or tower is an interpenetration at 100 % of the smaller box — keep the boxes of the
- hand-placed things and skip the scatter points that fall inside them. A wide flat thing on a
- slope (a talus field, a stockpile conveyor) is `sunken` at its uphill end unless each piece
- follows `heightAt`.
-4. **Particles are soft or absent**: the library's volumes (`makeSmoke` / `makeSteam` /
- `makeMotes` / `makeFire`) or a radial-alpha sprite on every point. A bare `PointsMaterial`, a
- chain of spheres for a steam jet or polygon sparks is `hard_edged_particles` AND fails the
- brief's "soft particle effect" must-item — both fired together in 5 of 30 scenes.
-5. **A zone that throws at build time is DROPPED and scores nothing** — three runs lost 2-3
- zones each: `walk(fig, t)` runs ONLY inside `userData.update(t)` (a build-time `walk(fig)`
- throws `time must be finite`); import only names the effects catalog prints for a module
- (`concrete` is not in `lib/materials.js` — that SyntaxError dropped two zones); `mergeGeometries`
- returns null on mismatched attributes (check before `computeVertexNormals`); run `build` after
- your last edit and read its zone list.
-
-## DON'T
-- Sun, sky, ground and cameras are the env's. This zone may add the practical lights its setting
- contains (a lantern, a neon sign, a forge, a campfire), within the exposure band and the perf
- budget — a shadow-casting light per practical is the usual budget blow-out.
-- No DOM, {% if not (textures is defined and textures) %}no textures, {% endif %}no fetch, no Math.random (`mulberry32(seed)` from `lib/noise.js`).
-- Do not import assets marked NOT AVAILABLE; do not edit other files.
-
-{% if tool_cards and not single_shot %}
-
-## Tools
-{{ tool_cards }}
-After editing run `build` → `check_placement` (it names every asset that floats, is sunken,
-touches nothing or interpenetrates another, with the exact "lower X by 0.23 m onto Terrain"
-fix; a deliberately airborne thing gets `obj.userData.placement = 'free'`) → fix every row →
-`build` again, then `scene_views`: check that each authored frame shows what the description
-says, and read the MEASURED MOTION line it prints — if it reports your zone's cameras as
-STATIC, double the amplitude and render again.
-{% endif %}
-{% if effects_catalog is defined and effects_catalog %}
-
-{{ effects_catalog }}
-{% endif %}
-{% if textures is defined and textures %}
-
-{{ textures }}
-{% endif %}
-
-## Output
-{{ output_format }}
-{% endif %}
diff --git a/harness/codeverse3d/prompts/variants/argon/tracks/scene_zone_bpy.j2 b/harness/codeverse3d/prompts/variants/argon/tracks/scene_zone_bpy.j2
deleted file mode 100644
index dd57f1b6..00000000
--- a/harness/codeverse3d/prompts/variants/argon/tracks/scene_zone_bpy.j2
+++ /dev/null
@@ -1,160 +0,0 @@
-# Zone `{{ zone_name }}` of `{{ title }}` — write `{{ zone_file }}`
-
-Scene: {{ spec_prompt }} · Setting: {{ setting }} · Mood: {{ mood }}
-
-## This zone
-- Description (the brief's facts in it are binding; its counts are the layout's intent, checked against the placement census): {{ zone_description }}
-- Bbox (Z up, −Y front, metres — already converted from the plan): {{ zone_bbox }} — placed assets are
- measured against it and the plan bounds (a planned content entirely outside the bounds + max(5 m, 10 % of the
- span) is `out_of_bounds`, a WARN; scenery may continue past them as the place implies); seat each on
- the ground via `ctx.height_at(x, y)` or on the surface it stands on.
-{% if interior %}- INTERIOR: the shell (floor, walls, lid) is `env.py`'s; a partition, counter or alcove this zone needs
- is yours, seated and clear of the shell (placement gate). A window or door is an OPENING env cut:
- glazing and door leaves go in the opening, not through the wall.
-{% endif %}- Contents (asset names to place): {{ zone_contents | join(', ') if zone_contents else '(none — build local detail from bmesh)' }}
-- Every asset in `ctx.assets` is a Collection AT THE SIZE the asset API states and is measured as ONE
- object against the plan's `approx_size_m`: a WARN beyond 2.5 × (or under 1 / 2.5), an ERROR beyond 4 ×
- (`scale`), and the judge's `wrong_scale` on top (measured 2026-09-08, round 0: a 1.15 m stove placed at
- 3.60 m, 0.48 m oil lamps at 0.03 m — both cost the round). Never re-scale to fit or stretch a part of
- an instance; a chimney, pipe or cable that must reach further is a SEPARATE object you add beside it.
-
-{% if layout is defined and layout %}## Zone director's layout (the contents it names are measured as present; its positions and counts are the director's proposal, world metres (x, y) in THIS frame — keep them unless the place reads better otherwise)
-{{ layout }}
-
-{% endif %}Neighbouring zones (their builders place there; a thing of yours running into a thing of theirs is an
-`interpenetration` row like any other):
-{% for n in neighbours %}- {{ n }}
-{% endfor %}
-{% if shared is not defined or shared %}
-Authored cameras that will photograph this scene (Z up, metres; nothing may sit inside or within
-0.5 m of a lens — `scene_views` camera_checks, `camera_in_geometry` cap 0.50 — and no more than 5 of a
-camera's 9 sight rays may end within 1.5 m, `camera_blocked`, the same cap; the framing is this zone's
-choice):
-{{ cameras }}
-
-## Assets available (sizes are measured, metres)
-{{ asset_api }}
-
-Place one with `instance(ctx.collection, ctx.assets['<snake>'], unique_name('Name', i), x, y,
-height_at=ctx.height_at, rot_z=…)` from `lib/scatter.py` + `lib/place.py` (a collection-instance
-Empty seated on the ground = ONE placement row), or scatter many with `scatter(...)`, or build your
-own collection-instance Empties. Shared materials and the terrain come from the environment:
-`ctx.env[...]` (the keys `build_env` returned), `ctx.height_at`; zones may also `from env import …`
-whatever `env.py` defines at module level. A hero GLB is already imported for you as
-`ctx.assets['<snake>']` — instance it, never import a file. There is no `ctx.rand` and no
-`ctx.materials`; randomness is `rng = ctx.rng(<seed>)`.
-
-## Contract
-{{ frame_doc }}
-{{ contract }}
-
-### The harness assembles `{{ entry_file }}` and runs YOUR module like this — nothing else runs
-```python
-ctx.collection = <this zone's own Collection, active> # bpy.ops primitives land in it
-out = zones.<snake>.build(ctx) # the function MUST be named `build`, one argument
-# a raise = this zone DROPPED (file:line reported), everything it made removed; the rest builds
-```
-So `{{ zone_file }}` defines `def build(ctx) -> bpy.types.Collection` that links everything into
-`ctx.collection` and returns it. `build_{{ zone_name }}`, `main` and `register` are never called.
-Animation is DATA: keyframes on `ctx.frame(0.0)` / `ctx.frame(1.5)` and simple drivers of `frame`
-(`lib/motion.py`); there is no per-frame hook.
-
-## What this zone is graded on (the requirement, and how it is measured)
-1. **What the description names is here.** Counts the plan states are compared with the placement
- census (`missing_planned_element`, `empty_zone`), and a place that reads as sparse for what the brief
- describes is judged `undressed_scene`. Place props where the setting puts them; regular arrangements
- only where the brief implies them. `lib.scatter` offers `scatter`, `along_path`, `poisson`, `grid`
- if you want them.
-2. **Repeated natural elements read as individuals** from the cameras (judge `monotonous_vegetation`:
- one shape stamped many times, in a ring or a grid). The lib's `tree` kinds, `shrub`, `fern`,
- `boulder` seeds, `materials.tint` and per-instance rotation / scale are one way; regular things (a
- colonnade, a row of bollards) stay regular.
-3. **Seated, and clear of each other — measured.** Every placed root object rests on the surface it
- stands on (`lib.place.seat` / `rest_on`, or your own seating — the gate samples the foot columns):
- a foot 0.05 m up is `floating` (ERROR at 0.08 m), 0.10 m under is `sunken` (ERROR at 0.20 m), two
- boxes sharing > 10 % of the smaller one are `interpenetration` (ERROR at 35 %). Run
- `lib.place.clear_of(objs)` over your roots AND the neighbours' placed things before you finish.
- `obj["placement"] = "free"` only for things that hang in the air; the share of tagged things is
- reported. A built thing on soil must not read as pasted on (judge `flat_ground`: undressed seams):
- a few centimetres of sink (the gate allows up to 0.10 m) or dressing along the seam are options; a
- ground feature (a pond, a bed, a terrace) must not read as a plate on the terrain from the overview
- cameras — carving in `height_at` (the env's) or a built edge both work.
-4. **The cameras stay clear.** No authored camera may be inside or blocked by what this zone builds
- (`scene_views` camera_checks: nothing within 0.5 m of a lens, `camera_in_geometry`; 6 of 9 sight
- rays within 1.5 m, `camera_blocked` — each an ERROR capped at 0.50). `lib.place.clear_mask` / a
- poisson `mask` keeps scatter out of any region you choose. Framing is yours.
-5. **Motion that shows.** The harness DIFFERENCES the t=0 and t=1.5 frames per camera and reports the
- number: a camera moves when ≥ 0.4 % of its pixels change by more than 8/255 (or ≥ 0.08 % by more
- than 60/255); no authored camera moving is `no_motion` (ERROR), the judge's `nothing_moves`.
- Keyframes on `ctx.frame(0.0)` / `ctx.frame(1.5)` (LINEAR) or a simple driver of `frame`; what moves
- is the brief's (amplitudes that have registered at 1024 × 576: ≥ 0.10 rad, ≥ 0.05 m, a particle /
- leaf / boat ≥ 0.6 m per 1.5 s).
-6. **One root = one thing; names unique.** `check_placement` measures each root object in
- `ctx.collection` as one placed thing: a multi-part prop has one root (a mesh, a parent Empty, a
- collection instance) and every root a unique name (`unique_name(base, i)`). Stay inside the triangle
- budget `scene_probe` reports; collection instances and geometry-nodes clouds
- (`lib.vegetation.grass_patch`, `lib.scatter.gn_scatter`) are the cheap ways to repeat, and the lint
- warns on `bpy.ops.mesh.primitive_*` inside a loop.
-7. **A soft particle has no silhouette.** In Cycles only a volume renders without an edge
- (`lib.materials.volume`); a translucent surface puff, metaball, torus or disc is graded
- `hard_edged_particles` and fails the brief's must-item. It is one root tagged free, and it moves
- ≥ 0.6 m between the two frames.
-
-## Before you return — what the argon scenes of iteration 0 lost their points to
-Thirty argon Blender scenes were measured on 2026-10-15 (mean 0.75). Every point below is one
-tool call away and cost whole rounds:
-1. **Your LAST `check_placement` of this session shows 0 ERROR rows for this zone.** Every
- session ran the check; 13 of 30 picked rounds still shipped interpenetration ERRORs because the
- zone was edited again afterwards and never re-checked. Edit → `build` → `check_placement` →
- fix EVERY row it names (move the smaller thing until `clear_of` reports no pair over the gate's
- 10 %; lower / raise by the stated metres) → `build` → `check_placement` again until clean →
- only then `scene_views`.
-2. **Scatter clear of what you placed**: 9 of the 13 were small props scattered INTO a cart, a
- rack, a shrub or a salt mound (100 % of the smaller box). Place the big things first, keep every
- scatter point out of their footprints (`mask = clear_mask(placed_roots, margin=0.3)` from
- `lib.place` as the `poisson(..., mask=mask)` argument, or your own test), then
- `for a, b, frac in clear_of([*roots, *scattered]):` and move or delete the smaller offender
- (`bpy.data.objects.remove`) — the placement skill shows the loop.
-3. **A pit, a bank or a floor you carve in this zone is the ground for what stands in it**: seat
- those things on YOUR surface (`rest_on(obj, pit_floor)`), not on `ctx.height_at`, or the gate
- reads the sheaves 0.4 m sunk and the anchor plates 0.28 m floating (as in one iteration-0 run).
-4. **A soft particle has no silhouette**: in Cycles only a volume renders without an edge
- (`lib.materials.volume`; a cloud of `Batch` spheres wearing it is one root). Translucent
- Principled puffs, metaballs, tori and discs were `hard_edged_particles` in 8 of 30 scenes AND
- failed the brief's "soft particle effect" must-item every time. Tag the root
- `placement = "free"` and move it ≥ 0.6 m between the two frames.
-5. **A cross-zone overlap is an `interpenetration` row like any other**: two runs shipped one (a
- wind pump into a salt mound, a lane prop into a canopy frame). Run `clear_of` over your roots
- and the neighbours' placed things; the bbox is where the plan's contents are measured, not a
- fence.
-
-## DON'T
-- No world, no sun, no cameras, no ground here (the env's; the lint rejects a world in a zone); the local
- lights the brief's place has are yours.
-- No file IO, {% if not (textures is defined and textures) %}no image textures, {% endif %}no `random.*` (`ctx.rng(seed)`), no Python drivers, no `scene.*` settings.
-- Do not place assets marked NOT AVAILABLE; do not edit other files.
-
-{% if tool_cards and not single_shot %}
-
-## Tools
-{{ tool_cards }}
-After editing run `build` → `check_placement` (it names every asset that floats, is sunken, touches
-nothing or interpenetrates another, with the exact "lower X by 0.23 m onto Ground" fix; a
-deliberately airborne thing gets `obj["placement"] = "free"`) → fix → `build` again, then
-`scene_views` and LOOK at the frames against the brief, and read the MEASURED MOTION line it prints —
-STATIC means this zone's motion is below the threshold.
-{% endif %}
-{% if effects_catalog is defined and effects_catalog %}
-
-{{ effects_catalog }}
-{% endif %}
-{% if textures is defined and textures %}
-
-{{ textures }}
-(These are PNG files under `public/textures/`: load one with `bpy.data.images.load("public/textures/<file>",
-check_existing=True)` into an Image Texture node; the build runs with the workspace root as its working directory.)
-{% endif %}
-
-## Output
-{{ output_format }}
-{% endif %}
diff --git a/harness/codeverse3d/prompts/variants/argon/variant.toml b/harness/codeverse3d/prompts/variants/argon/variant.toml
index 6f1dfacb..9887b28f 100644
--- a/harness/codeverse3d/prompts/variants/argon/variant.toml
+++ b/harness/codeverse3d/prompts/variants/argon/variant.toml
@@ -6,22 +6,15 @@
# so iteration 0 of eval/bench/loop.py measures the base prompts under the variant plumbing;
# the loop writes files beside this one and bumps `version` on accept.
#
-# Iteration 1 (2026-10-15): tracks/scene_zone.j2 and tracks/scene_zone_bpy.j2 shadow the base zone
-# briefs with a "Before you return" block — the last check_placement must be clean, one placed thing
-# per zone child, scatter clear of placed roots (lib.place.clear_mask), volumes for particles, and
-# the three build-time crashes that dropped zones; skills/variants/argon/routes.toml boosts the Blender
-# placement skill to the top of the standing list (the three.js composition boost was withdrawn under
-# D106, 2026-10-15: that bundle carried the template every iteration-0 scene reproduced).
-#
# Selection is explicit, never a regex over the model id: `3dcode make --variant argon`,
# C3D_VARIANT=argon, or C3D_VARIANTS='{"agy:gemini-4-argon": "argon"}' (by the served model, so
# agy:gemini-4-argon-high maps too). `generators` below is informative.
[variant]
name = "argon"
-version = 1
+version = 2
generators = ["agy:gemini-4-argon"]
-description = "gemini-4-argon on the scene track (threejs + blender): zone briefs with the iteration-0 placement / particle / crash lessons, placement skills first"
+description = "gemini-4-argon on the scene track (threejs + blender)"
# [knobs] # optional; only Settings.skills_max / skills_only, applied like a profile
# skills_max = 4 # (a field the user stated in config.yaml / C3D_* wins)
diff --git a/harness/codeverse3d/skills/variants/argon/routes.toml b/harness/codeverse3d/skills/variants/argon/routes.toml
index cbce17a7..5904f754 100644
--- a/harness/codeverse3d/skills/variants/argon/routes.toml
+++ b/harness/codeverse3d/skills/variants/argon/routes.toml
@@ -1,5 +1,6 @@
-# The `argon` variant's routing table (D105). Parsed by codeverse3d/skills/__init__.py::parse_routes
-# with tomllib into typed rows (no regex); a row that does not type-check is rejected at attach time
+# The `argon` variant's routing table (D105, 2026-10-14) — EMPTY: iteration 0 of the loop
+# measures the base table. Parsed by codeverse3d/skills/__init__.py::parse_routes with tomllib
+# into typed rows (no regex); a row that does not type-check is rejected at attach time
# (logged, the base table routes) and refused by the tests. Three row kinds:
#
# [[boost]] # add `delta` to the priority of every route naming `skill`: a standing
@@ -17,18 +18,3 @@
# languages = ["scene_blender"]
# kinds = ["env", "zone", "refine"]
# why = "flat albedo is the audit's most-cited surface defect on argon zones"
-
-# Iteration 1 (2026-10-15): placement is the measured defect that capped the most iteration-0
-# rounds (threejs 7/30 interpenetration + 5/30 sunken; blender 13/30 + 5/30), and the Blender
-# skill that teaches it sat behind lighting / materials in the attached list. The boost puts it
-# FIRST in every standing zone / env / refine session (R29 80 -> 89; the gate-fired rows R30 / R34
-# already route at 95).
-#
-# The matching three.js boost (c3d-scene-composition +14) was withdrawn the same day: that bundle
-# carried the build order, the bounds-centre establishing formula and the ring arithmetic that all
-# 60 iteration-0 scenes reproduced, and putting it first in every session amplified the template.
-# It is now a sheet of measured requirements and routes at its base priority (R14 75); the
-# three.js placement findings reach the agent through the gate's own fix hints (R34 at 95).
-[[boost]]
-skill = "c3d-bpy-scene-placement"
-delta = 9
diff --git a/harness/tests/core/test_doctor.py b/harness/tests/core/test_doctor.py
index e827bdbd..fb93de00 100644
--- a/harness/tests/core/test_doctor.py
+++ b/harness/tests/core/test_doctor.py
@@ -128,4 +128,4 @@ def test_doctor_skills_reports_the_shipped_argon_overlay(monkeypatch):
get_settings.cache_clear()
assert rows["skills library"][0] == "OK"
status, detail = rows["skills overlay"]
- assert status == "OK" and detail.startswith("argon: 0 bundles, 0 invalid") and "1 boost(s)" in detail
+ assert status == "OK" and detail.startswith("argon: 0 bundles, 0 invalid")
diff --git a/harness/tests/flywheel_cli/test_cli.py b/harness/tests/flywheel_cli/test_cli.py
index d8a2fdf1..74736258 100644
--- a/harness/tests/flywheel_cli/test_cli.py
+++ b/harness/tests/flywheel_cli/test_cli.py
@@ -541,7 +541,7 @@ def test_make_freezes_the_variant_on_the_spec_and_refuses_an_unknown_one(tmp_pat
assert r.exit_code == 0, r.output
assert json.loads((runs / "v" / "spec.json").read_text())["options"]["variant"] == "argon"
out = " ".join(r.output.split())
- assert "variant" in out and "argon v1" in out and "via --variant" in out
+ assert "variant" in out and "argon v2" in out and "via --variant" in out
r = runner.invoke(app, ["make", "a clay pot", "--variant", "bogus", "--no-run", "--runs-dir", str(runs), "--slug", "b"])
assert r.exit_code == 2 and "unknown variant 'bogus'" in r.output and "argon" in r.output
diff --git a/harness/tests/prompts/test_variants.py b/harness/tests/prompts/test_variants.py
index 01ef305c..07da20b4 100644
--- a/harness/tests/prompts/test_variants.py
+++ b/harness/tests/prompts/test_variants.py
@@ -222,26 +222,21 @@ def test_variant_hash_covers_both_overlays_and_ignores_readmes(overlay, tmp_path
assert V.variant_block("gone") == {"name": "gone", "version": 0, "hash": ""}
-def test_the_argon_variant_ships_the_iteration_1_overlays():
- """Iteration 0 of the loop measured the base prompts under the plumbing (an empty overlay);
- iteration 1 (2026-10-15) shadows the two zone briefs and boosts the Blender placement skill (the
- three.js composition boost was withdrawn under D106: that bundle carried the template) — the
- whole overlay is these files, nothing else, and the hash covers them."""
+def test_the_argon_variant_ships_an_empty_overlay_at_version_2():
+ """Iteration 1 (2026-10-15) shadowed the two zone briefs and boosted the Blender placement skill;
+ D106 withdrew both (the briefs carried a template; the boost amplified it) and iterations 2-4 ran
+ on the EMPTY overlay — iteration 4 was accepted as v2 (2026-10-16, ledger argon_scene): the gain
+ was harness code (D106-D108), so the overlay ships only its README and variant.toml."""
from codeverse3d.skills import variant_dir, variants_table
info = variant_info("argon")
- assert info.name == "argon" and info.version == 1 and info.generators == ("agy:gemini-4-argon",) and info.knobs == {}
+ assert info.name == "argon" and info.version == 2 and info.generators == ("agy:gemini-4-argon",) and info.knobs == {}
assert info.description.startswith("gemini-4-argon on the scene track (threejs + blender)")
assert "argon" in list_variants()
- assert sorted(p.name for p in (VARIANTS_DIR / "argon").iterdir()) == ["README.md", "tracks", "variant.toml"]
- assert sorted(p.name for p in (VARIANTS_DIR / "argon" / "tracks").iterdir()) == ["scene_zone.j2", "scene_zone_bpy.j2"]
- for name in ("scene_zone.j2", "scene_zone_bpy.j2"):
- text = (VARIANTS_DIR / "argon" / "tracks" / name).read_text(encoding="utf-8")
- assert "## Before you return" in text and text.index("## Before you return") < text.index("## DON'T")
+ assert sorted(p.name for p in (VARIANTS_DIR / "argon").iterdir()) == ["README.md", "variant.toml"]
assert sorted(p.name for p in variant_dir("argon").iterdir()) == ["README.md", "routes.toml"]
table = variants_table("argon")
- assert not table.empty and table.variant == "argon" and not table.routes and not table.disabled
- assert {(b.skill, b.delta) for b in table.boosts} == {("c3d-bpy-scene-placement", 9)} # the composition boost was withdrawn (D106)
+ assert table.variant == "argon" and not table.routes and not table.disabled and not table.boosts
assert len(variant_hash("argon")) == 12
@@ -371,14 +366,14 @@ def test_a_run_records_the_variant_it_activated(tmp_path, monkeypatch):
rec, ws, _ = _run(tmp_path, monkeypatch, options=RunOptions(variant="argon"))
h = variant_hash("argon")
assert rec.environment["variant"] == "argon"
- assert rec.extra["variant"] == {"name": "argon", "version": 1, "hash": h}
+ assert rec.extra["variant"] == {"name": "argon", "version": 2, "hash": h}
assert rec.prompt_hashes["variant"] == h and "generate" in rec.prompt_hashes
snap = settings_snapshot(rec)
- assert (snap.variant, snap.variant_version, snap.variant_hash) == ("argon", 1, h)
+ assert (snap.variant, snap.variant_version, snap.variant_hash) == ("argon", 2, h)
events = _events(ws)
assert next(e for e in events if e["event"] == "run.start")["variant"] == "argon"
active = next(e for e in events if e["event"] == "variant.active")
- assert (active["name"], active["version"], active["hash"], active["knobs"]) == ("argon", 1, h, {})
+ assert (active["name"], active["version"], active["hash"], active["knobs"]) == ("argon", 2, h, {})
attached = [e for e in events if e["event"] == "skills.attached"]
assert attached and {e["variant"] for e in attached} == {"argon"}
rows = read_jsonl_lenient(ws.root / "telemetry" / "skills.jsonl")