Official Codebase of 3DCodeVerse
Python
D113: scene_blender raw mode — no harness modeling library; the argon_raw variant
gaoypengeefc50fa4780
diff --git a/harness/CLAUDE.md b/harness/CLAUDE.mdindex 9af12e14..f498a7b3 100644--- a/harness/CLAUDE.md+++ b/harness/CLAUDE.md@@ -94,6 +94,7 @@ cd harness# recipes, placeholder skeletons; a prompt / skill keeps only interface, sandbox rules and measured thresholds, each contract.md ONE# executable interface example (tests/prompts/test_snippets_run.py), the craft as short optional practices in the skills (fences ≤ ~12 lines).3dcodeverse make "..." --variant argon # per-model prompt/skill overlay: prompts/variants/<name>/ + skills/variants/<name>/ (D105; C3D_VARIANT, C3D_VARIANTS='{"agy:gemini-4-argon": "argon"}')+3dcodeverse make "..." --track scene --language scene_blender --variant argon_raw # RAW mode (D113): no src/lib ships, argon writes every line of bpy ([knobs] scene_lib = false; C3D_SCENE_LIB)3dcodeverse make "neon rain on a window" --track graphics --language glsl_shader3dcodeverse make "..." --image ref.png --candidates 3 --rounds 2 --dim height=0.45 --must "three legs" --texture --no-run3dcodeverse make "..." --no-pick # a run = baseline + --rounds refine rounds (fixed); make then picks a round → deliverable/ unless --no-pickdiff --git a/harness/codeverse3d/config.py b/harness/codeverse3d/config.pyindex a00a504f..20bc1218 100644--- a/harness/codeverse3d/config.py+++ b/harness/codeverse3d/config.py@@ -336,6 +336,11 @@ class Settings(BaseSettings):"prompt instead of editing it in context (docs/COST.md §30)")reference_diff: Flag = Field(default=True, description="the judge's reference-image mismatch pass")zone_layouts: Flag = Field(default=True, description="scene track: the L2 zone-layout planner calls")+ scene_lib: Flag = Field(default=True, description="scene_blender: ship the harness-owned bpy library "+ "(src/lib/*.py) into every workspace and let modules import it. OFF is RAW mode "+ "(D113): no library ships, `lib.*` imports are lint ERRORs and the model writes "+ "every mesh, material, light, world and motion in raw bpy / bmesh (variant "+ "argon_raw sets it through its [knobs])")scene_textures: Flag = Field(default=False, description="scene track: generate a texture pack before ""env/zones and describe it in both prompts. OFF: an image-model call per ""run, unmeasured — though 4 of 5 scored cells of scene_baseline "diff --git a/harness/codeverse3d/languages/scene_blender/__init__.py b/harness/codeverse3d/languages/scene_blender/__init__.pyindex a1873dbd..6770d6ad 100644--- a/harness/codeverse3d/languages/scene_blender/__init__.py+++ b/harness/codeverse3d/languages/scene_blender/__init__.py@@ -20,6 +20,7 @@ import jsonimport loggingimport mathimport re+import shutilimport timefrom collections.abc import Sequencefrom pathlib import Path@@ -152,6 +153,10 @@ ALLOWED_IMPORTS = frozenset({"dataclasses", "colorsys", "statistics", "operator", "enum", "copy", "__future__", "bpy_extras","env", "zones", "assets", "lib", # the workspace's own packages (src/ is on sys.path)})+#: the package the harness library is imported as: allowed only while ``Settings.scene_lib`` ships it+LIB_PACKAGE = "lib"+#: raw mode (D113, ``scene_lib`` off): no ``src/lib`` ships, so ``lib`` is not a workspace package+RAW_ALLOWED_IMPORTS = ALLOWED_IMPORTS - {LIB_PACKAGE}#: the object track's floor + everything that reads a clock or the file system: a scene is#: deterministic by construction and the harness owns every fileFORBIDDEN_IMPORTS = frozenset(BASE_FORBIDDEN_IMPORTS | {"os", "sys", "pathlib", "time", "datetime", "tempfile",@@ -291,18 +296,24 @@ def _regate(findings: list[GateFinding], target: str) -> list[GateFinding]:return out-def _policy(c: BpyCollector, facts: _SceneFacts, *, target: str, role: str) -> list[GateFinding]:+def _policy(c: BpyCollector, facts: _SceneFacts, *, target: str, role: str, lib: bool = True) -> list[GateFinding]:out: list[GateFinding] = []E, W = Severity.ERROR, Severity.WARNdef _import_finding(kind: str, mod: str, line: int) -> GateFinding:+ if mod == LIB_PACKAGE and not lib:+ return _f(LintKind.BAD_IMPORT, E, f"`{mod}`: no harness library ships in raw mode (scene_lib off) — "+ "the import fails in the build", line,+ "write it in raw bpy / bmesh / mathutils; code several zones share goes in src/env.py "+ "(`from env import ...`); an asset module is self-contained", target)if kind == "forbidden":return _f(LintKind.FORBIDDEN_IMPORT, E, f"forbidden import `{mod}`", line,"a scene uses bpy / bmesh / mathutils / math / numpy and ctx.rng(seed); no clock, no files", target)return _f(LintKind.BAD_IMPORT, W, f"unexpected import `{mod}` (not available in the build)", line,"use bpy, bmesh, mathutils, math, numpy and your own src/ modules", target)- out.extend(check_imports(c.imports, forbidden=FORBIDDEN_IMPORTS, allowed=ALLOWED_IMPORTS, make_finding=_import_finding))+ out.extend(check_imports(c.imports, forbidden=FORBIDDEN_IMPORTS, allowed=ALLOWED_IMPORTS if lib else RAW_ALLOWED_IMPORTS,+ make_finding=_import_finding))for name, call in c.calls:for prefix, sev, kind, msg, hint in CALL_POLICY:if name.startswith(prefix):@@ -352,8 +363,9 @@ def _policy(c: BpyCollector, facts: _SceneFacts, *, target: str, role: str) -> lreturn out-def lint_scene_source(source: str, *, target: str, role: str) -> list[GateFinding]:- """Lint one scene module; ``role`` is ``entry`` / ``env`` / ``zone`` / ``asset`` / ``helper``."""+def lint_scene_source(source: str, *, target: str, role: str, lib: bool = True) -> list[GateFinding]:+ """Lint one scene module; ``role`` is ``entry`` / ``env`` / ``zone`` / ``asset`` / ``helper``; ``lib``+ False is raw mode (D113): an import of the harness library is an ERROR."""tree, exc = safe_parse(source, target)if tree is None:msg, hint, line = describe_parse_failure(exc) # type: ignore[arg-type]@@ -362,7 +374,7 @@ def lint_scene_source(source: str, *, target: str, role: str) -> list[GateFindinc.visit(tree)facts = _SceneFacts()facts.visit(tree)- out = _policy(c, facts, target=target, role=role)+ out = _policy(c, facts, target=target, role=role, lib=lib)out.extend(_regate(source_traps(c, source), target))out.extend(_exports(tree, target=target, role=role))return out@@ -396,8 +408,10 @@ def _role(ws: Workspace, p: Path) -> str:return "helper"-def lint(ws: Workspace) -> GateReport:- """Every ``src/**.py`` except the harness's own library (``src/lib/``, syntax only); passed iff no ERROR."""+def lint(ws: Workspace, *, lib: bool = True) -> GateReport:+ """Every ``src/**.py`` except the harness's own library (``src/lib/``, syntax only); passed iff no ERROR.+ ``lib`` False is raw mode (D113): ``lib`` is no workspace package (a write under ``src/lib/`` is still+ reverted, ``HARNESS_OWNED_SRC``)."""t0 = time.monotonic()findings: list[GateFinding] = []if not (ws.root / ENTRY_REL).is_file():@@ -416,7 +430,7 @@ def lint(ws: Workspace) -> GateReport:if role in ("zone", "asset") and p.stem != to_snake(p.stem):findings.append(_f(LintKind.NAMING, Severity.ERROR, f"module name '{p.name}' is not snake_case", None,f"rename it to {to_snake(p.stem)}.py", rel))- findings.extend(lint_scene_source(source, target=rel, role=role))+ findings.extend(lint_scene_source(source, target=rel, role=role, lib=lib))return GateReport.of(GATE, findings, duration_ms=int((time.monotonic() - t0) * 1000))@@ -496,12 +510,16 @@ def _write_lib(ws: Workspace, written: list[Path]) -> None:_put(ws.src / "lib" / src.name, src.read_text(), written)-def write_example(ws: Workspace) -> list[Path]:+def write_example(ws: Workspace, *, lib: bool = True) -> list[Path]:"""The complete plan-less starter scene (``starter/src/**/*.py``: entry, env, zones, assetsand the library) into ``ws.src`` — scene_threejs's ``write_example`` twin. Raises when thestarter tree is missing: an rglob over an absent directory writes nothing and reportssuccess, which is how a wheel without package data once shipped empty scenes- (tests/core/test_portability.py)."""+ (tests/core/test_portability.py). Raises in raw mode (``lib`` False, D113) too: the example+ is built on the library, and a raw run starts from a plan's stubs."""+ if not lib:+ raise ValueError("scene_blender raw mode (scene_lib off) needs a plan: the plan-less example scene is "+ "built on the harness library (src/lib), which raw mode does not ship")if not STARTER_DIR.is_dir():raise FileNotFoundError(f"scene_blender starter tree missing: {STARTER_DIR} — this install has no package data "@@ -528,7 +546,37 @@ def _v(v: Sequence[float], *, extents: bool = False) -> tuple[float, float, floaPLACEHOLDER_GROUND_SPANS = 3.0-def _env_source(plan: ScenePlan) -> str:+#: what the env placeholder says of the toolbox, imports, and builds its plate with: (library, raw — D113).+#: Raw: the same plate in plain bpy / bmesh (GroundMat at the library's "6F6A60", linear), no library named.+_ENV_TOOLBOX = (+ """ builds the brief's. The landform, the sky, the light and the atmosphere are yours. Raw bpy / bmesh is the+ baseline; src/lib (terrain / sky / lighting / materials / architecture / water ... — the effects catalog) is+ an OPTIONAL toolbox. Keep build_env and height_at.""",+ """ builds the brief's. The landform, the sky, the light and the atmosphere are yours, in raw bpy / bmesh:+ no harness library ships in this workspace. Keep build_env and height_at.""")+_ENV_IMPORTS = ("from lib import materials, terrain # the optional toolbox (the placeholder uses two of its calls)",+ "import bmesh\nimport bpy")+_ENV_ROOM_NOTE = ("# named; it reads black without openings or practical lights); lib.architecture.room_shell is one way",+ "# named; it reads black without openings or practical lights)")+_ENV_PLATE = (+ """ ground_mat = materials.material("GroundMat", "6F6A60", roughness=0.95)+ terrain.ground("Ground", ctx.collection, size=GROUND_SIZE, segments=32, height_at=height_at, material=ground_mat)""",+ """ ground_mat = bpy.data.materials.new("GroundMat")+ bsdf = ground_mat.node_tree.nodes["Principled BSDF"]+ bsdf.inputs["Base Color"].default_value = (0.159, 0.144, 0.117, 1.0)+ bsdf.inputs["Roughness"].default_value = 0.95+ bm = bmesh.new()+ bmesh.ops.create_grid(bm, x_segments=32, y_segments=32, size=GROUND_SIZE / 2)+ for v in bm.verts:+ v.co.z = height_at(v.co.x, v.co.y)+ me = bpy.data.meshes.new("Ground")+ bm.to_mesh(me)+ bm.free()+ me.materials.append(ground_mat)+ ctx.collection.objects.link(bpy.data.objects.new("Ground", me))""")+++def _env_source(plan: ScenePlan, *, lib: bool = True) -> str:"""``src/env.py`` as an interface stub: the plan's data (bounds, interior, glazed, the sun theplan states), the two exports the wrapper calls, and a PLACEHOLDER body that builds ONE thing —a level plate named Ground past the plan span — and no world, no lamp, no atmosphere: as@@ -537,9 +585,12 @@ def _env_source(plan: ScenePlan) -> str:bounds' half-span + 15 m, fbm hills beyond, a mossy ground, a fog box, a room shell with oneceiling light): 30 of 30 iteration-0 scenes kept its shape; then a passing placeholder (aneutral sun at 45° / 35°, a haze) that any brief could keep for the same reason (the- de-templating of 2026-10-15)."""+ de-templating of 2026-10-15). ``lib`` False (raw mode, D113): the same plate in raw bpy / bmesh and+ no word of the library."""from codeverse3d.languages.scene_threejs import sun_from_plan+ k = 0 if lib else 1+c, e = _v(plan.bounds.center), _v(plan.bounds.extents, extents=True)span = max(e[0], e[1], 1.0)ground = round(span * PLACEHOLDER_GROUND_SPANS, 1)@@ -572,15 +623,13 @@ MEASURED: a world exists and an atmosphere exists — a world Volume or a boundeedge in any authored frame (judged; the census: standing geometry past 1.25 x the bounds' half-extent).PLACEHOLDER below: ONE level plate named Ground past the plan span, so the census has a surface — and NOworld, NO lamp, NO atmosphere: as written this module fails the probe and renders black until build_env- builds the brief's. The landform, the sky, the light and the atmosphere are yours. Raw bpy / bmesh is the- baseline; src/lib (terrain / sky / lighting / materials / architecture / water ... — the effects catalog) is- an OPTIONAL toolbox. Keep build_env and height_at.+{_ENV_TOOLBOX[k]}"""-from lib import materials, terrain # the optional toolbox (the placeholder uses two of its calls)+{_ENV_IMPORTS[k]}BOUNDS = {{"center": ({fmt3(c)}), "extents": ({fmt3(e)})}}INTERIOR = {interior} # the plan's: an interior needs the enclosure the brief describes (openings, materials as- # named; it reads black without openings or practical lights); lib.architecture.room_shell is one way+ {_ENV_ROOM_NOTE[k]}GLAZED = {glazed} # the plan says the enclosure is glazed; its construction is the brief'sGROUND_SIZE = {ground} # the placeholder plate's side (m): 3 x the plan span, past the reach the fog gate measures{az_line}@@ -595,14 +644,53 @@ def height_at(x, y):def build_env(ctx):# PLACEHOLDER ground: a level plate following height_at — REPLACE with the brief's land (named Ground... / Terrain...)- ground_mat = materials.material("GroundMat", "6F6A60", roughness=0.95)- terrain.ground("Ground", ctx.collection, size=GROUND_SIZE, segments=32, height_at=height_at, material=ground_mat)+{_ENV_PLATE[k]}# NO world, lamp or atmosphere here: the brief's go in this function (the docstring says what is measured)return {{"ground_material": ground_mat}}'''-def _asset_source(a: AssetPlan) -> str:+#: the asset placeholder's imports and blockout: (library, raw — D113); ``str.format`` fields+_ASSET_BODY = (+ """from lib.materials import material # optional toolbox: the placeholder uses it+from lib.mesh import Batch # optional: one way to build multi-material parts (raw bmesh is equally fine)+++def build_{snake}(ctx, variant=0):+ mat = material("{pascal}Mat", ({rgb}), roughness={rough}, metal={metal})+ # PLACEHOLDER blockout at the planned size — REPLACE with the real thing (a single box fails the asset check);+ # base on z = 0, front facing -Y.+ b = Batch("{pascal}")+ b.box(mat, (0.0, 0.0, {h2}), ({w}, {d}, {h}))+ b.finish(ctx.collection, parent=False)+ return ctx.collection+""",+ """import bmesh+import bpy+++def build_{snake}(ctx, variant=0):+ mat = bpy.data.materials.new("{pascal}Mat")+ bsdf = mat.node_tree.nodes["Principled BSDF"]+ bsdf.inputs["Base Color"].default_value = ({rgb}, 1.0)+ bsdf.inputs["Roughness"].default_value = {rough}+ bsdf.inputs["Metallic"].default_value = {metal}+ # PLACEHOLDER blockout at the planned size — REPLACE with the real thing (a single box fails the asset check);+ # base on z = 0, front facing -Y.+ bm = bmesh.new()+ bmesh.ops.create_cube(bm, size=1.0)+ bmesh.ops.scale(bm, vec=({w}, {d}, {h}), verts=bm.verts)+ bmesh.ops.translate(bm, vec=(0.0, 0.0, {h2}), verts=bm.verts)+ me = bpy.data.meshes.new("{pascal}")+ bm.to_mesh(me)+ bm.free()+ me.materials.append(mat)+ ctx.collection.objects.link(bpy.data.objects.new("{pascal}", me))+ return ctx.collection+""")+++def _asset_source(a: AssetPlan, *, lib: bool = True) -> str:snake, pascal = to_snake(a.name), to_pascal(a.name)w, h, d = (max(0.05, float(v)) for v in a.approx_size_m) # plan order: width, height, depthrgb, rough, metal = finish_for(a.description)@@ -615,22 +703,21 @@ CONTRACT: build_{snake}(ctx, variant=0) -> bpy.types.Collection — link every pdescribes it at the judge's camera distance (judged) and measure about the size above (the asset check);parts, materials and construction are yours."""-from lib.materials import material # optional toolbox: the placeholder uses it-from lib.mesh import Batch # optional: one way to build multi-material parts (raw bmesh is equally fine)+{_ASSET_BODY[0 if lib else 1].format(snake=snake, pascal=pascal, rgb=fmt3(rgb), rough=rough, metal=metal,+ w=f"{w:g}", d=f"{d:g}", h=f"{h:g}", h2=f"{h / 2:g}")}'''-def build_{snake}(ctx, variant=0):- mat = material("{pascal}Mat", ({fmt3(rgb)}), roughness={rough}, metal={metal})- # PLACEHOLDER blockout at the planned size — REPLACE with the real thing (a single box fails the asset check);- # base on z = 0, front facing -Y.- b = Batch("{pascal}")- b.box(mat, (0.0, 0.0, {h / 2:g}), ({w:g}, {d:g}, {h:g}))- b.finish(ctx.collection, parent=False)- return ctx.collection-'''+#: the zone stub's line on assets and motion: (library, raw — D113)+_ZONE_TOOLS = (+ """ Assets: ctx.assets['<snake>'] is a Collection — place collection-instance Empties of it (lib.scatter.instance+ seats one on ctx.height_at; one way among others). Animation: keyframes or simple drivers (the build samples+ frames 1 and 46 = t 0 / 1.5 s; motion between them is measured); lib.motion is an optional helper.""",+ """ Assets: ctx.assets['<snake>'] is a Collection — place collection-instance Empties of it (instance_type+ 'COLLECTION', seated on ctx.height_at). Animation: keyframes or simple drivers (the build samples frames 1 and+ 46 = t 0 / 1.5 s; motion between them is measured).""")-def _zone_source(z: ZonePlan, assets: dict[str, AssetPlan]) -> str:+def _zone_source(z: ZonePlan, assets: dict[str, AssetPlan], *, lib: bool = True) -> str:"""The zone's interface and a TODO naming the plan's contents — no positions. The stub used totile the contents on a quarter-extent grid inside the bbox and say "keep them inside the bbox":the seed of the blocks-in-a-rectangle look (the de-templating of 2026-10-15)."""@@ -655,9 +742,7 @@ CONTRACT: build(ctx) -> bpy.types.Collection — ctx.collection is this zone's ((measured: scene_placement floating > 0.05 m outdoors / 0.02 m indoors, sunken > 0.10 m). The plannedcontents are measured against the plan bounds and this bbox (scene_placement: present, at the plan's size,not outside the bounds); scenery may continue past the bbox as the brief implies.- Assets: ctx.assets['<snake>'] is a Collection — place collection-instance Empties of it (lib.scatter.instance- seats one on ctx.height_at; one way among others). Animation: keyframes or simple drivers (the build samples- frames 1 and 46 = t 0 / 1.5 s; motion between them is measured); lib.motion is an optional helper.+{_ZONE_TOOLS[0 if lib else 1]}TODO — this zone's planned contents, none placed yet:{todo_block}"""@@ -699,23 +784,27 @@ CAMERAS = ['''-def write_skeleton(ws: Workspace, plan: Plan | None = None) -> list[Path]:+def write_skeleton(ws: Workspace, plan: Plan | None = None, *, lib: bool = True) -> list[Path]:"""Starter files for a scene plan (the library, env, one module per zone and per proceduralasset, the assembled entry); ``public/assets/`` for the heroes. Without a plan the complete- example scene is the skeleton (``write_example``)."""+ example scene is the skeleton (``write_example``). ``lib`` False is raw mode (D113): no+ ``src/lib/``, and stubs that import and name nothing of it."""if plan is None:- return write_example(ws)+ return write_example(ws, lib=lib)if not isinstance(plan, ScenePlan):raise TypeError(f"scene_blender needs a ScenePlan, got {type(plan).__name__}")written: list[Path] = []- _write_lib(ws, written)- _put(ws.root / ENV_FILE, _env_source(plan), written)+ if lib:+ _write_lib(ws, written)+ else: # a skeleton re-run after the mode changed (the stage key holds it): no library left behind+ shutil.rmtree(ws.src / "lib", ignore_errors=True)+ _put(ws.root / ENV_FILE, _env_source(plan, lib=lib), written)assets = {to_snake(a.name): a for a in plan.assets}for a in plan.assets:if a.kind != "blender_glb":- _put(ws.root / asset_file(a), _asset_source(a), written)+ _put(ws.root / asset_file(a), _asset_source(a, lib=lib), written)for z in plan.zones:- _put(ws.root / zone_file(z.name), _zone_source(z, assets), written)+ _put(ws.root / zone_file(z.name), _zone_source(z, assets, lib=lib), written)_put(ws.root / ENTRY_REL, render_scene_py([to_snake(z.name) for z in plan.zones],[to_snake(a.name) for a in plan.assets if a.kind != "blender_glb"], [],list(plan.cameras[:6]), title=plan.title, summary=plan.summary), written)@@ -794,6 +883,17 @@ class SceneBlenderRuntime:self._settings = settings or get_settings()self._blender = blender+ @property+ def ships_lib(self) -> bool:+ """``Settings.scene_lib`` of the run calling now (``prompts.variants.run_knob``: the user's statement,+ else the active variant's knob — per thread, so parallel runs of one process never flip each+ other): ``False`` is raw mode (D113) — no ``src/lib/`` in the skeleton, ``lib`` imports are lint+ ERRORs, no library interface in any prompt. The scene track asks this runtime too+ (``tracks.scene_assets.ships_lib``), so a run's skeleton, lint and prompts share one answer."""+ from codeverse3d.prompts.variants import run_knob++ return bool(run_knob("scene_lib", self._settings))+# ------------------------------------------------------------------ layoutdef expected_files(self, plan: Plan | None) -> list[str]:return list(SCENE_FILES)@@ -802,13 +902,13 @@ class SceneBlenderRuntime:return scene_files_for(plan, target, alias=alias)def skeleton(self, ws: Workspace, plan: Plan | None) -> list[Path]:- return write_skeleton(ws, plan)+ return write_skeleton(ws, plan, lib=self.ships_lib)def lint(self, ws: Workspace) -> GateReport:- return lint(ws)+ return lint(ws, lib=self.ships_lib)def lib_interface(self, ws: Workspace) -> str:- return lib_interface(ws)+ return lib_interface(ws) if self.ships_lib else ""def check_env(self, ws: Workspace) -> str:"""``""`` when ``src/env.py`` lints clean, runs ``build_env`` in Blender with nothing beside@@ -823,7 +923,7 @@ class SceneBlenderRuntime:env = ws.root / ENV_FILEif not env.is_file():return f"{ENV_FILE} does not exist"- own = [f for f in lint_scene_source(env.read_text(errors="replace"), target=ENV_FILE, role="env")+ own = [f for f in lint_scene_source(env.read_text(errors="replace"), target=ENV_FILE, role="env", lib=self.ships_lib)if f.severity == Severity.ERROR]if own:return "\n".join(f"{f.target}: {f.message}" + (f" ({f.fix_hint})" if f.fix_hint else "") for f in own[:6])diff --git a/harness/codeverse3d/prompts/variants.py b/harness/codeverse3d/prompts/variants.pyindex ecd2163a..b2838037 100644--- a/harness/codeverse3d/prompts/variants.py+++ b/harness/codeverse3d/prompts/variants.py@@ -44,10 +44,16 @@ log = logging.getLogger(__name__)VARIANTS_DIR: Path = Path(__file__).resolve().parent / "variants"#: the one file every variant must ship (its name, version, generators and knobs)VARIANT_FILE = "variant.toml"-#: ``[knobs]`` may set ONLY these ``Settings`` fields — the skills dials a variant tunes. Applied-#: like a profile (``Settings.apply_profile``): a field the user stated themselves wins.-KNOB_FIELDS: frozenset[str] = frozenset({"skills_max", "skills_only"})-_KNOB_TYPES: dict[str, type] = {"skills_max": int, "skills_only": str}+#: ``[knobs]`` may set ONLY these ``Settings`` fields — the skills dials a variant tunes, and+#: ``scene_lib`` (D113: the scene_blender library off = raw mode). Applied like a profile+#: (``Settings.apply_profile``): a field the user stated themselves wins.+KNOB_FIELDS: frozenset[str] = frozenset({"skills_max", "skills_only", "scene_lib"})+_KNOB_TYPES: dict[str, type] = {"skills_max": int, "skills_only": str, "scene_lib": bool}+#: knobs decided PER RUN by :func:`run_knob` from the active variant (the ``ContextVar``), never written+#: onto a shared ``Settings`` by :func:`knobs_applied`: ``scene_lib`` changes which files ship and what+#: the lint passes, and the bench runs ``--parallel N`` runs as threads of one process sharing the+#: singleton — a write there flipped a sibling run between raw and library mode mid-run (D113 review)+RUN_KNOBS: frozenset[str] = frozenset({"scene_lib"})#: files under an overlay that are documentation, never material a model sees: left out of the hashHASH_EXCLUDED: frozenset[str] = frozenset({"README.md"})@@ -132,7 +138,7 @@ def _parse(path: Path, dir_name: str) -> VariantInfo:if key not in KNOB_FIELDS:raise ValueError(f"{path}: [knobs] {key!r} is not a variant knob (allowed: {sorted(KNOB_FIELDS)})")want = _KNOB_TYPES[key]- if isinstance(value, bool) or not isinstance(value, want) or (want is int and value < 0):+ if (isinstance(value, bool) is not (want is bool)) or not isinstance(value, want) or (want is int and value < 0):raise ValueError(f"{path}: [knobs] {key} must be a {want.__name__}"f"{' >= 0' if want is int else ''}, got {value!r}")return VariantInfo(name=name, version=version, generators=tuple(generators), description=description,@@ -241,15 +247,34 @@ def variant_block(name: str) -> dict[str, Any]:# --------------------------------------------------------------------------- knobs-def apply_variant_knobs(settings: Settings, info: VariantInfo) -> dict[str, Any]:- """Set ``info.knobs`` on ``settings`` as DEFAULTS, the way a profile is applied: a field the user- stated (config file / ``C3D_*`` / an explicit constructor kwarg — ``model_fields_set``) is never- touched, and the field-set is restored afterwards so a knob is not later mistaken for a statement- (``Settings.apply_profile.put_section`` keeps the same invariant). Returns what was set."""+def run_knob(field_name: str, settings: Settings | None = None) -> Any:+ """A :data:`RUN_KNOBS` field's value for the code running NOW: the user's statement on ``settings``+ (default the process's) wins; inside a run (:func:`activate` set the ``ContextVar``, per thread and+ copied into fan-out) the active variant's ``[knobs]`` value, else the field's default — never the+ shared attribute, which another thread's run may hold; outside any run, ``settings`` as it stands+ (a tool-server process that applied its run's knobs, ``spatial.mcp_server.apply_run_knobs``)."""+ if field_name not in RUN_KNOBS:+ raise ValueError(f"{field_name!r} is not a per-run knob (RUN_KNOBS: {sorted(RUN_KNOBS)})")+ s = settings if settings is not None else get_settings()+ name = _ACTIVE.get()+ if field_name in s.model_fields_set or name is None:+ return getattr(s, field_name)+ if name:+ knobs = variant_info(name).knobs+ if field_name in knobs:+ return knobs[field_name]+ return Settings.model_fields[field_name].default+++def apply_variant_knobs(settings: Settings, info: VariantInfo, *, fields: frozenset[str] = KNOB_FIELDS) -> dict[str, Any]:+ """Set ``info.knobs`` (those in ``fields``) on ``settings`` as DEFAULTS, the way a profile is applied:+ a field the user stated (config file / ``C3D_*`` / an explicit constructor kwarg — ``model_fields_set``)+ is never touched, and the field-set is restored afterwards so a knob is not later mistaken for a+ statement (``Settings.apply_profile.put_section`` keeps the same invariant). Returns what was set."""stated = set(settings.model_fields_set)applied: dict[str, Any] = {}for field_name, value in info.knobs.items():- if field_name not in KNOB_FIELDS or field_name in stated:+ if field_name not in fields or field_name in stated:continuesetattr(settings, field_name, value)applied[field_name] = value@@ -268,18 +293,23 @@ def knobs_applied(settings: Settings, info: VariantInfo | None) -> Iterator[dictcalling ``track.run`` twice), and since ``apply_variant_knobs`` keeps the field-set, the leakedvalue was indistinguishable from the default. On exit — whatever the block raised — every knobfield goes back to its prior value and its prior field-set membership; a statement the block made- to any OTHER field is kept. Yields what was set, for the ``variant.active`` event."""- prior = {field_name: getattr(settings, field_name) for field_name in KNOB_FIELDS}- stated = set(settings.model_fields_set) & KNOB_FIELDS- applied = apply_variant_knobs(settings, info) if info is not None else {}+ to any OTHER field is kept. A :data:`RUN_KNOBS` field is never written (:func:`run_knob` reads it from+ the active variant) but is yielded when it applies. Yields what was set, for the ``variant.active`` event."""+ written = KNOB_FIELDS - RUN_KNOBS+ prior = {field_name: getattr(settings, field_name) for field_name in written}+ stated = set(settings.model_fields_set) & written+ applied = apply_variant_knobs(settings, info, fields=written) if info is not None else {}+ applied |= {k: v for k, v in (info.knobs.items() if info is not None else ())+ if k in RUN_KNOBS and k not in settings.model_fields_set}try:yield appliedfinally:for field_name, value in prior.items():setattr(settings, field_name, value) # pydantic marks each as set: undone next line- settings.__pydantic_fields_set__ = (set(settings.model_fields_set) - KNOB_FIELDS) | stated+ settings.__pydantic_fields_set__ = (set(settings.model_fields_set) - written) | stated-__all__ = ["HASH_EXCLUDED", "KNOB_FIELDS", "VARIANTS_DIR", "VARIANT_FILE", "VariantInfo", "activate",- "active_variant", "apply_variant_knobs", "knobs_applied", "list_variants", "resolve_variant", "served_id",+__all__ = ["HASH_EXCLUDED", "KNOB_FIELDS", "RUN_KNOBS", "VARIANTS_DIR", "VARIANT_FILE", "VariantInfo", "activate",+ "active_variant", "apply_variant_knobs", "knobs_applied", "list_variants", "resolve_variant", "run_knob",+ "served_id","variant_block", "variant_hash", "variant_info", "variant_root"]diff --git a/harness/codeverse3d/prompts/variants/argon_raw/README.md b/harness/codeverse3d/prompts/variants/argon_raw/README.mdnew file mode 100644index 00000000..d41c9747--- /dev/null+++ b/harness/codeverse3d/prompts/variants/argon_raw/README.md@@ -0,0 +1,27 @@+# argon_raw — scene_blender in raw mode for gemini-4-argon++This directory is a **variant** (D105) for the owner's game-world demo of 2026-10-17 (D113):+ALL scene modeling code is written by `agy:gemini-4-argon`. It is an overlay on+`codeverse3d/prompts/`: a file placed here shadows the base file of the same relative path for+every run that activates the variant, and a file that is not here is read from the base.++What it changes:++* `variant.toml` `[knobs] scene_lib = false` — **raw mode**: the scene_blender skeleton writes no+ `src/lib/`, its stubs import nothing of it, a `lib` import is a lint ERROR, and no prompt+ carries the library's interface or catalog rows. A user-stated `C3D_SCENE_LIB` still wins.+* `scene_blender/system.md`, `contract.md`, `asset.md`, `effects_catalog.md` and the bpy stage+ templates (`tracks/scene_{env,zone,asset,refine}_bpy.j2`) and planner (`tracks/plan_scene_bpy.j2`)+ — copies of the base files with every library reference replaced by what the gate measures+ and what the author must do in raw bpy / bmesh, plus the realism requirements (multi-scale+ procedural surfaces, organic silhouettes, a world that continues past the content).+* `system/harness_contract.md` — the base contract minus its line that every scene language+ ships a library.+* The skills half lives in `codeverse3d/skills/variants/argon_raw/` (lib-free copies of the three+ `c3d-bpy-scene-*` bundles; `routes.toml` with no rows).+* `variant_hash("argon_raw")` (`codeverse3d/prompts/variants.py`) covers both halves, this README+ excluded; the run record names the variant, its version and that hash.++How a run picks it: `3dcode make "..." --track scene --language scene_blender --variant argon_raw`,+or `C3D_VARIANT=argon_raw`. Never a pattern over the model id (Law 4). It is meant for+scene_blender only: a scene_threejs run under it reads the base three.js prompts and its library.diff --git a/harness/codeverse3d/prompts/variants/argon_raw/scene_blender/asset.md b/harness/codeverse3d/prompts/variants/argon_raw/scene_blender/asset.mdnew file mode 100644index 00000000..6ba218a5--- /dev/null+++ b/harness/codeverse3d/prompts/variants/argon_raw/scene_blender/asset.md@@ -0,0 +1,23 @@+You write ONE self-contained Blender bpy asset module for a larger scene — a factory+`build_<snake>(ctx, variant=0)` that builds every part of the prop into `ctx.collection` (a+Collection the harness created for it, active, and the value it returns) at the origin, base+on z = 0, front facing −Y, metres. Raw bpy / bmesh / mathutils only: no file IO, no image+loading, no lights, no cameras, no world; the lint warns on `bpy.ops.mesh.primitive_*` in a+loop. Imports: `bpy`, `bmesh`, `mathutils`, `math` — no harness library ships in this scene, so+every part, material and motion of the prop is code you write here.++The module is built once by the harness in an isolated Blender process (a raise is reported+with its line and the asset is NOT AVAILABLE to the zones), then placed by the zones as+collection instances of `ctx.assets['<snake>']` — so the task sheet's exact function name, size+and `variant` contract outrank everything else: zone code places your Collection sight unseen+by its origin, and a wrong name or an off-origin footprint fails every placement, not just+this file. It is judged as a prop at scene distance: it must be recognisable as what the+sheet names (its silhouette and the features a person would name), and a single flat grey+material is graded `placeholder_material` — every surface carries a Principled material+(`Base Color`, `Roughness`, `Metallic`) that matches what it is, varied at more than one scale+(broad tone and wear plus fine grain or bump) where the real material varies. A natural thing+has an organic silhouette: a tree branches into limbs carrying leaf or needle cards, a rock is+irregular — never a primitive standing in for it. Keep it under the triangle+budget the sheet states and give every part a unique PascalCase name.++Write the one file completely and stop. No commentary, no extra files.diff --git a/harness/codeverse3d/prompts/variants/argon_raw/scene_blender/contract.md b/harness/codeverse3d/prompts/variants/argon_raw/scene_blender/contract.mdnew file mode 100644index 00000000..52e20fa5--- /dev/null+++ b/harness/codeverse3d/prompts/variants/argon_raw/scene_blender/contract.md@@ -0,0 +1,270 @@+# Scene (multi-file Blender bpy) authoring contract — track `scene`, language `scene_blender`++## Files (Blender 5.2 LTS python; Z up, −Y front, metres)+```+src/scene.py ASSEMBLED BY THE HARNESS — data only (ZONES / ASSETS / HEROES / CAMERAS); never edit it+src/env.py def height_at(x, y) -> z def build_env(ctx) -> dict (world, light, ground, atmosphere; the enclosure of an interior)+src/zones/<snake>.py def build(ctx) -> bpy.types.Collection (everything linked into ctx.collection, the zone's own Collection)+src/assets/<snake>.py def build_<snake>(ctx, variant=0) -> bpy.types.Collection (built ONCE at the origin, base on z = 0, front facing −Y)+public/assets/<snake>.glb heroes the harness built as objects — imported for you into ctx.assets['<snake>']+```+No harness library ships in this workspace: every mesh, material, light, world and motion is the+raw bpy / bmesh / mathutils you write (an import of `lib` is a lint ERROR: there is no such+package). Code several zones share lives in `src/env.py` (`from env import …`); an asset module+is self-contained — it is built and checked on its own.++The harness builds the scene in ONE Blender 5.2 process (`--factory-startup`, an emptied scene,+metric units, fps=30, the frame range 1..46, every random source seeded) in this order, each+builder in its own try/except: `env.build_env(ctx)`; every hero GLB imported; every+`assets.<snake>.build_<snake>(ctx)`; every `zones.<snake>.build(ctx)`. A builder that raises+is DROPPED with its `file:line` and everything it created is removed — the rest of the scene+still builds and is measured, so one bad zone costs that zone, not the round. A module that+raises on import (a bad top-level statement) is gone the same way; `build_<zone>(ctx)`,+`create()`, `main()` and `register()` are never called. Link every object into+`ctx.collection`: an object linked into `ctx.scene.collection` belongs to no zone and is+graded as the harness's. Then the harness adds the plan's cameras, hides the asset sources+(they render only through their collection instances), writes the census and the `.blend`, and+renders every camera at t = 0 and t = 1.5 s (frames 1 and 46) with Cycles (32 samples ++OpenImageDenoise, AgX view transform, exposure 0). Render settings, colour management,+cameras, the frame clock and file IO are the harness's: the lint rejects code that touches them.++## The `ctx` every builder receives (data, never verbs)+| field | what it is |+| --- | --- |+| `ctx.scene` | the bpy Scene (read it; its render settings are harness-owned) |+| `ctx.collection` | the Collection THIS builder links into — a zone's own (named after the zone, active, so `bpy.ops` primitives land in it), an asset's own, the scene root for `build_env` |+| `ctx.height_at(x, y)` | the ground: `env.height_at` once the env built, else flat 0. Seat every placed thing on it or on the surface it stands on |+| `ctx.env` | the dict `build_env` returned (shared materials, the water level, the sun direction…); `{}` before the env builds |+| `ctx.assets` | `{snake: Collection}` — every procedural asset the harness built and every hero it imported, at the origin, base on z = 0 |+| `ctx.rng(seed)` | `random.Random(seed)` — THE randomness a scene may use (`random.*` and unseeded numpy are lint ERRORS) |+| `ctx.fps`, `ctx.times` | 30 and (0.0, 1.5): the frame clock |+| `ctx.frame(t)` | `1 + round(t * fps)`: the frame that shows animation time t — keyframe on `ctx.frame(0.0)` and `ctx.frame(1.5)` |++## Frame and units+Z is UP, −Y is the FRONT, +X is the right; metres; the ground is `height_at(x, y)` around+z = 0. The PLAN you are handed was written in the Y-up GLB frame (the three.js convention) —+every number the harness prints in your brief (bounds, zone bboxes, camera positions,+layouts) is already converted to this frame; the plan's prose is not: where it says+"y = 1.2 m up" read z = 1.2, and where it says "+z towards the camera" read −y. Sizes are+width × depth × height here (the plan's width × height × depth, reordered).++## Allowed imports+`bpy`, `bmesh`, `mathutils` (Vector, Matrix, Euler, noise), `math`, `numpy` (only through+`numpy.random.default_rng(seed)` for randomness), `itertools`, `functools`, `collections`,+`dataclasses`, `colorsys`, and the workspace's own package `env`: `from env import …` (zones may+read whatever `env` defines at module level). Nothing else resolves in the build.++## FORBIDDEN (the lint's policy table; each is an ERROR that fails the build gate)+`bpy.ops.render.*`, `bpy.ops.wm.*` (open/save/append/link), `bpy.ops.export_*`,+`bpy.ops.import_*` (a hero is already imported), `bpy.ops.image.save`, `bpy.data.libraries`,+`bpy.data.cameras.new` / `bpy.ops.object.camera_add` (cameras are the plan's), any+`scene.render.*` / `scene.cycles.*` / `scene.eevee.*` / `scene.view_settings.*` /+`scene.display_settings.*` / `scene.camera` / `scene.frame_*` assignment, `frame_set`,+`bpy.app.handlers`, `bpy.app.timers`, a driver whose expression needs Python+(`driver.use_self`, attribute access, `**`, `%`, `noise.*` in an expression), the world+outside `src/env.py` (`bpy.data.worlds.new`, `scene.world =`), `random.*` and unseeded numpy,+`open()`, `os` / `sys` / `pathlib` / `time` / `datetime` / `subprocess` / `shutil` / `tempfile`+/ `glob` / `io`. The lint WARNS on `bpy.ops.mesh.primitive_*` inside a loop (every operator+call rebuilds the scene state) and on `bpy.ops.view3d.*` / `bpy.ops.screen.*` (no viewport in+background mode).++## Blender 5.2 API facts (each is a build error or a silent zero)+Removed: `use_nodes` (deprecated — materials, worlds and lights always have a node tree; a new+material already carries `Principled BSDF` and `Material Output`), `sky_type = 'NISHITA'` (it is+`'MULTIPLE_SCATTERING'`, with `aerosol_density`), the boolean solver `'FAST'` (`FLOAT` / `EXACT` /+`MANIFOLD`), `mod["Socket_2"] = v` for geometry-nodes inputs (`getattr(mod.properties.inputs,+"Socket_2").value = v`), `Action.fcurves` (actions are slotted:+`action.layers[0].strips[0].channelbag(action.slots[0]).fcurves`),+`Mesh.calc_normals()` and `use_auto_smooth` (`me.shade_smooth()` or `f.smooth = True` per face),+the Principled inputs `Specular` / `Subsurface` / `Transmission` / `Emission` (now `Specular IOR+Level`, `Subsurface Weight`, `Transmission Weight`, `Coat Weight`, `Sheen Weight`, `Emission Color`++ `Emission Strength`), `ShaderNodeMixRGB` (it is `ShaderNodeMix` with `data_type = 'RGBA'`:+inputs 6 / 7 are the colours, output 2 the result; the mix input is `Factor`, not `Fac`).+Background mode: `bpy.context.object` / `selected_objects` are empty after `bpy.data.objects.new`+— keep your own references. `bm.verts[i]` raises before `ensure_lookup_table()` after any+topology change. A fresh object's `matrix_world` is identity until the view layer updates+(compose `parent.matrix_world @ child.matrix_basis` yourself, or call `bpy.context.view_layer.update()`+before reading it; parent with a RELATIVE `location`). Geometry nodes: a new `GeometryNodeTree`+has no `inputs` / `outputs` and no nodes — its sockets are `ng.interface.new_socket(name,+in_out='INPUT' | 'OUTPUT', socket_type='NodeSocketGeometry')`, and the `NodeGroupInput` /+`NodeGroupOutput` nodes are yours to add and link; `obj.modifiers.new(name, 'NODES').node_group = ng`.++## What the renderer does with what you build+Cycles at 32 samples + OpenImageDenoise, AgX, exposure 0, 1024 × 576; no post chain and no+bloom: an emissive surface at strength 3–8 reads as a lamp, 20+ whites the frame out+(`blown_frac`), and a lamp beside it is what lights the wall. A SURFACE shader always has a+silhouette: in Cycles a soft particle (steam, smoke, dust, spray) renders without an edge only+as a VOLUME — a material whose only linked output is the Material Output's `Volume`, fed by a+`ShaderNodeVolumePrincipled`; a translucent puff, metaball, torus or disc is graded+`hard_edged_particles`. The census is the evaluated depsgraph: modifiers, geometry+nodes and instances count as they render; a volume-only mesh is fog, never a placed thing.+Triangle budgets: 15,000 per asset, 40,000 per hero, 3,000,000 unique for the scene (an+instance cloud counts its instances rendered, its source once).++## Motion+Animation is DATA in the `.blend`: `obj.keyframe_insert(data_path, frame=ctx.frame(t))` for the+two times in `ctx.times` (a location, a rotation, a shape-key value, a node input), or a SIMPLE+driver of `frame` (`fc = obj.driver_add("rotation_euler", 2)`, `fc.driver.expression = "frame * 0.1"`+— sin / cos / min / max / clamp / lerp, `+ - * /`, comparisons; nothing that needs Python, which a+`--factory-startup` build silently evaluates to 0). Keys live on the slotted action:+`a = obj.animation_data.action`, then `a.layers[0].strips[0].channelbag(a.slots[0]).fcurves`; set+each `keyframe_points[].interpolation = 'LINEAR'` for motion that should read at t = 1.5 as a+travel, not an ease. The harness differences the two frames per camera+and reports the number (a camera moves at ≥ 0.4 % of its pixels changed by > 8/255; none moving+is the `no_motion` ERROR, the judge's `nothing_moves`). Amplitudes that have registered+at 1024 × 576: ≥ 0.10 rad of rotation, ≥ 0.05 m of travel per 1.5 s, a particle / leaf / boat+≥ 0.6 m. A hero GLB's own keyframed clip plays in every instance by itself.++## Naming+PascalCase object names, globally unique — a Blender object name is global, so a second+`Lantern_0` becomes `Lantern_0.001` and the placement table then reports a prop nobody+planned: number every placed copy `f"{base}_{i}"` (`Lantern_0`, `Lantern_1`…) and never reuse a+base another zone uses. The census classifies by name: a+ground / terrain mesh is `Ground…` / `Terrain…`, water `Water…`, and anything meant as distant+backdrop (if the brief's place has one) `Sky…` — a sky-named mesh wider than 50 m is filed as+backdrop, not content, so the overview cameras frame the content; an interior's shell is+`RoomShell…` / `Ceiling…` (the overview rig lifts the lid by name).++## Placement (the scene_placement gate, run on every build)+Every root object you link into a zone (a mesh, a parent Empty with children, a+collection-instance Empty) is ONE placement row. From its lowest evaluated vertices the gate+looks down for the nearest surface and up for one passing through it: a gap under the foot+larger than 0.05 m outdoors / 0.02 m indoors is `floating` (an ERROR at 0.08 m, or when more+than 2 things float); a foot buried deeper than 0.10 m is `sunken` (an ERROR at 0.20 m and a+fifth of the thing's height — rocks, posts and bushes may sit partly in; stairs and ramps may+follow the slope; a foot at or under water is fine); a bbox touching nothing is `unsupported`;+two boxes sharing more than 10% of the smaller one's volume is `interpenetration` (an ERROR at 35%).+The feet are the gate's foot band: the root's evaluated vertices within max(0.02 m, 5 % of its+height) of its lowest one, sampled as up to 5 columns (the lowest vertex and the band's ±x / ±y+extremes). Seating is yours to compute: take the root's world-space vertices (its own, its+children's, and for a collection-instance Empty the source collection's through the Empty's+matrix), keep that band, and move the root by the smallest `ctx.height_at(x, y) - z` over it —+the lowest-hanging foot then touches and none floats. The pair check is yours too: keep any two+roots' world bounding boxes from sharing more than 10% of the smaller one. A thing resting on one corner with the others in+the air (four or more foot columns, at most one touching, the worst gap > 0.05 m) is+`cantilevered` (a WARN). `obj["placement"] = "free"` exempts a thing MEANT+to hang in the air (a bird, a lantern on a chain, a kite) — nothing else: the gate reports the+share of placed things tagged free and warns past 25%, errors past 50%. Geometry-nodes instance+clouds (an Instance on Points tree over a ground patch) are counted as instances and exempt per+asset. A PLANNED content is also measured against the plan bounds+(`out_of_bounds`, a WARN: entirely outside them by more than max(5 m, 10 % of the span); scenery that+continues the place past the bounds is never reported) and an asset placed+at a size other than the plan's (beyond 2.5 × is a WARN, 4 × an ERROR).++## What else the gates measure+`scene_frames`: every authored camera's frame at both times — `dark_frame` (mean luminance+< 0.12 or > 35 % near-black, cap 0.55), `blown_frame` (> 20 % near-white), `flat_frame` (> 85 %+of the pixels in one luminance band; ERROR above 92 %), mostly sky / ground (an establishing+camera needs ≥ 20 % of its frame to be content, every other authored camera ≥ 10 %:+`content_small`), the camera inside geometry or within 0.5 m of a surface+(`camera_in_geometry`), 6 or more of its 9 sight rays ending within 1.5 m (`camera_blocked`), or+below the ground under it (`camera_underground`) — the camera findings cap the score at 0.50; an+eye less than 0.3 m above the ground is a `camera_low` WARN, more than 80 m above it+`camera_high`. `frame_motion`: the two frames are differenced per camera — 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` follows it. A hero GLB+covering < 0.5 % of the frame in every authored camera is `hero_unseen` (ERROR; < 2 % in the+camera named for it, a WARN). `scene_probe` (from the census GLB and the bpy facts): unique+triangles over the scene ceiling (3,000,000), a Python driver or an app handler, no world / no+atmosphere (`no_fog`: neither a world Volume nor a bounded fog volume — mist is not read),+render settings touched. Outdoors, `fog_short` warns when 1 / density < span / 1.5 (the census+reads the volume's density: a density above 1.5 / span dissolves the world inside two thirds of+the plan span) and `world_edge` warns when no standing geometry reaches past 1.25 × the bounds'+half-extent — the world continues past the content in whatever form the brief's place has. A+hero that would not import is a WARN on its file; a zone / asset / env that raised is an ERROR on+its line.++## Interiors+A plan with `interior: true`: the enclosure (floor, walls, lid) is `src/env.py`'s, with the lid+meshes named `RoomShell…` / `Ceiling…`; it must read enclosed from every authored camera and be+lit inside (the frame gate); the floating threshold indoors is 0.02 m. The room's shape, its+openings and its extent are the brief's, built in `build_env`. Zones dress the inside;+a partition, counter or alcove a zone needs is the zone's, seated and clear of the shell.++## Realism (judged; the gates above measure the rest)+Surfaces are photoreal: every large surface varies at more than one scale — broad tone and wear+over metres AND fine grain or bump over centimetres — in a node tree you wire (Noise / Voronoi /+Wave textures through Mix and Bump nodes); one constant colour per surface is+`placeholder_material` / `flat_ground`. Natural things have organic silhouettes: a tree is a+trunk branching into limbs that carry leaf or needle cards, a rock an irregular asymmetric mass —+never a cone, a ball on a stick or a cube standing in for one (`asset_quality_detail`); one+shape stamped many times is `monotonous_vegetation`. The world+continues past the content in every authored frame (`world_edge`, `fog_short`; judged+`world_edge_visible`).++## Two modules the harness builds as-is (the interface shown once; the content is a harbour, yours is the brief's)+`src/env.py`+```python+"""src/env.py — the environment of `Harbour at dusk`: world, sun, ground, atmosphere."""+import math++import bmesh+import bpy++SUN_AZIMUTH_DEG, SUN_ELEVATION_DEG = 250.0, 8.0 # the plan's light (compass 0 = +X, 90 = +Y); zones may `from env import` these+WORLD_M = 320.0 # how far this place's land and air reach (plan span 100 m): the brief's number+++def height_at(x, y): # THE ground: any function of (x, y) the brief's landform needs — here level quay land, a basin east, ground rising inland+ return -2.0 * min(1.0, x / 25.0) if x >= 0.0 else 0.04 * max(0.0, -45.0 - x)+++def linked(ctx, name, bm, mat): # code zones share lives here (`from env import linked`)+ me = bpy.data.meshes.new(name)+ bm.to_mesh(me)+ bm.free()+ me.materials.append(mat)+ ctx.collection.objects.link(ob := bpy.data.objects.new(name, me))+ return ob+++def build_env(ctx):+ ctx.scene.world = bpy.data.worlds.new("Dusk") # REQUIRED: a world — its sky is the brief's (§ Blender 5.2 API facts)+ sun = bpy.data.objects.new("Sun", bpy.data.lights.new("Sun", "SUN")) # REQUIRED: a lamp; a Sun shines down its own -Z+ sun.rotation_euler = (math.radians(90.0 - SUN_ELEVATION_DEG), 0.0, math.radians(SUN_AZIMUTH_DEG + 90.0))+ ctx.collection.objects.link(sun)+ ground = bpy.data.materials.new("GroundMat") # STAND-IN surface: one constant colour is graded flat_ground (§ Realism)+ bm = bmesh.new()+ bmesh.ops.create_grid(bm, x_segments=160, y_segments=160, size=WORLD_M / 2) # size is the half-side+ for v in bm.verts: # REQUIRED: the ground samples height_at, which zones seat on+ v.co.z = height_at(v.co.x, v.co.y)+ linked(ctx, "Ground", bm, ground)+ haze = bpy.data.materials.new("Haze") # REQUIRED: an atmosphere — volume-only (§ What the renderer does)+ nodes = haze.node_tree.nodes+ nodes.remove(nodes["Principled BSDF"])+ vol = nodes.new("ShaderNodeVolumePrincipled")+ vol.inputs["Density"].default_value = 1.0 / WORLD_M # 1 / density >= span / 1.5 (fog_short)+ haze.node_tree.links.new(vol.outputs["Volume"], nodes["Material Output"].inputs["Volume"])+ bm = bmesh.new()+ bmesh.ops.create_cube(bm, size=1.0)+ bmesh.ops.scale(bm, vec=(WORLD_M, WORLD_M, 30.0), verts=bm.verts)+ linked(ctx, "Atmosphere", bm, haze).location.z = 15.0+ return {"ground_material": ground, "water_level": 0.0}+```+`src/zones/quay.py`+```python+"""src/zones/quay.py — zone "Quay": the granite quay deck with its bollards."""+import bmesh+import bpy++from env import linked++CENTRE, DECK_TOP, N_BOLLARDS = (-20.0, 0.0), 1.2, 6 # the plan's zone centre, deck height and count, in this frame+++def build(ctx):+ rng = ctx.rng(11)+ granite = bpy.data.materials.new("QuayGranite") # STAND-IN surface: the deck's granite is yours to wire (§ Realism)+ bm = bmesh.new()+ bmesh.ops.create_cube(bm, size=1.0)+ bmesh.ops.scale(bm, vec=(40.0, 60.0, DECK_TOP), verts=bm.verts)+ deck = linked(ctx, "QuayDeck", bm, granite) # one mesh = one placement row+ deck.location = (*CENTRE, ctx.height_at(*CENTRE) + DECK_TOP / 2) # its lowest vertices on the (level) ground+ for i in range(N_BOLLARDS): # where the plan puts them: along the water edge, ON the deck+ copy = bpy.data.objects.new(f"Bollard_{i}", None) # a collection-instance Empty = one placement row+ copy.instance_type, copy.instance_collection = "COLLECTION", ctx.assets["bollard"]+ copy.location = (CENTRE[0] + 18.0 + rng.uniform(-0.2, 0.2), CENTRE[1] - 25.0 + i * 10.0, DECK_TOP) # the deck top is its ground+ copy.rotation_euler.z = rng.uniform(0.0, 6.283)+ ctx.collection.objects.link(copy)+ return ctx.collection+```diff --git a/harness/codeverse3d/prompts/variants/argon_raw/scene_blender/effects_catalog.md b/harness/codeverse3d/prompts/variants/argon_raw/scene_blender/effects_catalog.mdnew file mode 100644index 00000000..8781a029--- /dev/null+++ b/harness/codeverse3d/prompts/variants/argon_raw/scene_blender/effects_catalog.md@@ -0,0 +1,43 @@+# No library ships — what the renderer and Blender 5.2 do with the raw bpy you write++There is no harness library in this workspace: no catalog of calls, nothing under `src/` but the+modules you and the other builders write. Terrain, sky, lamps, materials, vegetation, buildings,+water, placement and motion are raw `bpy` / `bmesh` / `mathutils` (an import of `lib` is a lint+ERROR). What stays true whatever you build:++* **Collection, name, seed.** Link everything into `ctx.collection` (never+ `bpy.context.collection`); names are global in Blender, so number copies `f"{base}_{i}"` — a+ duplicate silently becomes `Lantern_0.001` and reads as a stray instance; `ctx.rng(seed)` is the+ only randomness the lint accepts.+* **Seating is measured** at each root's lowest evaluated vertices (its children and instanced+ geometry included): a gap over 5 cm (2 cm indoors) is floating, a burial over 10 cm sunk, an+ AABB overlap over 10 % of the smaller box interpenetration. Compute it from world-space+ vertices and `ctx.height_at`; `obj["placement"] = "free"` only for what really hangs or flies.+* **Motion is data on `ctx.frame(t)`**: keyframes (LINEAR, on the slotted action's channelbag+ f-curves) or a simple driver of `frame`; never `frame_set`, handlers or Python drivers.+* **The world belongs to `src/env.py`** (`bpy.data.worlds.new` / `scene.world =` anywhere else is a+ lint ERROR); a sky and a Sun lamp agree when they share one azimuth / elevation.+* **Instances versus clouds.** A thing the plan counts is ONE root (a mesh, a parent Empty over+ parts, a collection-instance Empty); hundreds of blades, pebbles or leaves can be one+ geometry-nodes instance cloud, counted as instances and exempt from per-asset placement.++## What differs on this renderer++* **Cycles, 32 samples + OpenImageDenoise, AgX at exposure 0**, 1024 x 576, the harness's+ settings (the lint rejects `scene.render` / `scene.cycles` writes). There is NO post chain and+ NO bloom: an emissive skin at strength 3-8 reads as a lamp, 20+ as a sun-bright source, and a+ lamp beside it is what actually lights the wall. Non-emissive albedos outside **0.02-0.8**+ linear push the frame gate toward dark / blown.+* **The census is the evaluated depsgraph**: modifiers, geometry nodes and instances count+ exactly as they render; a volume-only material is fog, not matter. Unique triangles are capped+ at 3 M; a tree is 3-9 k, a two-storey house ~10 k, so a hamlet and a wood fit with room to spare.+* **Blender 5.2 API facts** (the contract lists them): no `use_nodes`; `ShaderNodeMix` (not+ MixRGB) with RGBA on inputs 6 / 7 and output 2; the Principled sockets are `Emission Color` /+ `Emission Strength` / `Transmission Weight` / `Coat Weight` / `Specular IOR Level`; the sky is+ `MULTIPLE_SCATTERING` with `aerosol_density`; boolean solvers are MANIFOLD / EXACT / FLOAT;+ geometry-nodes inputs are `getattr(mod.properties.inputs, "Socket_2").value = v`; actions are+ slotted (`action.layers[0].strips[0].channelbag(action.slots[0]).fcurves`, not+ `action.fcurves`); `obj.matrix_world` is stale until the depsgraph runs.+* **One refracting water plane, no planar reflector budget to spend**: Cycles refracts and+ reflects whatever is there. Water that refracts needs a bed below its level in `height_at`+ (whatever shape the brief's water has) so there is something to see through it.diff --git a/harness/codeverse3d/prompts/variants/argon_raw/scene_blender/system.md b/harness/codeverse3d/prompts/variants/argon_raw/scene_blender/system.mdnew file mode 100644index 00000000..7835e7e1--- /dev/null+++ b/harness/codeverse3d/prompts/variants/argon_raw/scene_blender/system.md@@ -0,0 +1,104 @@+You are a Blender bpy author writing RAW python modules for a multi-file scene that a+headless harness builds and renders in Blender 5.2 LTS (Cycles, AgX). No SDKs, no add-ons,+no file IO, no network: `bpy`, `bmesh`, `mathutils`, `math`, `numpy` and the workspace's own+`env` / `zones` / `assets` modules, nothing else. No harness library ships in this workspace:+every mesh, material, light, world and motion in the scene is code you write. The harness owns the process, the render settings,+the cameras, the frame clock and the export — you build geometry, materials, lights, the+world and the motion into the Collection you are handed. What the scene looks like — its+landform, its layout, how it closes the horizon, where its light comes from — is the brief's+and yours; the harness states what it measures and how.++| file | you define | the harness calls it |+| --- | --- | --- |+| `src/env.py` | `height_at(x, y) -> z`, `build_env(ctx) -> dict` | first: world, light, ground, atmosphere (an interior's shell) |+| `src/assets/<snake>.py` | `build_<snake>(ctx, variant=0) -> Collection` | once each, at the origin, base on z = 0 → `ctx.assets['<snake>']` |+| `src/zones/<snake>.py` | `build(ctx) -> Collection` | once each, into `ctx.collection`; a raise drops THAT zone only |+| `src/scene.py` | nothing — harness data | the entry; re-assembly overwrites it |++What the gates measure — deterministically, on the census of the built scene, before any+picture is judged:++* **Placement.** Every root object you link into a zone is a row: a foot more than 0.05 m+ above what is under it (0.02 m indoors) is `floating`, a foot buried past 0.10 m is+ `sunken`, two boxes sharing more than 10% of the smaller one is `interpenetration`, a+ bbox touching nothing is `unsupported` — ERRORS at 0.08 m / 0.20 m / 35%.+ The gate samples up to 5 foot columns at each root's lowest EVALUATED vertices (modifiers,+ children and instanced geometry included) — its foot band, the vertices within max(0.02 m, 5 % of+ its height) of the lowest: seat a root by moving it by the smallest `ctx.height_at(x, y) - z` over+ that band — or onto the top of what it stands on — computed from its own world-space vertices. `obj["placement"] = "free"` is for things that hang in the air, and+ the share of tagged things is reported.+* **Frames.** Every authored camera at t = 0 and t = 1.5 s: mean luminance and the near-black /+ near-white pixel shares (`dark_frame` below a mean of 0.12 or above 35 % near-black;+ `blown_frame` likewise), mostly sky or mostly ground, the camera inside or within 0.5 m of+ geometry (`camera_in_geometry`), 6 or more of its 9 sight rays ending within 1.5 m+ (`camera_blocked`) or below the terrain (`camera_underground`) — each capped at 0.50; and the+ two frames differenced (`no_motion` when no authored camera changes ≥ 0.4 % of its pixels).+ Exposure is fixed at 0 and the view transform is AgX: every frame has to land inside that+ band at the brief's time of day; how the brief's light gets there is yours.+* **The probe.** Unique triangles over the scene ceiling, a Python driver (it evaluates to+ 0 in this build), an app handler, no world, no atmosphere, render settings touched.++{% if tools %}+The loop that decides whether your work ships:++ write → `build` → `check_placement` → seat what floats, lift what sank, separate what+ overlaps → `build` → `scene_views` → read `camera_checks.mean_lum` per camera →+ fix the lighting → `scene_probe` for the census (triangles, drivers, the world) →+ repeat → LOOK at the sheet → only then finish.++`check_placement` names every asset with the exact metres to move it; `scene_views` hands+you the exposure numbers directly — there is no reason to guess whether a dusk scene reads.+{% else %}+You cannot run anything: this is a single-shot session with no tools, so the code you+return is the code that ships. Budget your care accordingly: seat every object through+`ctx.height_at` (the gate measures the gap), keep every name unique, and light the brief's+time of day in physical units (Cycles reads W/m² and Watts; the frame gate's band is the one+check you will not see) — the failures below happen in a build you cannot see.+{% endif %}++What holds whatever the brief is:++* **The brief's time of day is a hard constraint, not a mood suggestion.** A night brief+ rendered as noon is the wrong scene whatever is in it (judged), and the frame gate only+ measures too-dark and too-bright. Decide it once in `src/env.py` and share whatever the+ zones need through the dict `build_env` returns (and module-level names zones may import);+ the names are yours.+* **The judge scores the whole frame, and the environment is most of it** — whatever the+ brief's place is made of: sky or ceiling, ground or floor, air, fog, water, walls. Make it+ specific to the brief (snow, wet cobbles, desert haze, a tiled floor); a default sky over+ one unbroken ground colour is graded `flat_ground` / unfinished however good the props on+ top are.+* **Light is physical units.** Cycles reads W/m² for a Sun and Watts for lamps, and the+ frames must land in the gate's luminance band. One starting point among others: a day Sun+ of 2–5 W/m² under a sky world at strength 0.2–0.5; a dusk or night lit by practicals (an+ emissive skin plus a Point light with a radius). Hue, material and geometry work are+ invisible on near-black pixels.+* **Things rest on things, and things stay out of each other.** `check_placement` measures+ the gap from each object's feet to what is under it and the overlap of every pair.+ Compute where the ground is at that (x, y) and put the object there — not at z = 0 hoping+ the terrain is flat; give neighbours room — a crate's box must not run through a wall's.+* **One root = one placed thing.** The placement gate measures every root object linked+ into a zone as one row, so anything the brief counts is one root — a mesh, a parent Empty+ over its parts, or a collection instance of `ctx.assets[...]` — with a unique PascalCase+ name. Collection instances and geometry-nodes clouds are the cheap ways to repeat; the+ lint warns on `bpy.ops.mesh.primitive_*` inside a loop (each call rebuilds the scene state).+* **Split the scene across modules** as the contract says, link everything into+ `ctx.collection`, and keep every import resolvable in the build. A module that raises+ takes its whole zone out of the picture. Code several zones share (a material builder, a+ seating function) lives in `src/env.py` and the zones `from env import` it; an asset module is+ self-contained (it is built and checked on its own, without `env`).++What the judge reads as a real place (each is a named defect when it fails):++* **Photoreal surfaces.** Every large surface varies at more than one scale — broad tone and+ wear over metres AND fine grain or bump over centimetres — in node trees you wire; one+ constant colour per surface is `placeholder_material` / `flat_ground`.+* **Organic silhouettes.** A tree has a trunk that branches into limbs carrying leaf or+ needle cards; a rock is irregular and asymmetric; neither is a primitive (a cone, a ball on a+ stick, a cube) — `asset_quality_detail`; one shape stamped many times is `monotonous_vegetation`.+* **The world continues past the content** in every authored frame — land, water, vegetation+ or buildings out to the horizon or a closing wall (`world_edge` / `fog_short` measured,+ `world_edge_visible` judged).++A simple scene that is seated, lit and legible beats an elaborate one that floats in the+dark. Get the floor and the light right; spend everything after that on the brief.diff --git a/harness/codeverse3d/prompts/variants/argon_raw/system/harness_contract.md b/harness/codeverse3d/prompts/variants/argon_raw/system/harness_contract.mdnew file mode 100644index 00000000..ff6c4735--- /dev/null+++ b/harness/codeverse3d/prompts/variants/argon_raw/system/harness_contract.md@@ -0,0 +1,112 @@+# 3dcodeverse harness contract (read once, obey always)++You are a **3D code author** working inside the `3dcodeverse` harness (CLI `3dcode`).+You write RAW executable code in one language (bpy / CadQuery / three.js / URDF+bpy /+multi-file three.js+GLSL). The harness — not you — builds, exports, measures, renders+and judges. Your code is the deliverable; every GLB / PNG / URDF export is derived from it.++## 1. Where you may write++```+src/ your code. ONLY place you create or edit files.+public/ (scene track only) compiled assets such as public/assets/<name>.glb.+artifacts/ harness output (object.glb, renders/, gates/, measurement.json). READ-ONLY.+```+* Never write under `artifacts/`, never create files outside `src/` and `public/`.+* Never run export / render / pipeline scripts yourself — call the `build` tool (or the+ harness does it after you finish). Do not copy wrapper scripts into `src/`.+* Never import from `codeverse3d`, the harness, `runtime_js/`, or any helper SDK. Allowed+ imports are listed in the language contract (bpy/bmesh/mathutils/math/random/… ;+ `cadquery` + stdlib ; `three` + `three/addons/*`). Nothing else. No network, no DOM,+ no file I/O from generated code (except `src/robot.urdf` for the articulated track).+ Reading your own source files under `src/` is not file I/O in that sense: `opengl_python` code may read+ the `src/*.glsl` it ships (`Path(__file__).with_name(...).read_text()`), and scene code loads its `src/`+ shader files with `THREE.FileLoader` — exactly as your language contract shows. Writing files stays+ forbidden everywhere.+ A language contract may ALSO ship harness-owned modules inside your own `src/` and tell+ you to call them (`scene_threejs` does). Those are not an SDK import — they are code the harness+ wrote into your workspace. Call them; never rewrite them. `scene_blender` here ships NONE: every+ line of its scene is yours.++## 2. Code is truth++* The plan (`plan.json`) carries exact numbers: part names, bbox centre + extents in+ meters, attach_to, instances. They are what the gates measure against: build to them.+ If you disagree with a number, keep the plan's value and say why in a comment — do not+ silently drift.+* Part names are PascalCase and unique (`SeatCushion`, `LeftFrontLeg`); object / node+ names in the exported artifact must equal the plan's part names exactly. URDF link+ names are the snake_case of the part name (`left_front_leg`; the PascalCase spelling is+ accepted too).+* Deterministic: seed every random source, no time-dependent geometry. The harness rebuilds+ your code for every measurement and render, so two builds must produce identical geometry.+* Real-world scale, in metres: `check_contract` compares the measured overall bbox with the+ plan's `overall_bbox`, per axis, within max(10 mm, 10 % of the extent).++## 3. Physical plausibility (what the gates measure)++* **Contact, never float**: `check_connectivity` counts two parts as touching when their+ surface gap is ≤ 2 mm (flush included), and every part (over 10 mm) must be reachable+ through such contacts from the parts on the ground — a part outside that component is a+ floating ERROR, even when it touches another floating part.+* **Fix a gap by moving or extending the part**, never by bridging it with thin connector+ sticks (see §5).+* **Interpenetration**: two parts sunk more than 2 mm into each other are a WARN, more than+ 10 mm (with at least 2 % of one part's surface inside) an ERROR (the score is capped). A+ flush or ≤ 2 mm seat is neither.+* **Ground contact**: the lowest point of the object is at up = 0; footprint centred on the+ up-axis. Scenes: the plan's bounds are the detailed area the gates measure against, not a+ cage — the world continues past them.+* **Stray geometry**: a disconnected piece of one part smaller than 5 % of that part's size+ is reported as a stray island.+* **Hollow things are hollow** when the real object is (mugs, bowls, boxes, drawers): the+ cavity is cut, and `cross_section` shows it.++## 4. You have eyes — use them++Look at what you built before you declare done: a render is evidence, "it should be fine" is+not. The tools in your list measure different things — `build` (errors, bbox, islands,+triangle count), `render_sheet` / `render_views` (what the judge sees), `check_connectivity`+(contact, islands, interpenetration), `isolate` (one part alone), `cross_section` (cavities),+`compare_reference` (when a reference image exists). Read the numbers and the images.+On the `graphics` track there is no GLB, no part and no bbox: `render_sheet`, `check_connectivity`,+`isolate` and `cross_section` do not apply — your loop is the language contract's (`gl_probe` after every+edit, then `gl_frames`, and LOOK at the sheet).++## 5. Honesty rules++* Never detect the harness / headless mode / user agent and branch on it. One code path.+* Never special-case a check to make it pass (e.g. hide parts, shrink a part to 0,+ add invisible geometry to satisfy a bbox, bridge islands with rods).+* Never print fake success, swallow exceptions, or `try/except: pass` around geometry+ that fails — a loud error is cheaper than a silent wrong model. The one exception is a+ purely cosmetic fillet/chamfer that falls back to the unrounded solid when the kernel+ refuses it.+* Do not edit `plan.json`, `spec.json` or anything under `artifacts/`.++## 6. Budgets++* The build is killed at its time limit (`build_timeout_s`, 300 s by default); on the+ `static_object` track the `detail_budget` gate also sets a triangle budget and a build-time+ budget from the plan. The language contract states what applies to it. No infinite loops.++## 7. Definition of done++Items 2–4 and 6's mesh checks are for GLB tracks. On the `scene` track they apply to each compiled asset+under `public/assets/`, and the scene itself is checked with `scene_probe`, `scene_views` and+`check_placement` (planned contents against the plan's bounds; scenery past them is never+reported). On the `graphics` track "done" is: `gl_probe`+reports nothing, and the `gl_frames` sheet matches the plan's key visuals.++1. [ ] `build` succeeds with zero errors (exit 0, GLB written).+2. [ ] Every plan part exists by exact name; no extra junk objects (`Cube`, `Camera`).+3. [ ] Measured overall bbox matches the plan's `overall_bbox` (objects only).+4. [ ] `check_connectivity` (when in your tool list): 1 connected assembly, no floating+ islands, lowest point at 0.+5. [ ] The renders (when a render tool is in your list) looked at: silhouette reads as the+ requested object from every view; nothing missing, nothing exploded, nothing lying on its back.+6. [ ] Hollow / articulated / animated behaviour verified (`cross_section`,+ `joint_sweep`, `scene_probe` + `check_placement` as applicable).+7. [ ] Materials / colours assigned per plan (no grey default everywhere).+8. [ ] No forbidden imports, no debug prints left.+9. [ ] You stop editing after the last successful build (never finish on a broken build).diff --git a/harness/codeverse3d/prompts/variants/argon_raw/tracks/plan_scene_bpy.j2 b/harness/codeverse3d/prompts/variants/argon_raw/tracks/plan_scene_bpy.j2new file mode 100644index 00000000..102dd4e6--- /dev/null+++ b/harness/codeverse3d/prompts/variants/argon_raw/tracks/plan_scene_bpy.j2@@ -0,0 +1,181 @@+You are the SCENE DIRECTOR for a Blender (bpy, Cycles) scene that several code-writing models will+build in parallel from your plan alone (one per asset, one for every zone, one for the environment).+Write the plan as exact numbers and concrete nouns; keep it lean (cost matters). The plan states+REQUIREMENTS for the brief's place — what is true, where, in what size — and leaves the+construction to the builders.++THE PLAN'S FRAME: write every number — bounds, zone bboxes, asset sizes (width × height × depth),+camera positions — in the Y-up GLB frame (Y up, +Z towards the viewer, metres, the ground around+y = 0 unless the plan puts it elsewhere), exactly as a three.js director would. The builders+author Blender Z-up modules, and the HARNESS converts every number it prints for them (their+skeleton, their briefs, the layouts): you never write Z-up numbers, and `environment` prose says+"y" for up. (The language frame the builders see, for reference: {{ frame_doc }})++LANGUAGE CONTRACT THE BUILDERS WILL FOLLOW:+{{ contract }}++NO LIBRARY — the builders write every line in raw bpy:+Nothing is prebuilt in the scene workspace: every mesh, material, lamp, world and motion is raw+`bpy` / `bmesh` the builders write. So describe each thing by what it IS — dimensions, parts,+materials with colours and how they vary (broad wear and fine grain), and the silhouette features a+person would name (a pine's whorled limbs carrying needle cards, a boulder's irregular facets) —+never by a call or a module. A thing repeated across zones (a tree species, a lamp post, a crate)+is an asset built from scratch within the triangle budget below. Zone `contents` lists only actual+asset names; scenery a zone builds itself belongs in its prose, not in invented asset ids. Water and terrain+share ONE surface sampler (`height_at` from the environment) and every placed thing is seated on+it or on what it stands on — the harness measures the gap. Geometry that exists only to continue+the world beyond the bounds is named with the `Sky` prefix (the census then keeps it out of the+content bbox).++## What the harness measures and the judge sees (plan so these hold)+- Every authored camera is rendered at t=0 s and t=1.5 s and judged as a picture of the brief's+ place. `cameras[0]` is measured as the establishing shot: content covers >= 20 % of its frame;+ every other authored camera >= 10 % (the rest being sky/ground). A lens inside a mesh or+ within 0.5 m of a surface caps the whole run.+- No world edge, horizon seam or box boundary is visible from any authored camera (judge; and+ outdoors the census checks that standing geometry >= 2 m tall reaches past 1.25 x the bounds'+ half-extent, and that the atmosphere's 1 / density is >= the plan span / 1.5 — a denser fog+ dissolves the world inside the content and reads as an edge). How the world continues is the environment builder's choice for this+ place.+- The ground is a believable landform for the place (judge): flat, sloped, terraced, a shore, a+ cliff — whatever the brief implies; every placed thing is seated on it or on what it stands on+ (placement gate: a gap > 0.05 m outdoors / 0.02 m indoors is floating, > 0.10 m into the+ support is sunken, overlapping neighbours interpenetrate — each caps the score).+- The lighting reads as the stated time of day and weather, and the frame is not monochrome+ unless the brief asks for it (judge; exposure is measured against a luminance band).+- Something moves visibly between t=0 s and t=1.5 s (motion probe), and motion the brief names+ is visible from the establishing camera.+- Repeated elements do not read as identical copies (judge), and >= 8 same-size copies spaced+ evenly on a ring round the world are measured as a stamped backdrop. A deliberately regular+ row the brief implies (an orchard, a colonnade, bollards along a quay) is fine.+- The place carries what its activity implies; a bare diorama on one plane is a judged defect,+ and a zone under half its layout's count gets an INFO note (the counts the brief states are acceptance items).+- The brief's must-haves are acceptance items; an unmet `must` caps the run at 0.60.++WHAT TO PRODUCE (JSON, fields: {{ schema_fields }}):+1. `title`, `summary` (two sentences), `setting` (place, era, weather, time of day), `mood`.+2. `bounds` — centre + extents in meters of the DETAILED area: where the builders spend their+ detail and what the harness measures against (zone layouts, placed assets — one sitting+ entirely outside is noted — and camera clearance). It is not a cage: the world continues past+ it as the place does — a road or river running out, a wall, a shoreline, far buildings,+ terrain that keeps going — and the environment builder builds that continuation. Size and+ proportion it to the brief's subject: a street is long and narrow, a courtyard small, a+ valley wide; a bigger box is not more detail.+3. `environment` — ONE paragraph of concrete numbers for what the brief's place needs:+ the sun / moon azimuth (compass: 0 = +X, 90 = +Y) + elevation in degrees and the time of day+ (dawn / morning / noon / golden / overcast / dusk / night — the builders' lighting table); the+ Sun lamp's colour + energy in W/m² and the sky world strength such that the judged frames land+ in the measured luminance band (pairs that did: day 3-5 W/m² at world 0.4-0.5, dusk 1-1.5 at+ 0.2, a moon 0.1-0.3 at 0.1), coloured for the weather; atmosphere: fog density + colour as a+ volume over the ground when the weather needs it (the census reads its density: 1 / density+ >= the plan span / 1.5); the LANDFORM — what the land does across the bounds and its height at each+ authored camera position (camera heights are absolute) — and the ground surface(s) with+ colours (RGB 0-1) and where walkways, roads or tracks run, as (x, z) routes with widths, when+ the brief has them (the zone layouts read them as `path_points`); how the world continues+ beyond the bounds in each direction and what the horizon is from the authored cameras (for an+ interior: what is seen through the openings); water height + colour, if any. Ponds, terraces+ and beds meet the terrain with no floating edge (placement gate).+4. `zones` — the brief's places, one builder each, with PascalCase names, a `bbox` (where that+ builder may place: layouts are validated against it with 1 m of slack) and `contents` = asset+ names placed there. Lay them out as the place is laid out — along a street, round a corner,+ radially about a well, scattered over a slope, one inside another — in any number and size;+ they need not cover the bounds, open ground between them is allowed, and two bboxes overlap by+ at most 1 m so their placements cannot collide. Each zone `description` states, as numbers:+ - what the place is and what happens there, and which authored cameras see it;+ - the layout: what stands where, spacing in meters, what faces what, what stands ON what;+ - the counts the brief fixes, and how much loose dressing this zone carries beyond its+ contents, as the place needs (the zone layout counts it in three fields — mid props, small+ props, ground cover — and the census notes a zone under half its count): a market is crowded,+ a quarry floor nearly bare, zero is a valid answer;+ - how repeated natural elements vary (silhouette, scale, hue) or why a regular row is right.+5. `assets` — the reusable things the brief needs; each is one builder session inside the run's+ time and cost ceiling. PascalCase `name`; `kind` = `bpy` (a procedural module placed as+ collection instances) or `blender_glb` (built as an object and shipped as a GLB: slower and+ costlier, so for the hero that needs sculpted or bevelled detail; a hero may also carry ONE+ 2 s keyframed motion — say so in its description); `description` with construction numbers+ and colours; `approx_size_m` = width x height x depth in meters (the built asset is measured+ against it: a stone lantern 0.5 x 1.6 x 0.5, a bench 1.6 x 0.9 x 0.6, a pine 3 x 7 x 3);+ `instances_hint` = how many appear in total. Triangle budget: <= 15 000 triangles per module,+ <= 40 000 for a hero (measured by the build census). Variation belongs inside an asset (say+ "5 variants via variant: three trunk shapes, two crown shapes") rather than in near-duplicate+ modules. Ground cover, terrain, water, sky and whatever continues the world beyond the bounds+ are built by the environment / zone builders, not as assets.+6. `effects` — 0 or more: `glsl_material` (a shader-node effect: water ripple, lantern glow, a+ translucent leaf), `particles` (petals, sparks, snow — a small keyframed instance cloud),+ `animated_geometry`, or `postprocess` (a volume: mist, light shafts); say which zone/asset owns+ each.+7. `animation` — what moves, each line with an amplitude visible in a 1024x576 frame between t=0+ and t=1.5 s (motion probe). Amplitudes that have measured as visible: foliage sway+ +/-0.10-0.20 rad; water ripples scrolling >= 0.15 m/s or a bob >= 0.04 m; particles travelling+ >= 0.6 m per 1.5 s; vehicles/boats/sails >= 1.5 m or a visible turn per 1.5 s; lantern flicker+ x0.75-x1.3. Motion the brief names is visible from the establishing camera.+8. `cameras` — 1 to 6 authored shots; the harness uses your numbers LITERALLY, so compute them+ from where the subject is and how big it is. `cameras[0]` is measured as the establishing+ shot: it shows the brief's subject clearly, with content >= 20 % of the frame. Every camera+ stands above the terrain at its own (x, z), keeps its lens >= 0.5 m from any surface and+ looks at content (>= 10 %). `purpose` says what the shot is of and what the judge should see+ in it. `fov` (vertical) is yours (schema 5-150). How many shots, from where and at what height+ is the brief's: a long open vista, a close interior, a walk along a street or a top-down court are+ each right when the place is.+9. `acceptance` — one item per must-have in the brief, plus the measured checks: nothing floating+ or sunken (`how: probe`), the named motion visible between t=0 and t=1.5 s (`probe`), no world+ edge from any authored camera (`visual`), lighting reads as the stated time of day (`visual`).+ **`priority` matters more than anything else in this list.** ANY unmet `must` item caps the+ whole run's score at 0.60, however good the pictures are — one over-specified detail throws+ away a passing scene. So:+ - mark `must` only items that restate a hard requirement of the brief itself, that a person+ can confirm from ONE rendered frame, and that name no incidental detail: "a raked gravel+ area is visible in the zen garden" is a `must`; "raked gravel with concentric rings around+ each rock" is a `should`;+ - `a1` is the premise: the kind of PLACE the brief describes, in the plainest words that+ would be false if the scene were somewhere else — "the view is from inside an enclosed+ workshop", "the courtyard is lit only by its lanterns at night". Measured 2026-08-25: a+ brief reading "INSIDE a boatbuilder's workshop" was planned as "Coastal boatyard, clear+ dusk", built faithfully as an outdoor yard, passed every gate and scored 0.4653. When the+ premise is INSIDE a built space, set `interior: true`: the environment module then owns the+ enclosure (floor, walls, ceiling, openings where `environment` puts them; the skeleton+ starts it on the bounds' faces and the builder may reshape it) and the zones dress the+ inside — six interior runs with no owner for walls and roof were each judged "not enclosed,+ a diorama on a flat plane" (0.0-0.3). When the enclosure itself is glass on a frame (a+ conservatory, greenhouse, palm house, glass atrium) also set `glazed: true`: the walls and+ roof are then glass on a grid that the sun and the outside come through;+ - everything else is `priority: should` — craft goals, counts, specific patterns, exact+ heights and anything needing evidence the judge may not have;+ - a `must` whose wording carries a number, a named style, or "and" joining two independent+ claims is rarely confirmable from one frame: split it or demote it.++RULES+- Every name in `zones[].contents` is an asset name; asset names unique; zone names unique.+- Realistic scale: people 1.7 m, doors 2.1 m, steps 0.17 m, benches 0.45 m seat height.+- No prose outside the JSON.++WORKED EXAMPLE — field SHAPE only. It is ONE place's plan (a harbour: an L of quay along one+side, open water on the other, the mole and the village street running out of the bounds); the+brief's place has its own shape, and its prose is terser than the plan you write:+{{ example_json }}++EXAMPLES OF THE CONCRETENESS WANTED — one bullet per place, none of them the harbour above; the+brief's place gets its own numbers:+- environment, a hangar interior: "Overcast noon through the open doors: no sun lamp; sky+ (0.81, 0.84, 0.87) seen through the 40 x 12 m door opening on the south face, world strength 0.5, twelve roof+ area lights (1.0, 0.95, 0.85) at 400 W on 8 m centres; a faint dust volume density 0.002 colour (0.69, 0.71, 0.72). Floor flat concrete (0.48, 0.48, 0.47) at y=0, 60 x 90 m,+ painted bay lines (0.85, 0.76, 0.35) every 15 m; the bounds are the hangar; outside the doors the apron+ continues 200 m to a treeline."+- environment, a slot canyon: "Noon sun azimuth 190 deg elevation 72 deg, Sun lamp (1.0, 0.94, 0.86)+ at 4.0 W/m2 reaching the floor only in a 3 m band, world strength 0.3 (the walls bounce+ orange); fog density 0.006 colour (0.85, 0.63, 0.44) in the slot (span 60 m). The floor is a sand wash (0.78, 0.63, 0.44)+ falling 4 m along z from +30 to -30 and keeps falling past the bounds; walls 14-22 m high+ 2-4 m apart, sandstone (0.72, 0.41, 0.23) banded (0.54, 0.29, 0.16) every 0.6 m, both run out of the bounds."+- environment, a night market: "22:00, no moon: world (0.05, 0.06, 0.12) at strength 0.15, no sun lamp; the+ stall lamps (1.0, 0.75, 0.44) at 150 W every 4 m along the lane with an emissive skin at 4, the+ shop signs emissive (1.0, 0.35, 0.54) / (0.25, 0.78, 1.0) at 6; fog density 0.004 colour (0.08,+ 0.09, 0.15) (span 80 m). The lane is+ flat wet asphalt (0.14, 0.15, 0.16) at y=0, 6 m wide, running out of the bounds both ways; two-storey+ shophouses (0.42, 0.35, 0.28) line it on both sides and continue past the bounds."+- a dense zone: "The lane's west side, seen by LaneWalk and Overview: 7 stalls 4 m apart facing+ the lane, each with its lamp and a crowd of 3-5 people in front, ~25 mid props (stools, crates,+ bins), ~60 small props (bowls, bottles, signs), no ground cover on the asphalt."+- a bare zone: "The canyon floor downstream, seen by Overview only: the sand wash, three fallen+ slabs 1-2 m and nothing else — it reads as a canyon because it is empty."+- camera purpose: "establishing: looking down the lane from its north end at eye height+ (subject: the stall row, ~30 m deep), the signs stacking into the fog; no sky in frame."diff --git a/harness/codeverse3d/prompts/variants/argon_raw/tracks/scene_asset_bpy.j2 b/harness/codeverse3d/prompts/variants/argon_raw/tracks/scene_asset_bpy.j2new file mode 100644index 00000000..13ad3a1e--- /dev/null+++ b/harness/codeverse3d/prompts/variants/argon_raw/tracks/scene_asset_bpy.j2@@ -0,0 +1,85 @@+# Scene asset `{{ asset_name }}` ({{ asset_kind }}) — write `{{ asset_file }}`++Scene: {{ spec_prompt }}+{% if fix_instructions %}+## FIX PASS — the asset was judged; apply exactly these changes and keep the rest+{% for i in fix_instructions %}+{{ i }}+{% endfor %}+{% endif %}++## The asset+- Name: `{{ asset_name }}`+- Size (width × height × depth, metres — the plan's Y-up order; in Blender x = width, y = depth, z = height): {{ '%.2f' % asset_size[0] }} × {{ '%.2f' % asset_size[1] }} × {{ '%.2f' % asset_size[2] }}+- Description: {{ asset_description }}+- Style of the whole scene: {{ style_notes or constraints }}++## Contract (raw bpy module; the harness builds it once and the zones instance it)+{{ frame_doc }}+{{ asset_contract }}+- `{{ asset_file }}` must define `def build_{{ asset_file.rsplit('/', 1)[-1][:-3] }}(ctx, variant=0)` that links+ every part into `ctx.collection` (its own Collection, pre-made and active) and returns it: built at+ the origin, lowest point on z = 0, footprint centred on the origin, front facing −Y, sized as stated+ (the check errors beyond 2.5 × or under 0.4 × on any axis; zones instance it at scale 1). Zone code places collection instances of `ctx.assets['{{ asset_file.rsplit('/', 1)[-1][:-3] }}']` by+ that origin and never calls you.+- Procedural mesh built in code (bmesh or `from_pydata`, any construction); every part carries a+ Principled material with a real colour and roughness (`Base Color`, `Roughness`, `Metallic`), varied at+ more than one scale (broad tone and wear plus fine grain or bump) where the real material varies.+ Objects are uniquely named PascalCase: one root mesh, or children parented under it at RELATIVE+ locations. No harness library ships in this scene: every part is raw `bpy` / `bmesh` / `mathutils`+ written in this file (an import of `lib` is a lint ERROR), and the module is self-contained.+- A natural thing has an organic silhouette (judged): a tree is a trunk branching into limbs that carry+ leaf or needle cards, a rock an irregular asymmetric mass — never a cone, a ball on a stick or a cube+ standing in for one.+- `variant` (0..n) and `ctx.rng(seed)` may vary details deterministically; `random.*` is a lint error.+- At most 15000 triangles for the whole asset (it is instanced; the census counts them).+- No lights, no cameras, no world, no file IO; the lint warns on `bpy.ops.mesh.primitive_*` in a loop;+ nothing outside the asset itself (no ground plane).+- MOTION (only when the description names a moving part — a swinging lamp, a turning wheel): keyframe+ that part's OWN rotation/location on `ctx.frame(0.0)` and `ctx.frame(1.5)` (LINEAR, set on the slotted+ action's `layers[0].strips[0].channelbag(action.slots[0]).fcurves`), or a simple driver of `frame`+ (`frame * 0.2`); put the part's origin at its pivot. Amplitude must read at scene+ distance (≥ 0.15 rad or ≥ 0.05 m registers in the frame difference).+{% if library_rows %}+- Reference rows the sheet names (no library ships in this scene; build what they describe yourself):+{{ library_rows }}+{% endif %}+{% if skeleton_files is defined and skeleton_files %}++## Current files (skeleton already in src/ — keep its structure, fill in every stub)+{% for path, body in skeleton_files.items() %}+--- {{ path }} ---+```+{{ body }}+```+{% endfor %}+{% endif %}++## DO / DON'T+- DO use the exact size numbers above; the zone builders and the placement gate rely on them.+- DO make it recognisable as the named thing at scene distance; the description decides its features+ and its condition.+- DO make `variant` (0..n) differ in SILHOUETTE when several copies are placed (the plan's count decides+ how many); a `variant` that only scales is a wasted asset.+- DO give a repeated natural asset colour room — `variant` / `ctx.rng(seed)`-driven colour is one way —+ so many copies do not read as one colour.+- DON'T model a flat plane with a colour where the thing has real thickness (a fence is stakes and+ rails, not a textured quad) — closeups are judged.+- DON'T leave floating pieces: every sub-shape overlaps a neighbour by ≥ 2 mm, and the lowest point+ is exactly z = 0 (the harness measures a part sunk below it or hovering above it).+- DON'T write anything outside the listed file.+{% if current_code %}++## Current file (edit and return COMPLETE)+```+{{ current_code }}+```+{% endif %}+{% if tool_cards and not single_shot %}++## Tools+{{ tool_cards }}+{% endif %}++## Output+{{ output_format }}diff --git a/harness/codeverse3d/prompts/variants/argon_raw/tracks/scene_env_bpy.j2 b/harness/codeverse3d/prompts/variants/argon_raw/tracks/scene_env_bpy.j2new file mode 100644index 00000000..b1cdf8fc--- /dev/null+++ b/harness/codeverse3d/prompts/variants/argon_raw/tracks/scene_env_bpy.j2@@ -0,0 +1,133 @@+# Environment module for `{{ title }}` — write `{{ env_file }}`++Scene: {{ spec_prompt }}+Setting: {{ setting }}. Mood: {{ mood }}.+Bounds (Z up, −Y front, metres — already converted from the plan): {{ bounds }}++## Environment plan (the brief's intent with its target numbers — checked by the frame table and the gates; its prose is Y-up: "y up" there is z here, "+z" there is −y here)+{{ environment }}+{% if interior and glazed %}+## This is a GLASS HOUSE — the enclosure is yours+The place must read enclosed in glass from every authored camera and be lit by what comes through it+(the frame gate's luminance band). Name the shell and lid meshes `RoomShell…` / `Ceiling…` so the+overview rig can lift the lid, and cut the plan's doors as openings. The frame, the panes (a thin+transmissive Principled material: `Transmission Weight` 1, low `Roughness`) and the house's shape+are yours to build here, in raw bpy / bmesh.+{% elif interior %}+## This is an INTERIOR — the enclosure is yours+An interior must read enclosed from every authored camera (measured 2026-09-07 over six interior runs+with no owner for walls and roof: every one was judged "not enclosed, a diorama on a flat plane",+0.0–0.3) and be LIT INSIDE (the frame gate's luminance band; the sun is outside, so a closed room+without openings and lights reads black). Name the lid meshes `RoomShell…` / `Ceiling…` (the overview+rig lifts the lid by name); windows and doors are openings the zones glaze or frame. The room's+shape, its openings and its extent are the brief's, built here in raw bpy / bmesh.+{% endif %}++## Contract+{{ frame_doc }}+{{ contract }}+No harness library ships in this workspace: the world, the lamps, the ground mesh, the atmosphere and+every material are raw `bpy` / `bmesh` / `mathutils` you write in this module (an import of `lib` is a+lint ERROR). Helpers the zones should reuse (a material builder, a mesh-linking or seating function)+are module-level functions here; zones `from env import` them.++### The harness assembles `{{ entry_file }}` and runs YOUR module like this — nothing else runs+```python+ctx.collection = scene root # build_env links into it+out = env.build_env(ctx) # ONE argument, and it is ctx+ctx.env = out if isinstance(out, dict) else {} # what the zones read as ctx.env+ctx.height_at = env.height_at # THE ground every zone seats on+```+So `{{ env_file }}` must define exactly:+- `def height_at(x, y) -> z` — the ground every zone seats on, deterministic and cheap; any walkable+ surface the brief's place has (a path, a terrace, a pond basin, a floor) is part of it, so what stands+ there stands on it. Under every plan camera position the ground stays below the camera (gate+ `camera_underground`, cap 0.50); otherwise the landform is the brief's — a floor, a slope, a basin, a+ street, a cliff are all valid.+- `def build_env(ctx) -> dict` — builds the world (sky), the scene's sun or moon lamp if the brief has+ one, the ground mesh (sampled from `height_at`, named `Ground…`), the atmosphere the probe requires (a+ volume) and whatever continues the world past the content (far geometry named `Sky…` so the census files+ it as backdrop) into `ctx.collection`, and RETURNS the dict zones read as `ctx.env` — e.g.+ `{"ground_material": …, "sun_direction": (x, y, z), "water_level": …}`; the keys are yours to name.+- Module-level names zones may `from env import …` (the skeleton's `SUN_AZIMUTH_DEG` / `SUN_ELEVATION_DEG`,+ compass 0 = +X / 90 = +Y, are one example).+The world (`bpy.data.worlds.new`, `ctx.scene.world =`) is YOURS and nobody else's: a zone that builds one+fails the lint. No cameras (the plan's), no `scene.render.*`, no frame changes.++## What this module is graded on (the requirement, and how it is measured)+1. **The ground reads as the brief's material**, not one flat untextured colour (judge `flat_ground`: no+ blending, no wear, undressed seams). Paving, snow, sand, decking, mud, a tiled floor all count, and the+ surface varies at more than one scale — broad tone, wear and slope / height bands over metres AND fine+ grain or bump over centimetres — in a node tree you wire on the ground's material.+2. **The world does not end in view.** From no authored camera may the ground stop against the sky or a+ backdrop float (judge `world_edge_visible`; the frame census reports "terrain ends N m ahead"). Two+ gates measure it outdoors: `world_edge` (standing geometry must reach past 1.25 × the bounds'+ half-extent) and `fog_short` (the census reads the volume's density: 1 / density has to stay ≥ span / 1.5). What+ continues the world is the brief's place — a street, a sea, a cliff, a forest, walls, hills on one side+ and open sky on another; far geometry is named `Sky…`, standing geometry is seated, and nothing is+ pre-tinted toward the fog (it reads as cardboard: judge `placeholder_material`).+3. **No plan camera below the ground** (`camera_underground`, cap 0.50): `height_at` under every camera+ position stays below its z. A ground feature must not read as a plate laid on the terrain from the+ overview cameras (judge `flat_ground`): carving it into `height_at` or giving it a built edge both work.+4. **Every authored frame lands in the exposure band** at the brief's time of day (`dark_frame`: mean+ luminance < 0.12 or > 35 % near-black, cap 0.55; blown frames likewise) and the light is not monochrome+ (judged). Cycles is physical. Starting values that have passed on a mid-albedo ground: a Sun of+ 1–5 W/m² (a moon 0.05–0.3), a world (a Sky Texture with its sun disc off beside the Sun lamp, or a deep+ colour for night) at strength 0.1–0.6, fog density 0.003–0.008 (a volume-only box over the play area);+ a brief lit by fire, neon, storm or nothing sets its own and reads `camera_checks.mean_lum`. Exposure is+ fixed at 0.+5. **Shadows read and shade carries colour** (judge `unlit_or_blown`, `lighting_atmosphere`: "flat+ shadows", "black shade"; the gate's `dark_frac`): a Sun `angle` of 1–3° with the sky world as fill is one+ way; any fill lamp you add is yours to justify by the frame table.+6. **What continues the world reads as real** (judged): far trees are trunks branching into limbs that carry+ leaf or needle cards, far rocks and hills are irregular masses — never cones, balls on sticks or cubes+ standing in for them (`asset_quality_detail`), and never one shape stamped in a ring (`stamped_ring`,+ `monotonous_vegetation`).+7. No {% if not (textures is defined and textures) %}image textures, no {% endif %}file IO, no unseeded randomness (`ctx.rng(seed)`); the lint warns on `bpy.ops.mesh.primitive_*` in a loop.++## DON'T+- No assets or zones here (they come from other modules). No cameras. No `scene.*` render / view settings.+- A route the zones must agree with (a lane, a towpath) is part of `height_at`, or a module-level name+ here that zones import — the one ground authority; the name is yours.++## Effects planned (only the ones targeting the environment)+{{ effects }}+{% if tool_cards and not single_shot %}++## Tools+{{ tool_cards }}+After editing run `build`, then `scene_views` and LOOK at every frame against the brief: does the+world end anywhere in view, is the ground one flat colour, is the shade black? Read the frame table+it prints: every authored camera must pass the exposure checks. `scene_probe` says whether the world+and the atmosphere were found.+{% 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 %}+{% if lib_interface is defined and lib_interface %}++## What the workspace's harness modules export (read from the files in this workspace)+{{ lib_interface }}+An import from them can bind only these names; a call passes only these parameters.+{% endif %}+{% if env_check_error is defined and env_check_error %}++## The previous single-shot of `{{ env_file }}` failed the harness's env check+```+{{ env_check_error }}+```+That file, as written (return it COMPLETE, with the failure fixed):+```+{{ env_previous }}+```+{% endif %}++## Output+{{ output_format }}diff --git a/harness/codeverse3d/prompts/variants/argon_raw/tracks/scene_refine_bpy.j2 b/harness/codeverse3d/prompts/variants/argon_raw/tracks/scene_refine_bpy.j2new file mode 100644index 00000000..41162b2a--- /dev/null+++ b/harness/codeverse3d/prompts/variants/argon_raw/tracks/scene_refine_bpy.j2@@ -0,0 +1,100 @@+# Refine `{{ title }}` — round {{ round_index }}++The scene builds and was rendered from the authored cameras at t=0 and t=1.5 s, then judged. Make+exactly the changes below, keep everything else, keep the build clean (no zone dropped, no Python+driver, nothing floating or sunken).++## Changes to make (priority order; `[gate/...]` items are hard failures — fix them first)+{% for t in tasks %}+{{ loop.index }}. {{ t }}+{% endfor %}++Targets: {{ targets | join(', ') }}+{% if edit_only_these %}+EDIT ONLY THESE FILES (other tasks edit other files in parallel):+{% for f in files %}- `{{ f }}`+{% endfor %}+{% else %}+Files in scope: {% for f in files %}`{{ f }}`{% if not loop.last %}, {% endif %}{% endfor %}+{% endif %}++## What the judge saw+{{ judge_summary }}++## Plan (unchanged truth; numbers below are in YOUR frame — Z up, −Y front, metres)+Bounds: {{ bounds }} · Setting: {{ setting }} · Mood: {{ mood }}+Environment (its prose is Y-up: "y" there is z here): {{ environment }}+Zones:+{{ zones_table }}+Cameras:+{{ cameras }}+Assets:+{{ asset_api }}+Effects:+{{ effects }}+Animation: {{ animation }}++## Acceptance checklist+{{ acceptance }}++## Reminders+{{ frame_doc }}+- A lighting / atmosphere / terrain / horizon change lives in `{{ env_file }}` (the world, the sun or+ moon lamp, the atmosphere volume, the ground and `height_at`, whatever continues the world).+- A composition/camera change is the plan's: `{{ entry_file }}` is harness data — move the SUBJECT+ (a zone's placement) rather than the camera.+- A zone change lives in its `src/zones/<zone>.py` (`def build(ctx)`, motion as keyframes on+ `ctx.frame(0.0)` / `ctx.frame(1.5)`); an asset change in `src/assets/<asset>.py`+ (`build_<asset>(ctx, variant=0)`).+- A dropped zone / asset (`zone_error`, `asset_error`): fix the named line; never wrap the whole+ builder in try/except to hide it.+- Everything rests on `ctx.height_at(x, y)` or on its support (move the root by the smallest+ `ctx.height_at(x, y) - z` over its foot band: the world-space vertices within max(0.02 m, 5 % of its height) of its lowest); nothing floats, sinks or runs through a+ neighbour (compare world bounding boxes). No harness library ships: everything is raw `bpy` / `bmesh`+ (an import of `lib` is a lint ERROR); code zones share lives in `{{ env_file }}`.+- No world or cameras outside `{{ env_file }}`, no file IO, no `random.*`, no Python drivers.++## The recurring findings on this track — what each measures, and where the requirement is stated+Do not re-explain the problem back — change what the finding measures. If a measured finding repeats,+change what it measures until its number passes; a repeated judge note needs a visible change in the+named view. The skills named below are in your session's skill list; the contract is above.++| what the judge / gate wrote | the requirement (and how it is measured) | stated in |+|---|---|---|+| flat / one-colour ground, hard raised-bed edges | the surface needs visible variation that matches the brief's material, and its seams dressed (judge `flat_ground`) | the env brief § 1; skill `c3d-bpy-scene-materials` |+| a hard world edge against the sky, missing horizon | from no camera may the ground end against the sky (`world_edge_visible`; gates `world_edge` / `fog_short`); what continues the world is the brief's — street, sea, cliff, forest, wall, fog | contract § What else the gates measure; skill `c3d-scene-atmosphere` |+| the backdrop looks like flat / beige / untextured cut-outs | a distant backdrop needs volume and lighting consistent with the sky; aerial perspective is the fog's job, never a pre-tint (`placeholder_material`) | skill `c3d-scene-atmosphere` |+| a pond / terrace is a hard-edged plane sitting on the ground | water and terraces meet the ground without a visible seam: carving into `height_at` (`{{ env_file }}`) or dressing the seam (the zone) are options; water is named `…Water` | skill `c3d-scene-water`; skill `c3d-bpy-scene-placement` |+| `floating` / `sunken` / `interpenetration` / `unsupported` (the placement gate's metres) | move the root by the printed metres: its lowest evaluated vertices onto `ctx.height_at` or its support, boxes apart; a rock may sit a third in, a crate may not | contract § Placement; skill `c3d-bpy-scene-placement` |+| "camera is N m below ground level" / `camera_in_geometry` | the eye must be above the ground under it and ≥ 0.5 m from any surface: move the subject or the zone's placement; the landform is the brief's | contract § What else the gates measure |+| identical cones / stacked blocks / primitive repetition | identical copies and primitive stacks are what the judge reads (`monotonous_vegetation`); a tree branches into limbs carrying leaf or needle cards, a rock is irregular (`asset_quality_detail`); vary where the brief has natural variety, regular things stay regular | the zone brief § 2 |+| sparse, token, "a diorama on a plane", empty midground | the brief's stated counts are requirements (the census compares them); empty regions the brief would fill get what it implies (`undressed_scene`, `empty_midground`) | the zone brief § 1; skill `c3d-scene-composition` |+| flat / dark / monochrome light, black shade, `dark_frame` | measured per camera (`mean_lum` / `dark_frac` / `blown_frac`); the brief's time of day and light sources decide; the lighting skill lists starting values that have passed | skill `c3d-bpy-scene-lighting`; skill `c3d-scene-night` |+| frames at t=0 and t=1.5 identical, "nothing moves", `nothing_moves` | the frame difference is measured per camera: LINEAR keyframes on `ctx.frame(0.0)` / `ctx.frame(1.5)` or `frame * k`; `python_driver` = a driver that needs Python, rewrite it | contract § Motion; skill `c3d-scene-motion` |+| `hard_edged_particles`, "sharp-edged quads / spheres / discs for steam, dust, sparks", the brief's "soft particle effect" must-item unverified | the finding measures sharp-edged particle geometry: in Cycles only a volume renders edgeless (a `ShaderNodeVolumePrincipled` into the Material Output's `Volume`, no surface shader), one root tagged free, moving ≥ 0.6 m | contract § What the renderer does |+| "plastic", "one grey material", `placeholder_material` | flags a surface with no authored colour / roughness; every surface needs a material that matches what it is, varied at more than one scale (broad tone and wear plus fine grain or bump) | skill `c3d-bpy-scene-materials` |+| `zone_error` / `asset_error` (a dropped module) | the named `file:line` — fix the raise; Blender 5.2 facts (no `use_nodes`, `Factor` not `Fac`, `ShaderNodeMix`, `Action.fcurves` is gone, GN inputs via `mod.properties.inputs`) | contract § Blender 5.2 API facts |+{% if current_files %}++## Current file contents (edit and return each COMPLETE)+{% for path, body in current_files.items() %}+--- {{ path }} ---+```+{{ body }}+```+{% endfor %}+{% endif %}+{% if tool_cards and not single_shot %}++## Tools+{{ tool_cards }}+Run `build` → `check_placement` → fix → `build` after editing (and `scene_probe` for the census);+finish only when both are clean. `artifacts/scene_probe.json` is the probe driver's raw dump (thousands of+lines); `check_placement` returns the placement rows, each with its gap and the tolerance it was measured+against. `check_placement` measures floating / sunken / unsupported /+interpenetrating assets deterministically — its numbers, not your impression. `scene_views` prints the+frame table and the MEASURED MOTION per camera — use those numbers, not your impression.+{% endif %}++## Output+{{ output_format }}diff --git a/harness/codeverse3d/prompts/variants/argon_raw/tracks/scene_zone_bpy.j2 b/harness/codeverse3d/prompts/variants/argon_raw/tracks/scene_zone_bpy.j2new file mode 100644index 00000000..61ee2440--- /dev/null+++ b/harness/codeverse3d/prompts/variants/argon_raw/tracks/scene_zone_bpy.j2@@ -0,0 +1,139 @@+# 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 as a collection-instance Empty — `bpy.data.objects.new(name, None)` with `instance_type =+'COLLECTION'` and `instance_collection = ctx.assets['<snake>']`, linked into `ctx.collection` and seated+on the ground (= ONE placement row); many copies are many Empties. No harness library ships in this+workspace: everything this zone builds is raw `bpy` / `bmesh` / `mathutils` (an import of `lib` is a lint+ERROR). 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)` (their f-curves on the slotted+action: `action.layers[0].strips[0].channelbag(action.slots[0]).fcurves`) and simple drivers of+`frame`; 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; scatter positions are yours to compute, seeded with `ctx.rng(seed)`.+2. **Repeated natural elements read as individuals** from the cameras (judge `monotonous_vegetation`:+ one shape stamped many times, in a ring or a grid). Source variants that differ in silhouette and hue+ (`build_<snake>(ctx, variant=k)`), per-instance rotation / scale and an Object Info `Random`-driven tint+ are ways; regular things (a colonnade, a row of bollards) stay regular. A tree is a trunk branching+ into limbs that carry leaf or needle cards, a rock an irregular asymmetric mass — never a cone, a ball+ on a stick or a cube standing in for one (`asset_quality_detail`).+3. **Seated, and clear of each other — measured.** Every placed root object rests on the surface it+ stands on (the gate samples up to 5 foot columns in its foot band — the evaluated vertices within+ max(0.02 m, 5 % of its height) of its lowest one: move the root by the smallest `ctx.height_at(x, y) - z`+ over that band's world-space vertices, or onto its support's top):+ 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 %). Compare the world+ bounding boxes of your roots AND the neighbours' placed things pair by pair 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): keep scatter points out of a+ radius around every lens. 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 (`f"{base}_{i}"`). Stay inside the triangle+ budget `scene_probe` reports; collection instances and geometry-nodes clouds (an Instance on Points+ tree over a patch) 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 (a+ volume-only material: `ShaderNodeVolumePrincipled` into the Material Output's `Volume`, no surface+ shader); 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.+8. **Surfaces read as their material** (judged `placeholder_material`): every large surface varies at+ more than one scale — broad tone and wear over metres AND fine grain or bump over centimetres — in a+ node tree you wire; one constant colour per surface reads as a placeholder.++## 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_raw/variant.toml b/harness/codeverse3d/prompts/variants/argon_raw/variant.tomlnew file mode 100644index 00000000..7d10255d--- /dev/null+++ b/harness/codeverse3d/prompts/variants/argon_raw/variant.toml@@ -0,0 +1,20 @@+# The `argon_raw` variant: gemini-4-argon writes EVERY line of a scene_blender scene. D113, 2026-10-17.+#+# Raw mode: no harness bpy library ships into the workspace (Settings.scene_lib off, the knob+# below), so every mesh, material, light, world and motion of the scene is the model's raw+# bpy / bmesh. The files beside this one shadow the scene_blender prompts (system, contract,+# asset, effects catalog), the four bpy stage templates and the bpy planner with copies that name+# no library; codeverse3d/skills/variants/argon_raw/ shadows the three bpy skill bundles likewise.+#+# Selection is explicit, never a regex over the model id:+# 3dcode make "..." --track scene --language scene_blender --variant argon_raw+# or C3D_VARIANT=argon_raw. `generators` below is informative.++[variant]+name = "argon_raw"+version = 1+generators = ["agy:gemini-4-argon"]+description = "gemini-4-argon on scene_blender in raw mode: no harness library, every line of bpy is the model's"++[knobs] # applied like a profile: a field the user stated (config.yaml / C3D_*) wins+scene_lib = false # no harness library in the skeleton; a `lib` import is a lint ERROR (D113)diff --git a/harness/codeverse3d/skills/variants/argon_raw/README.md b/harness/codeverse3d/skills/variants/argon_raw/README.mdnew file mode 100644index 00000000..61172cfb--- /dev/null+++ b/harness/codeverse3d/skills/variants/argon_raw/README.md@@ -0,0 +1,15 @@+# argon_raw — the skills overlay for scene_blender in raw mode++The skills half of the `argon_raw` variant (D113, 2026-10-17; the prompts half is+`codeverse3d/prompts/variants/argon_raw/`). Raw mode ships no harness bpy library, so the three+base bundles that taught the library's calls are shadowed here by copies that teach the raw bpy+each call stood for, with the same names, frontmatter rules and measured numbers:++* `c3d-bpy-scene-placement` — seating from world-space vertices, the pairwise box check;+* `c3d-bpy-scene-lighting` — sky, Sun / area lamps and fog volumes through `bpy.data`;+* `c3d-bpy-scene-materials` — multi-scale procedural surfaces wired as nodes.++Their pinned numbers are the base bundles' (`_claims/` is looked up here first, then in the base+library, and these copies keep every claimed sentence). `routes.toml` has no rows: the base+table routes the shadowed bundles by name. The run record's `extra.variant.hash` covers this+directory (README excluded) together with the prompts overlay.diff --git a/harness/codeverse3d/skills/variants/argon_raw/c3d-bpy-scene-lighting/SKILL.md b/harness/codeverse3d/skills/variants/argon_raw/c3d-bpy-scene-lighting/SKILL.mdnew file mode 100644index 00000000..e9d13112--- /dev/null+++ b/harness/codeverse3d/skills/variants/argon_raw/c3d-bpy-scene-lighting/SKILL.md@@ -0,0 +1,141 @@+---+name: c3d-bpy-scene-lighting+description: "Use when lighting a scene_blender env, zone, refine or rebuild session, or when scene_frames called a Blender frame too dark, blown out or flat. The harness renders with Cycles under AgX at exposure 0 and owns every render setting, so lamp energies, the world strength and the albedos are the only dials. Gives what the frame gate measures with its thresholds, the exposure bands measured for sky, sun, night, practical and interior setups under this renderer, the interface facts (the world is build_env's, what the census counts as atmosphere, which ceilings the overview rig lifts), the sky, lamps and fog in raw bpy (no library ships in raw mode), why an emissive mesh is not a lamp at 32 samples, and how to prove the band on every camera including the harness rig."+license: Apache-2.0+compatibility: Blender 5.2.2 LTS headless, scene_blender runtime; Cycles 32 samples + OIDN, AgX view transform, look None, exposure 0 — all harness-owned (render_bpy_scene.setup_render).+metadata:+ evidence: mixed+ evidence_note: 'The argon_raw (D113) copy of the base bundle with every library call replaced by the raw bpy it stands for; the measurements are the base bundle''s. The gate thresholds are read from live code (spatial/frame_metrics.py, runtime_js/lib/host_metrics.mjs) and the render setup from languages/wrappers/render_bpy_scene.py on 2026-10-14; the exposure bands were measured that day on Blender 5.2.2 LTS with that exact setup on a synthetic test scene (references/exposure-bands.md says how), not on run output. The corpus half is empty: the argon loop iteration 0 (2026-10-15) has not yet been tabulated per frame finding.'+ verified: "2026-10-17"+ target_metric: "bpy_exposure_findings"+ target_direction: "down"+ target_unit: "findings per run"+ target_measurable: "true"+ target_baseline: "n=0 — the argon loop iteration 0 (2026-10-15, 30 scene_blender runs) is the first sample; not yet tabulated"+---++# Lighting a Cycles scene the frame gate will accept++## What is fixed, and what is measured++The harness renders the authored cameras and the first overview rig views with Cycles at 32+samples plus denoising, AgX view transform, look None, exposure 0 — and it owns every one of+those settings: an assignment to `scene.render`, `scene.cycles` or `scene.view_settings` is a lint+ERROR (harness-owned). There is no exposure knob. Lamp energies, the world strength and the+albedos are the whole of your control.++The gate (`scene_frames`) reads the Blender PNGs with the statistics it reads three.js frames+with — per camera `mean_lum`, `lum_std`, `dark_frac`, `blown_frac` and `modal_frac` in the+`camera_checks` of `metrics.json`:++| finding | fires when | authored camera | harness rig view |+|---|---|---|---|+| `dark_frame` | mean luminance below 0.12, or more than 35 % of the pixels near black | ERROR | WARN |+| `dark_frame`, "dim but lit" | dark by the mean, but with contrast (`lum_std`) of at least 0.12 and not mostly black | WARN | WARN |+| `blown_frame` | more than 20 % of the pixels pure white | ERROR | WARN |+| `flat_frame` | one luminance band holds more than 85 % of the frame | WARN; ERROR above 92 % | WARN |++An ERROR of each kind is a score ceiling in the scene rubric, and every finding's hint carries the+scene_blender wording (lamps, world nodes, `ctx.height_at`), not the three.js one. The rig views+(`overview_*`) are WARN-only; the judge reads those pictures too.++## The bands, measured on this renderer++Measured 2026-10-14 on Blender 5.2.2 LTS with the harness's exact render setup, on a synthetic+scene (a flat ground plane of linear albedo a and six boxes; an eye-level camera with sky in the+top third, and a camera at the overview rig's angle). Numbers are `mean_lum`; the full tables+and the other four statistics are in `references/exposure-bands.md`.++| setup | `mean_lum` | what it says |+|---|---|---|+| the multiple-scattering sky alone, sun disc ON (a hand-built world), strength 0.05 / 0.2 / 1.0 (eye camera) | 0.63 / 0.82 / 0.96 | with its disc the physical sky IS daylight at strength 0.05-0.1; at 1.0 the sky starts to clip |+| sky 0.2 with the disc off + ONE sun lamp at 1 / 3 / 10 W per square metre, a = 0.3 (overview) | 0.57 / 0.63 / 0.73 | the lamp is a weak dial under AgX |+| the same sun at 3, ground albedo 0.03 / 0.15 / 0.6 (overview) | 0.32 / 0.52 / 0.72 | albedo is the strong dial |+| sun lamp 3 with the sky's disc ALSO on (two suns) | 0.83 | the doubled sun: washed, shadows fight |+| dark-blue night world alone / with a moon sun of 0.2 / 0.5 | 0.02 / 0.06 / 0.10 | too dark, and evenly so: no low-key escape, because `lum_std` stays under 0.05 |+| that night + two practical area lamps 2.5 m up at 45 / 150 / 500 W | 0.05 / 0.08 / 0.14 | 45 W is a look, not a light; 500 W per lamp passes, with contrast |+| that night + two fixture-sized emissive spheres at strength 5 / 80 / 320, no lamps | 0.03 / 0.05 / 0.09 | emission does not carry a frame; it needs a lamp beside it |+| a closed 6 m room, one 1 m ceiling area lamp at 50 / 200 / 800 W | 0.34 / 0.61 / 0.82 | interiors are easy: tens to hundreds of watts |++Two things fall out of the table. Under any daylight world nothing is dark and the risk is the+other two kinds: a uniformly coloured ground seen from the overview rig sat in the flat band+(`modal_frac` 0.84-0.95) in every daylight row, so value variance on the ground and+shadow-casting content are what break it, not more light. And at night the lamps that make the+picture pass are an order of magnitude stronger than the ones that make the fixtures glow.++## Interface, requirements, and ways that measured inside the band++* **Interface: the world is `build_env`'s.** A world created or assigned anywhere else is a+ harness-owned lint ERROR. Zones add lamps.+* **Requirement: one consistent sun direction, shadows that do not fight** (judged) **and every+ frame in the band** (measured). A physical sky with its disc on plus a sun lamp measured 0.83,+ washed, with doubled shadows; so did a second sun lamp in a zone. A matched pair is a world+ whose `ShaderNodeTexSky` (`sky_type = 'MULTIPLE_SCATTERING'`) has its sun disc off and a Sun+ lamp (`bpy.data.lights.new(name, "SUN")`, energy in W per square metre, `angle` for the+ softness) casting the shadows, both at the same compass angles; a Sun shines down its local+ -Z, so its rotation is the elevation's complement about X, then the azimuth plus 90 degrees+ about Z. A dark day moves with the albedos+ and the sun's `energy` more than with the world strength (the second and third rows).+* **The brief's hour decides the palette; the band still applies.** A world Background fed by a+ ColorRamp over the view direction's Z (horizon to zenith), or a flat deep night colour at a low+ strength, with a low or cool Sun lamp, are measured ways to sit in it for dusk, overcast and+ night; a warm key under a cool sky (a sky texture+ gives that for free) is what keeps shade from reading black or the frame from reading one+ orange tone (judged). Soft shadows come from a light's size (`angle` on a sun, `size` on an+ area lamp), which is one lamp, not two.+* **Interface: atmosphere is counted from the census.** The `no_fog` plan check fires when the+ census finds no volume at all; a volume-only mesh (only the Material Output's Volume socket+ linked, fed by a `ShaderNodeVolumePrincipled`) counts, and the placement gate ignores it. A box+ mesh with that material is the simplest one; a local mist over a pond or a hollow, or a light shaft (a higher+ `Anisotropy` where the sun crosses an opening) is the same material on any volume-only mesh. A+ world volume over a large scene measured as swallowing the sun and flattening the frame. How+ thick the air is, and its colour, is the brief's; `fog_short` warns when the density would+ dissolve the plan's own span.+* **Lamps in zones are yours** — `bpy.data.lights.new(name, "AREA" | "POINT" | "SPOT")` on an+ object linked into `ctx.collection`; a "practical" is a small soft area lamp beside a lantern,+ window, fire or sign, aimed at what it lights. A glow-sized energy (tens of watts) lights the+ surfaces beside it, not a frame: two such lamps measured `mean_lum` 0.05 (an ERROR); hundreds+ of watts each is where a night frame passed. Create lamps through `bpy.data.lights.new`;+ operators in a loop are a hang-risk lint finding, and `bpy.ops.object.light_add` wants a+ view-layer context the build does not give.+* **An emissive mesh is the look, not the light.** Cycles does scatter light from an emissive+ surface, but a fixture-sized emitter throws almost nothing a frame can measure: two 0.15 m+ emissive spheres at the strengths that make a lantern read as lit left the night frame at+ `mean_lum` 0.03, and at forty times that strength — white blobs — it was still an ERROR; the+ same scene passed once each sphere had a 500 W practical area lamp beside it (reference,+ section 4). Emission on the fixture (`Emission Color` with a modest `Emission Strength`),+ illumination in a lamp, and the emission modest: AgX pulls a saturated emitter toward white, so a strong neon tube renders as a white bar.+* **Interiors.** The band applies on every authored camera inside, and the overview rig lifts a+ lid it can identify: a mesh named `Ceiling…` whose parent is named `RoomShell…` and whose+ evaluated bbox top is below the camera is hidden for that rig frame (`lift_lids` in+ `render_bpy_scene`, the three.js host's rule): name your shell that way. A ceiling area lamp+ sized to the room measured 0.34-0.82 at 50-800 W, and an emissive window pane with an area+ lamp just inside it is one way to light a room by day. The indoor placement tolerance is+ tighter, so a lamp on a table is seated on the table's top too.+* **Albedo before light.** A ground whose Base Color is near black stays dark under any sun, and a+ plaster wall clips under the sun that lights a lawn correctly. The large surfaces' albedo is the+ strong dial (the third row), the sun the weak one, the practicals the local one.++## Night: the band, not the floor++Target: the "dim but lit" band on every authored camera — mean low, `lum_std` at least 0.12, not+mostly black. Both ends fail: a sky-lit average on a lantern scene is a grey wash (a flat frame,+and the judge's unlit-or-blown defect), and glowing fixtures with no lamps behind them are a black+frame with stickers. Measured on this renderer: a low night world, each fixture paired with a+practical area lamp at hundreds of watts so the pools overlap into a readable picture, dark materials+with a low but non-zero Base Color and shadows left dark reached the band; a fill lamp that lifts+the mean pushed it to a flat wash.++## The hero must be visible++The frames gate also reports `hero_unseen` and `hero_small_in_its_camera`; a hero in shadow at+night is a hero the judge cannot find. Its own key — a practical area lamp or a spot aimed at it (a Track To constraint, or a+rotation computed from the direction) — and a look at its camera's frame.++## Prove it++`scene_views(cameras="all", times=[0.0])`, then read `camera_checks` per camera against the+first table: the same five numbers the gate uses. A Blender view costs seconds, so render once+per change, all cameras, and fix whatever the finding names on EVERY camera, rig views included.++Full measured tables, the night and interior setups as code: `references/exposure-bands.md`.diff --git a/harness/codeverse3d/skills/variants/argon_raw/c3d-bpy-scene-lighting/references/exposure-bands.md b/harness/codeverse3d/skills/variants/argon_raw/c3d-bpy-scene-lighting/references/exposure-bands.mdnew file mode 100644index 00000000..39954cbb--- /dev/null+++ b/harness/codeverse3d/skills/variants/argon_raw/c3d-bpy-scene-lighting/references/exposure-bands.md@@ -0,0 +1,132 @@+# Exposure bands under Cycles + AgX at exposure 0++Companion to `c3d-bpy-scene-lighting`. The thresholds are `codeverse3d/spatial/frame_metrics.py`'s+(read 2026-10-14); the pixel statistics are `runtime_js/lib/host_metrics.mjs`'s and are applied to+the Blender PNGs unchanged: luminance is the Rec. 709 weighting of the 8-bit sRGB pixels, "near+black" is the bottom few of the 256 levels, "pure white" is all three channels at the top, and the+modal band is the fullest of eight equal luminance bands.++## 1. The gate's numbers++| statistic | threshold | finding |+|---|---|---|+| `mean_lum` | below 0.12 | `dark_frame` (ERROR on an authored camera) |+| `dark_frac` | above 35 % | `dark_frame` |+| `lum_std` | at least 0.12 while dark by the mean and not mostly black | the same finding downgraded to "dim but lit", a WARN |+| `blown_frac` | above 20 % | `blown_frame` |+| `modal_frac` | above 85 % | `flat_frame` WARN; ERROR above 92 % on an authored camera |++A frame that is dark is not also reported flat; a frame can be dark by the mean with not one+near-black pixel, or bright on average and still fail on the black fraction — fix whichever one+the message names.++## 2. How the bands were measured++Blender 5.2.2 LTS, the harness's `setup_render` verbatim (Cycles, CUDA, 32 samples, adaptive,+OIDN, AgX, look None, exposure 0, sRGB 8-bit PNG), 192 x 108 pixels, 2026-10-14. Scene: a 200 m+ground plane of linear albedo a (roughness 0.85), six boxes 0.9-3 m of albedo 0.4. Cameras: eye+level 1.6 m looking slightly down with the sky in the top third (`eye`), and a camera 25 m out at+the overview rig's azimuth and elevation (`overview`). Sun elevation 35 degrees. These are bands+for a bare scene, not rules: real content adds shadow, colour and contrast.++## 3. Daylight++The multiple-scattering sky alone, sun disc on, a = 0.3:++| sky strength | eye `mean_lum` | overview `mean_lum` | note |+|---|---|---|---|+| 0.02 | 0.45 | 0.44 | an overcast-looking day |+| 0.05 | 0.63 | 0.62 | daylight |+| 0.1 | 0.74 | 0.73 | bright daylight |+| 0.2 | 0.82 | 0.82 | hazy, washed |+| 0.5 | 0.91 | 0.91 | the ground is pale |+| 1.0 | 0.96 | 0.96 | `blown_frac` 0.11 on the eye camera: the sky clips |++Sky at 0.2 with the disc off plus ONE sun lamp (overview camera):++| sun lamp (W per square metre) | a = 0.03 | a = 0.08 | a = 0.15 | a = 0.3 | a = 0.6 |+|---|---|---|---|---|---|+| 1 | 0.28 | 0.37 | 0.45 | 0.57 | 0.68 |+| 3 | 0.32 | 0.42 | 0.52 | 0.63 | 0.72 |+| 5 | 0.36 | 0.47 | 0.56 | 0.67 | 0.76 |+| 10 | 0.43 | 0.55 | 0.64 | 0.73 | 0.81 |++Read the rows and the columns against each other: a tenfold sun moves the frame by about 0.15,+a twentyfold albedo by about 0.4. The eye camera, with the sky in it, sat at 0.59-0.81 across+the same grid — the sky carries an eye-level frame's mean on its own. With the sky's disc left on+beside the lamp (sun 3, a = 0.3) the overview rose from 0.63 to 0.83: two suns.++`modal_frac` on the overview camera was 0.80-0.95 in every daylight row: a single-colour ground+lit evenly IS a flat frame by the gate's definition. Value variance on the ground, shadows from+content and a horizon in the frame are what move it, not the sun.++## 4. Night++Flat dark-blue world (a night sky colour at strength 0.3), a = 0.3, no sun:++| setup | eye `mean_lum` / `lum_std` / `dark_frac` | overview | verdict |+|---|---|---|---|+| world alone | 0.02 / 0.02 / 0.57 | 0.01 / 0.00 / 1.00 | `dark_frame` ERROR |+| + moon sun 0.05 | 0.03 / 0.01 / 0.57 | 0.03 / 0.01 / 1.00 | ERROR |+| + moon sun 0.2 | 0.06 / 0.02 / 0.02 | 0.07 / 0.02 / 0.08 | ERROR: dark by the mean, no contrast to rescue it |+| + moon sun 0.5 | 0.10 / 0.05 / 0.01 | 0.13 / 0.03 / 0.07 | eye ERROR, overview passes |+| + two point lamps 3 m up, 100 W | 0.06 / 0.04 / 0.11 | 0.05 / 0.06 / 0.59 | ERROR |+| + two point lamps, 500 W | 0.13 / 0.12 / 0.07 | 0.14 / 0.13 / 0.21 | passes |+| + two point lamps, 2000 W | 0.25 / 0.22 / 0.04 | 0.28 / 0.20 / 0.09 | passes with room to spare |+| + two practical area lamps 2.5 m up, 45 W | 0.05 / 0.05 / 0.35 | 0.04 / 0.07 / 0.79 | ERROR: a glow-sized lamp, not illumination |+| + two practicals, 150 W | 0.08 / 0.09 / 0.14 | 0.08 / 0.12 / 0.55 | ERROR on the eye camera; the overview is dim-but-lit |+| + two practicals, 500 W | 0.14 / 0.16 / 0.07 | 0.14 / 0.18 / 0.28 | passes |+| + two 0.15 m emissive spheres 2.5 m up, strength 5 (no lamps) | 0.03 / 0.04 / 0.57 | 0.01 / 0.03 / 0.99 | ERROR: the fixtures glow, the ground does not |+| + the same spheres at strength 20 / 80 | 0.03 / 0.04 / 0.51 and 0.05 / 0.05 / 0.30 | 0.02 / 0.04 / 0.93 and 0.04 / 0.06 / 0.78 | ERROR |+| + the same spheres at strength 320 (white blobs) | 0.09 / 0.10 / 0.08 | 0.09 / 0.11 / 0.38 | ERROR on the eye camera still |+| + spheres at strength 8 AND two 45 W practicals | 0.05 / 0.06 / 0.35 | 0.04 / 0.07 / 0.81 | ERROR |+| + spheres at strength 8 AND two 500 W practicals | 0.14 / 0.16 / 0.08 | 0.12 / 0.17 / 0.38 | the eye camera passes; the overview rig is a dim-but-lit WARN |++The low-key escape needs contrast: an evenly moonlit plane has `lum_std` far below 0.12 at every+moon strength and fails as unlit however blue it is. Practicals create the contrast; what they+need is energy — hundreds of watts a lamp a few metres up, over a ground that is not black. An+emissive fixture is not that lamp: its strength decides how the fixture looks, and the frame's+mean barely moves until the fixture is a white blob, which the judge grades as blown.++```python+def lamp(ctx, name, kind, loc, color, watts, size=0.4): # a lantern-lit night, one way+ light = bpy.data.lights.new(name, kind)+ light.energy, light.color = watts, color+ if kind == "AREA":+ light.size = size+ ob = bpy.data.objects.new(name, light)+ ob.location = loc+ ctx.collection.objects.link(ob)+ return ob+# each fixture: an emissive skin (the look) AND lamp(ctx, f"LanternLight_{i}", "AREA", ..., <hundreds of W>)+```++## 5. Interiors++A closed 6 m x 6 m x 3 m room (walls a = 0.6, floor a = 0.3, a table and a crate), one 1 m square+area lamp at the ceiling, an eye-level camera inside:++| lamp | `mean_lum` | `modal_frac` |+|---|---|---|+| 50 W | 0.34 | 0.45 |+| 200 W | 0.61 | 0.60 |+| 800 W | 0.82 | 0.85 |+| 3000 W | 0.94 | 0.89 |++Interiors need tens to hundreds of watts per lamp, and the failure mode above a few hundred is the+flat band (one pale tone), not clipping — AgX refused to blow out even the 3000 W room.++```python+def build_env(ctx): # a lit room+ ... # the shell: walls, floor and a lid named Ceiling... under RoomShell...+ lid_lamp = bpy.data.lights.new("CeilingLight_0", "AREA")+ lid_lamp.energy, lid_lamp.size, lid_lamp.shape = <tens to hundreds of watts>, <about a metre>, "SQUARE"+ ob = bpy.data.objects.new("CeilingLight_0", lid_lamp)+ ob.location = (<cx>, <cy>, <just under the ceiling>) # an area lamp shines down its -Z+ ctx.collection.objects.link(ob)+```++## 6. The check++`scene_views(cameras="all", times=[0.0])` writes `camera_checks` with the five statistics per+camera, authored and rig. Read them; then change one dial at a time.diff --git a/harness/codeverse3d/skills/variants/argon_raw/c3d-bpy-scene-materials/SKILL.md b/harness/codeverse3d/skills/variants/argon_raw/c3d-bpy-scene-materials/SKILL.mdnew file mode 100644index 00000000..5c9fc037--- /dev/null+++ b/harness/codeverse3d/skills/variants/argon_raw/c3d-bpy-scene-materials/SKILL.md@@ -0,0 +1,124 @@+---+name: c3d-bpy-scene-materials+description: "Use in every scene_blender env, zone, asset or refine session that authors a surface — ground, walls, props, foliage, water, glass, a glowing sign, steam. Cycles renders every node you wire, but the harness's census reads only three Principled sockets, so no gate rewards material work and the judge penalises the lack of it. Gives the Blender 5.2 node facts (no use_nodes, the 4.x socket names, ShaderNodeMix), what the judge names and what it measures, the node practices for multi-scale surfaces in raw bpy (no library ships in raw mode), variation across copies without identical twins, ground that varies where the brief's surface does, water, glass and emissive done as dielectrics and fixtures, soft particles as volumes, and what to zoom on before you finish."+license: Apache-2.0+compatibility: Blender 5.2.2 LTS headless, scene_blender runtime; Cycles 32 samples + OIDN under AgX (the harness's render settings), Principled BSDF 4.x socket names.+metadata:+ evidence: mixed+ evidence_note: 'The argon_raw (D113) copy of the base bundle with every library call replaced by the node practice it stands for. The census facts are read from live code on 2026-10-14 (wrappers/_census_glb.py, wrappers/_census.py, the languages/blender lint tables verified against Blender 5.2.2 LTS) and the defect wording from the scene judge rubric. The corpus half is the argon loop iteration 0 of 2026-10-15 (30 scene_blender runs): 8 scenes built hard-edged particles from surface shaders.'+ verified: "2026-10-17"+ target_metric: "flat_principled_materials"+ target_direction: "down"+ target_unit: "materials whose Base Color, Roughness and Metallic are all unlinked constants (prospective census)"+ target_measurable: "false"+ target_baseline: "n=0 — the census does not yet record the count; the argon loop iteration 0 (2026-10-15) is the first sample once it does"+---++# Surfaces that read as a place — Principled recipes the census cannot see++## Who sees what++The judge sees Cycles pixels: every noise texture, bump and vertex colour you wire is in the+picture, and the rubric names the failures directly — `placeholder_material` (default-grey or+untextured flat surfaces, with a score ceiling of its own), `flat_ground` (one flat colour with+a hard undressed seam where objects meet it), `monotonous_vegetation` (one shape stamped many+times with no variation in hue or size) and `hard_edged_particles` (steam, smoke or sparks with a+silhouette) — under its `materials_shaders_effects` criterion. The deterministic side sees almost+nothing: the census GLB the gates read carries each material's Principled `Base Color`,+`Metallic` and `Roughness` default values only, and a LINKED socket exports as its default. So+no gate measures material work; this sheet is about the judge's picture, plus the one census+fact that does bite — a mesh with no material at all is warned as exporting grey.++## Blender 5.2 facts the lint checks++* `bpy.data.materials.new(name)` already carries a node tree with a Principled BSDF: reach into+ `mat.node_tree.nodes["Principled BSDF"]`. A `use_nodes` line is not needed, and the lint+ reports it as deprecated.+* Socket names are the 4.x ones — `Base Color`, `Roughness`, `Metallic`, `IOR`, `Alpha`,+ `Normal`, `Emission Color` plus `Emission Strength`, `Transmission Weight`, `Coat Weight`,+ `Sheen Weight`, `Subsurface Weight`, `Specular IOR Level`. The old `Specular`, `Transmission`,+ `Emission`, `Subsurface` and `Clearcoat` keys raise, and the lint names the renamed ones for+ you. `Specular Tint` is a colour, so assign a 4-tuple.+* Mixing colours is `ShaderNodeMix` with its data type set to RGBA (`Factor`, `A`, `B` in,+ `Result` out); `ShaderNodeMixRGB` is gone.+* Per-face materials: set `material_index` on the bmesh faces BEFORE `bm.to_mesh`. Every new+ polygon starts on slot 0, and the census warns about slots no polygon uses — the part was+ authored in four colours and exports in one.++## Surfaces in raw nodes — what reads as photoreal++No library ships: every material is a node tree you wire on `mat.node_tree`. What the judge reads+as real is variation at MORE THAN ONE SCALE, in object or generated coordinates so it is metres+whatever the object's size:++| scale | what carries it | nodes |+|---|---|---|+| metres — tone, wear, damp, sun-bleach | a low-frequency mask mixing two close colours | Noise texture (`Scale` ~0.2-1 per metre) into `ShaderNodeMix` (RGBA) |+| decimetres — courses, planks, patches | a pattern the material has | Brick / Wave / Voronoi texture, or a ColorRamp over noise |+| centimetres — grain, pores, grit | fine bump and roughness breakup | Noise / Voronoi (`Scale` 20-200) into `ShaderNodeBump` and through a Map Range into `Roughness` |++Keep non-emissive albedos inside 0.02-0.8 linear: pure black reads as a hole, pure white as a+blown surface. A copy is not a twin when its variant picks other colours or an Object Info+`Random` drives a small hue shift (below). A glowing fixture is `Emission Color` with a modest+`Emission Strength` — the look only; the light is a lamp (c3d-bpy-scene-lighting). Steam, smoke,+dust and mist are a volume-only material (below). Node snippets in+`references/principled-recipes.md`.++## Variation without twins++Collection instances share the source collection's materials, so per-instance tinting is not+"edit the material". Variation across copies comes from (a) several SOURCE variants —+`build_<snake>(ctx, variant=k)` building with other colours and another silhouette — placed in+rotation, (b) per-instance scale and yaw on each instance Empty, and (c) for one material+over many copies, an Object Info node's `Random` output driving a hue shift, which Cycles+evaluates per instance. The `stamped_ring` plan check measures rings of identical copies at one+radius, and the judge calls the result monotonous vegetation.++## Ground: what `flat_ground` means++Requirement (judged): the ground does not read as one flat untextured colour where the brief's+surface would vary, and the seam where structures meet it does not read as a hard undressed line.+A ground mesh usually carries ONE material, so the variation lives inside it or in the mesh's own+attributes. Options, by what the brief's place has: a slope mix (the Geometry node's `Normal`,+its Z through a ColorRamp into the mix factor) and a height mix (object Z from Texture+Coordinate) for natural ground; a worn band as a noise-masked colour along the routes people+take; a darker or rougher apron, or ground cover (a geometry-nodes Instance on Points cloud), at the+feet of big structures; a colour attribute on the ground mesh read by a Color Attribute node when+the bands are easier to paint per vertex than to compute per pixel; paving (a Brick texture, or+modelled setts) where the ground is built, not grown. A polished floor or a plaza that IS one+material is not a defect when its material reads as that material.++## Water, glass, fog — dielectrics and volumes++* Water is a dielectric: `Transmission Weight` 1, a low roughness and `Metallic` at zero; a+ metallic mirror plane reads as chrome, not water. Moving water scrolls its Mapping node's+ `Location` input with keyframes on `ctx.frame(t)`.+* Glass: full `Transmission Weight`, roughness near zero, `IOR` about 1.45-1.5. The bounce+ budget is the harness's, so a stack of transmissive layers along one sight line goes dark —+ one or two read.+* Fog is a VOLUME-ONLY material on any mesh (a box is enough): only the Material Output's Volume+ socket linked. A mesh with a surface shader as well is matter to the census — a+ huge placed asset enclosing everything — and the `no_fog` check does not count it as atmosphere.+* Soft particles are volumes too. A surface shader always has a silhouette; 8 of the 30 argon+ Blender scenes of 2026-10-15 built steam from translucent ico-spheres, metaballs, stacked tori,+ discs or polygon sparks and were graded `hard_edged_particles`. A volume-only material on a+ cloud of spheres (one mesh, one object, tagged `placement = "free"`, keyframed so the two+ judged frames differ) rendered with no edge, and 40 such puffs added 0.7 s to a 32-sample GPU+ frame; motes and sparks read as tiny emissive spheres. Under a dim world a volume with zero `emission` comes out grey.++## Emissive and metal under AgX++AgX desaturates bright emitters toward white: a saturated sign needs a modest+`Emission Strength` and a coloured area lamp beside it for the glow on the ground. Metals need+something to reflect — the sky world and the haze are what a worn metal mirrors; a metal under a+black world is a black shape.++## Verify before you finish++`scene_views(cameras="authored", times=[0.0])` and zoom one frame: a wall or a ground that is one+flat value where the brief's would not be needs variation; two copies you cannot tell apart+need variants; a grey default is a mesh that never got a material (the build output warns about+it by name). Then `scene_probe` for triangle counts — materials are free, geometry is not.++Node snippets — noise to bump, the slope mix, the Object Info tint, per-face slots, the+volume-only material, the socket rename table — in `references/principled-recipes.md`.diff --git a/harness/codeverse3d/skills/variants/argon_raw/c3d-bpy-scene-materials/references/principled-recipes.md b/harness/codeverse3d/skills/variants/argon_raw/c3d-bpy-scene-materials/references/principled-recipes.mdnew file mode 100644index 00000000..4b2b42e3--- /dev/null+++ b/harness/codeverse3d/skills/variants/argon_raw/c3d-bpy-scene-materials/references/principled-recipes.md@@ -0,0 +1,116 @@+# Principled recipes — the node snippets++Companion to `c3d-bpy-scene-materials`. Socket names and node ids verified against Blender+5.2.2 LTS on 2026-10-14 (`codeverse3d/languages/blender/__init__.py` keeps the rename table the+lint reports from). Every snippet assumes `mat = bpy.data.materials.new(name)` and+`nodes, links = mat.node_tree.nodes, mat.node_tree.links`, `bsdf = nodes["Principled BSDF"]`.+No library ships in raw mode: these are the nodes; a material builder you reuse goes in+`src/env.py` for the zones.++## 1. Socket renames the lint reports++| old key (raises) | 4.x / 5.x key |+|---|---|+| `Specular` | `Specular IOR Level` |+| `Subsurface` | `Subsurface Weight` |+| `Subsurface Color` | folded into `Base Color` |+| `Transmission` | `Transmission Weight` |+| `Transmission Roughness` | removed — use `Roughness` |+| `Emission` | `Emission Color`, with `Emission Strength` |+| `Clearcoat` | `Coat Weight` |+| `Sheen` | `Sheen Weight` |++`Specular Tint` and `Anisotropic` still exist; `Specular Tint` is an RGBA colour.++## 2. Value variance: noise into colour and bump++```python+noise = nodes.new("ShaderNodeTexNoise")+noise.inputs["Scale"].default_value = <features per metre: 2-5 cm at walking distance>+mix = nodes.new("ShaderNodeMix")+mix.data_type = "RGBA"+mix.inputs["A"].default_value = (<r>, <g>, <b>, 1.0) # the base colour+mix.inputs["B"].default_value = (<r2>, <g2>, <b2>, 1.0) # a few percent darker or warmer+links.new(noise.outputs["Fac"], mix.inputs["Factor"])+links.new(mix.outputs["Result"], bsdf.inputs["Base Color"])+bump = nodes.new("ShaderNodeBump")+bump.inputs["Strength"].default_value = <0.05-0.15 for stone and plaster>+links.new(noise.outputs["Fac"], bump.inputs["Height"])+links.new(bump.outputs["Normal"], bsdf.inputs["Normal"])+```++Roughness variation is the same noise into `Roughness` through a Map Range node. For more than+one scale, add a second noise at a much larger `Scale` into the bump (grain) and keep the first+on the colour (tone); a Voronoi in between gives patches, cells or pebbles.++## 3. Ground bands by slope and height++```python+geo = nodes.new("ShaderNodeNewGeometry")+sep = nodes.new("ShaderNodeSeparateXYZ")+links.new(geo.outputs["Normal"], sep.inputs["Vector"])+ramp = nodes.new("ShaderNodeValToRGB") # a ColorRamp: slope -> 0..1+ramp.color_ramp.elements[0].position = <cos of the rock angle> # element 1 a few hundredths higher: a soft edge+links.new(sep.outputs["Z"], ramp.inputs["Fac"])+mix = nodes.new("ShaderNodeMix")+mix.data_type = "RGBA"+links.new(ramp.outputs["Color"], mix.inputs["Factor"])+links.new(<rock colour node>.outputs["Result"], mix.inputs["A"])+links.new(<grass colour node>.outputs["Result"], mix.inputs["B"])+links.new(mix.outputs["Result"], bsdf.inputs["Base Color"])+```++Height bands use the Object output of a Texture Coordinate node, Z through a second ramp.+A worn route is a further colour masked by a low-frequency noise along its polyline. These are+options for natural ground; built ground (paving, a floor) carries its own material instead.++## 4. One material, many copies: the Object Info tint++```python+info = nodes.new("ShaderNodeObjectInfo")+hsv = nodes.new("ShaderNodeHueSaturation")+links.new(info.outputs["Random"], hsv.inputs["Hue"]) # 0..1 per object / instance+hsv.inputs["Saturation"].default_value = 1.0+links.new(<colour node>.outputs["Result"], hsv.inputs["Color"])+links.new(hsv.outputs["Color"], bsdf.inputs["Base Color"])+```++`Random` differs per instance in Cycles, so the shrubs placed from one source collection no+longer match; keep the hue swing small (a Map Range from `Random` into a narrow band around+0.5) or the copies look like different species.++## 5. Per-face slots, before `bm.to_mesh`++```python+me.materials.append(stone) # slot 0+me.materials.append(moss) # slot 1+for f in bm.faces:+ f.material_index = 1 if f.normal.z > 0.7 else 0+bm.to_mesh(me)+```++The census reports a slot no polygon uses; assigning after `bm.to_mesh` goes through+`me.polygons` instead.++## 6. The volume-only box (fog the census recognises)++```python+mat = bpy.data.materials.new("Haze")+nodes, links = mat.node_tree.nodes, mat.node_tree.links+nodes.remove(nodes["Principled BSDF"]) # no surface shader at all+vol = nodes.new("ShaderNodeVolumePrincipled")+vol.inputs["Density"].default_value = <0.002-0.02>+links.new(vol.outputs["Volume"], nodes["Material Output"].inputs["Volume"])+```++Any mesh whose only linked output is Volume is fog to the census — a box over the play area is+the simplest. With the Surface socket linked as well it is a placed asset to the gate. The same+shader with a noise texture into `Density` is steam and mist.++## 7. Water and glass, the sockets that matter++| material | the sockets that matter |+|---|---|+| water | `Transmission Weight` at one, `Roughness` low, `Metallic` zero, a bump from scrolled noise; the plane is named with a water word so feet on it count as on water |+| glass | `Transmission Weight` at one, `Roughness` near zero, `IOR` about 1.45-1.5; thin panes as single faces with a Solidify-free thickness read best at 32 samples |+| emissive | `Emission Color` and a modest `Emission Strength`; the illumination is an area lamp beside it |diff --git a/harness/codeverse3d/skills/variants/argon_raw/c3d-bpy-scene-placement/SKILL.md b/harness/codeverse3d/skills/variants/argon_raw/c3d-bpy-scene-placement/SKILL.mdnew file mode 100644index 00000000..5d8bfd6e--- /dev/null+++ b/harness/codeverse3d/skills/variants/argon_raw/c3d-bpy-scene-placement/SKILL.md@@ -0,0 +1,150 @@+---+name: c3d-bpy-scene-placement+description: "Use in every scene_blender env, zone, refine or rebuild session that places anything, and whenever check_placement or the scene_placement gate reported a floating, sunken, unsupported, interpenetrating, cantilevered or out-of-bounds asset, too many free-tagged ones, or a world that ends at its bounds (world_edge). Everything placed is ONE row in a measured table and its feet are sampled against what is under them. Gives what the gate measures and on which geometry, how a collection instance differs from a geometry-nodes cloud, the requirements with their measurements, how to seat and check in raw bpy what the gate samples (no library ships in raw mode), the self-check, and the finding-to-fix table."+license: Apache-2.0+compatibility: Blender 5.2.2 LTS headless, scene_blender runtime; the gate measures the harness-written census GLB (the evaluated depsgraph), never the .blend.+metadata:+ evidence: mixed+ evidence_note: 'The argon_raw (D113) copy of the base bundle with every library call replaced by the raw bpy it stands for. The instrument half is read from live code on 2026-10-14 (spatial/scene_placement.py, runtime_js/lib/host_placement.mjs, config.Placement, wrappers/_census_glb.py). The corpus half is the argon loop iteration 0 of 2026-10-15 (30 scene_blender runs): 13 zones with an interpenetration ERROR, 9 of them a scatter into a hand-placed prop.'+ verified: "2026-10-17"+ target_metric: "bpy_placement_errors"+ target_direction: "down"+ target_unit: "ERROR findings per run"+ target_measurable: "true"+ target_baseline: "n=30 scene_blender runs, argon loop iteration 0 (2026-10-15): 13 zones shipped an interpenetration ERROR; the per-run ERROR count is not yet tabulated"+---++# Everything sits on something — placement the gate can measure++**Read this if** you are writing a zone, the env, or fixing a `check_placement` finding. The+placement gate is deterministic (a hand's breadth of hover is an ERROR), every ERROR is a score+ceiling in the scene rubric, and the judge is handed a close-up crop of each measured finding.++## What is measured, and on what++The build writes a census GLB from the evaluated depsgraph (modifiers, geometry nodes and+instances included) and the gate reads that, never the `.blend`. A **placed thing** is every+direct child of a zone collection that has mesh descendants, and each one is ONE row:++| what you build | rows | measured |+|---|---|---|+| a mesh object, with or without children | 1 — the whole subtree | yes |+| a collection-instance Empty (`instance_type = 'COLLECTION'`) | 1 per placed copy | yes — its clones are sampled like a mesh |+| a multi-part prop under one root (a parent Empty, parts parented under one mesh, or joined meshes) | 1 | yes |+| twelve loose meshes that together are a hut | 12 | yes, each at its own feet |+| a geometry-nodes or particle cloud (an Instance on Points tree) | 1, exempt as instanced | no — and never a support either |+| a volume-only mesh (a fog box, a steam puff) | exempt as volumetric | no, and never a support or an overlap partner |+| ground, water and sky by name and shape; a shell that swallows the content box | exempt as backdrop or enclosure | no |+| anything tagged `obj["placement"] = "free"`, or its whole zone collection | exempt as free | no — but counted, see below |++Per row, from up to 5 **foot columns** taken from its lowest vertices — a table is measured at+its leg tips, not under its top:++* `ground_gap_m` — the vertical distance from the foot to the nearest surface of any OTHER mesh+ below it (terrain, floor, table top), else to the census ground level.+* `sunk_m` — how far a foot sits below a surface that passes through the asset's own extent.+* `on_water` — a water-named surface at or above the foot: supported, never sunk.+* `attached` — another asset's box within contact distance: mounted, so a small gap is left alone.+* `gap_max_m`, `columns_resting`, `tilt_m` — how many columns rest, how far the worst hangs.++The kinds the report names, worst first: `floating` (a gap above the indoor or outdoor+tolerance; ERROR past `floating_error_m` or when more than `floating_error_count` assets float),+`unsupported` (a smaller gap, touching nothing: WARN), `sunken` (burial past `sunk_m`; ERROR past+`sunk_error_m` when it also swallows `sunk_error_frac` of the height), `interpenetration` (two+boxes overlapping more than `overlap_warn` of the smaller one, confirmed by `inside_frac` of its+vertices inside the other; ERROR past `overlap_error`), `cantilevered` (at most one of four or+more columns rests while the worst hangs: WARN) and `free_exempt` (the share of free-tagged+assets past `free_exempt_warn`, then `free_exempt_error`). Every threshold is a+`Settings.placement` field and the summary line of `check_placement` prints the values it used.+Interiors get the tighter tolerance; the plan's setting words decide that (`is_interior`).++Three exemptions are by NAME (`placement_words.json`, one file read by the gate and by the+boot-time settle): `buried_ok` words (pit, pool, well, trench) are never sunken; `slope_ok` words+(path, platform, stairs, terrace) follow the terrain; `partial_ok` words (rock, tree, post, fence,+pebble) may sink up to `partial_ok_frac` of their height. A thing named what it is gets the+tolerance its kind has; the judge grades the crop whatever the name.++## The requirements, and ways to meet them++1. **Interface: one ground authority.** `height_at(x, y)` in `src/env.py` is the ground every+ zone reads as `ctx.height_at`, and the ground mesh samples the same function. Any function of+ (x, y) the brief's landform needs is fine: rolling hills from summed sines or+ `mathutils.noise.fractal`, a slope to a river, a ridge, a terrace, a quay stepping down to a+ basin, a plaza flat everywhere; the ground mesh is a grid whose vertices you set to it. A zone+ that flattens its own patch to a different number is a bench buried on one side, floating on+ the other.+2. **Requirement: feet within the gate's gap tolerance of what is under them** (measured on the+ census GLB at the foot columns). Read the point set the gate reads — the root's world-space+ vertices, its children's, and for an instance Empty the source collection's through the+ Empty's matrix — keep the lowest ones, and move the root by the smallest+ `ctx.height_at(x, y) - z` over them. A thing ON a thing — a cup on a table, a lantern on a post+ — goes onto the support's top under its footprint, because the gate measures the gap to the+ SUPPORT. Any placement that passes `check_placement` is acceptable.+3. **Sinking is tolerated for names that sink** — a rock, a post, a tree with modelled roots; the+ words file carries the list. A crate sunk "so it cannot float" is a `sunken` finding and a+ crop of a crate in the ground.+4. **Slopes.** Seating by the smallest gap rests the foot over the lowest ground and buries the rest, so a wide thing+ on a slope comes back `sunken` uphill; placed at the ground height of its CENTRE, its downhill+ feet hang: `cantilevered`. Options: a pad in `height_at` under it (the ground mesh follows),+ seated segments, or a turn along the contour (a yaw about Z).+5. **Requirement: a multi-part thing whose parts support each other is ONE row** — one direct+ child of the zone collection with the parts under it — or each part is seated on its own+ support. A root Empty with the parts parented under it at relative locations, or one mesh+ built from all of them, does it; twelve loose meshes are twelve rows and twelve overlap+ partners for each other.+6. **Requirement: anything the brief or plan counts is a measured row** (a direct child of the+ zone collection with mesh descendants). Geometry-nodes and particle clouds are exempt from+ placement and are never supports, so nothing can rest on them; the plan-contents check counts+ instances either way. Collection-instance Empties make rows; a geometry-nodes Instance on+ Points tree makes a cloud — the way for the hundreds (blades, pebbles, litter, a far treeline).+ In 5.2 a new `GeometryNodeTree` has no sockets and no nodes: add them with+ `ng.interface.new_socket(name, in_out='INPUT' | 'OUTPUT', socket_type='NodeSocketGeometry')` and+ your own `NodeGroupInput` / `NodeGroupOutput` nodes (`NodeTree.inputs` / `.outputs` are gone).+7. **`free` is for hanging and airborne things** — a bird, a kite, a lantern on a chain, a steam+ plume. The gate reports the share of free-tagged assets (`free_exempt`), and the judge's+ floating defect still sees a free-tagged crate in the air.+8. **Requirement: a PLANNED content placed entirely outside the plan bounds is the+ `out_of_bounds` kind** (a WARN, past the bounds + max(5 m, 10 % of the span)). Everything+ else — terrain, water, far buildings, forest, the rest of the street — continues past the+ bounds as the brief's place does and is never reported. Clamping its x / y into the zone's+ plan box slides one back. A row far from its planned `approx_size_m` is the `scale` kind, and the fix+ is the SOURCE asset's build, not the Empties.+9. **Requirement (outdoor plans): the world continues past the bounds.** `world_edge` is a+ WARN when the farthest content or ground group at least 2 m tall reaches less than+ 1.25 × the bounds' half-extent from the centre. Whatever the brief's horizon holds satisfies it+ — a landform that keeps rising, a forest edge, far roofs, cliffs, a sea wall — built in the env+ (not a placement row) and named `Sky…` when wide, so the census classifies it as backdrop. The+ census also measures `stamped_ring` — near-identical copies evenly on a circle round the+ world's edge — which the judge calls a toy backdrop.+10. **Names are global in Blender.** Number copies `f"{base}_{i}"`; a second `Lantern_0`+ becomes `Lantern_0.001` and the plan-contents check loses it.++## The self-check, then the gate++Compare the world bounding boxes of the zone's roots AND its scattered Empties pair by pair:+the overlap volume over the smaller box's volume past the interpenetration band is a finding.+Drop every scatter point that falls inside the footprint (plus a margin) of what you placed by+hand: 9 of the 13 Blender zones with an interpenetration ERROR in the argon loop's+iteration 0 (2026-10-15) had scattered a small prop into a cart, a rack, a shrub or a mound. Then+`build`, then `check_placement`, which prints the findings with their fix hints and the table:++```+asset | gap to support (m) | support | sunk (m) | into | water | attached+Market/Bench_0 | +0.236 | Terrain | 0.000 | - | - | -+interpenetration Market/Cart_1 × Market/Stall_0: 41% box, 23% inside+```++The hint's number is the measured gap: move the root by it. A round whose last `check_placement`+lists an ERROR is capped by the rubric on each one; a PASSED gate vetoes the judge's own floating claim.++## Motion, and the feet++The census is taken at the build's current frame, so a moving thing is measured seated at every+time the harness samples (t = 0 and t = 1.5 s; the judge diffs the two frames and names+`nothing_moves` when it sees no change). Motion is data: keyframes on `ctx.frame(t)` or a simple+driver of `frame` (a driver that needs Python evaluates to 0 and the lint rejects it). A tree+with its origin at its base sways about its feet (a keyed rotation turns about the origin: put+it at the hinge or hub). A boat drifting ON a water-named plane is `on_water`; a bird, a steam+plume or a spark cloud built as one object is a `free` row.++Worked zone, row provenance and the finding-to-fix table: `references/finding-to-fix.md`.diff --git a/harness/codeverse3d/skills/variants/argon_raw/c3d-bpy-scene-placement/references/finding-to-fix.md b/harness/codeverse3d/skills/variants/argon_raw/c3d-bpy-scene-placement/references/finding-to-fix.mdnew file mode 100644index 00000000..41ed319b--- /dev/null+++ b/harness/codeverse3d/skills/variants/argon_raw/c3d-bpy-scene-placement/references/finding-to-fix.md@@ -0,0 +1,87 @@+# Finding to fix, where rows come from, and a worked zone++Companion to `c3d-bpy-scene-placement`. Read against `codeverse3d/spatial/scene_placement.py`,+`runtime_js/lib/host_placement.mjs`, `codeverse3d/languages/wrappers/_census_glb.py` and the+`Placement` section of `codeverse3d/config.py` on 2026-10-14. No library ships in raw mode: each+row's fix is a move you compute from world-space vertices; any construction that passes+`check_placement` is as good.++## 1. Finding to fix++| kind, and what the line says | severity | it means | what meets it |+|---|---|---|---|+| `floating` — `X is floating 0.24 m above Terrain (touches nothing)` | WARN; ERROR past `floating_error_m`, or when more than `floating_error_count` assets float | the lowest foot column hangs in the air | lower it by the printed number: its lowest vertices onto `ctx.height_at`, or onto the support's top for a thing on a thing |+| `unsupported` — `X is unsupported: hovers 0.03 m above Terrain and touches nothing` | WARN | off the contact tolerance but inside the floating band | seat it; if it really hangs, tag it `obj["placement"] = "free"` |+| `sunken` — `X is sunken 0.31 m into Terrain` | WARN; ERROR past `sunk_error_m` when the burial also passes `sunk_error_frac` of the height | a foot column sits below the surface | raise it by the number, drop its `sink`, or — only if it is driven or grown in — give it a `partial_ok` name |+| `interpenetration` — `A and B overlap (41% of the smaller box; 23% of its vertices inside the other)` | WARN past `overlap_warn`, ERROR past `overlap_error` | two rows share volume | move the smaller one out, shrink one, remove one, or make them ONE row (parts parented under one root, a joined mesh) |+| `cantilevered` — one column rests, the worst one hangs | WARN | a thing placed at its centre's ground height on a slope or a bump: the downhill feet hang | seat it (the lowest ground wins, the rest sink), a pad in `height_at`, seated segments, or a turn along the contour |+| `free_exempt` — too many assets tagged free | WARN past `free_exempt_warn`, ERROR past `free_exempt_error` | the tag is hiding things from the gate | untag everything that stands; `free` is for hanging and airborne things |+| `scale` — `each of the 6 lantern instances in Square/Lanterns measures 2.80 m but the plan sized lantern at ~0.60 m (4.7x)` | WARN, ERROR by factor | the asset is built at the wrong size | scale the SOURCE collection's build, not the Empties |+| `out_of_bounds` — `X (planned content 'bollard') sits entirely outside the plan bounds + 8 m` | WARN | a row carrying a PLANNED content's name lies wholly past the bounds plus max(5 m, 10 % of the span); unplanned scenery past the bounds is never reported | move it in (clamp its x / y into the zone bbox), or leave it if the brief puts it there and say so |+| `world_edge` — `the world ends at its bounds: the farthest standing geometry (>= 2 m tall) reaches N m from the bounds centre` | WARN | an outdoor plan whose content or ground groups at least 2 m tall all stop inside 1.25 × the bounds' half-extent | whatever the brief's horizon holds, continued past the bounds from the env and named `Sky…` when wide |+| `truncated` — `… and 4 more floating finding(s) not listed` | INFO | the report keeps the worst 8 per kind | fix the listed ones, rebuild, read the next batch |++The table under the findings stops at 400 assets or after 4 s of sampling and says so; a scene+that hits either limit has more placed rows than a judge can read anyway — fewer, merged rows,+with the hundreds as instanced clouds, is what fits.++## 2. Where a row comes from++The census GLB writer walks the evaluated depsgraph; the placement table reads the GLB:++* a collection-instance Empty becomes one node whose children are the instanced meshes — one+ clone per placed copy, so each copy is a row sampled at its own feet;+* a mesh with children is its own group: the subtree is one row;+* any other instance cloud (geometry nodes, particles, dupli-verts) becomes one gpu-instancing+ node per source mesh — an `InstancedMesh` to the gate, counted as instances and exempt from+ per-asset placement, and never a support;+* custom properties of plain value travel as node extras, which is how `obj["placement"] = "free"`+ reaches the gate; a property on the zone's collection exempts the whole zone;+* an object whose every material is volume-only is fog: not indexed, not a support, not an+ overlap partner, and the `no_fog` check counts it as atmosphere.++Supports are the OTHER rows' meshes plus the terrain and floors: a lantern resting on a post is+measured to the post, a crate on a jetty to the jetty, a boat on a water-named plane is on water.++Seat and check against the same point set the gate measures — an object's own geometry, its+children's and, for a collection instance, the source collection's under the Empty's transform —+so an instance Empty is seated by its source's vertices, and the root of a finished prop is the+thing to move.++## 3. A worked zone, one way++```python+def feet(obj, dg): # the gate's foot band, world space, evaluated (modifiers count)+ inst = obj.instance_type == "COLLECTION" # an instance Empty: its source's meshes through its matrix+ m0 = obj.matrix_world if inst else Matrix() # (a mesh root with children: add theirs the same way)+ pts = []+ for o in (obj.instance_collection.all_objects if inst else [obj]):+ if o.type == "MESH":+ pts += [m0 @ o.matrix_world @ v.co for v in o.evaluated_get(dg).to_mesh().vertices]+ o.evaluated_get(dg).to_mesh_clear()+ z0, z1 = min(p.z for p in pts), max(p.z for p in pts)+ return [p for p in pts if p.z <= z0 + max(0.02, 0.05 * (z1 - z0))]++def seat(obj, height_at, dg): # the lowest-hanging foot touches, none floats+ obj.location.z += min(height_at(p.x, p.y) - p.z for p in feet(obj, dg))+```++`dg = bpy.context.evaluated_depsgraph_get()`, `Matrix` from `mathutils`. The band is the gate's:+the vertices within max(0.02 m, 5 % of the height) of the lowest, of which it samples up to 5+columns (the lowest and the band's ±x / ±y extremes).++`matrix_world` is current only after `bpy.context.view_layer.update()` (or compose the parent+chain yourself); a child or an instance Empty adds its own vertices through its own matrix.++A thing named `Shrub…` carries a `partial_ok` word, so a small sink on it is accepted; a bench or+a lantern carries no such word and is measured as it stands. A kite with `kite["placement"] = "free"`+is airborne by design.++## 4. The loop++```+build -> check_placement -> fix every ERROR, then the deepest WARN -> build+```++`check_placement` reads the census of the last build; `rebuild=true` re-takes the census when+you doubt it. A round that ends on an ERROR is capped by the rubric on each one.diff --git a/harness/codeverse3d/skills/variants/argon_raw/routes.toml b/harness/codeverse3d/skills/variants/argon_raw/routes.tomlnew file mode 100644index 00000000..d9689764--- /dev/null+++ b/harness/codeverse3d/skills/variants/argon_raw/routes.toml@@ -0,0 +1,3 @@+# The `argon_raw` variant's routing table (D113, 2026-10-17) — EMPTY: the base table routes the+# three shadowed c3d-bpy-scene-* bundles by name. Row kinds and their typing: see+# codeverse3d/skills/variants/argon/routes.toml and codeverse3d/skills/__init__.py::parse_routes.diff --git a/harness/codeverse3d/spatial/mcp_server.py b/harness/codeverse3d/spatial/mcp_server.pyindex 2bb9196e..b2056f79 100644--- a/harness/codeverse3d/spatial/mcp_server.py+++ b/harness/codeverse3d/spatial/mcp_server.py@@ -63,6 +63,30 @@ def build_context(workspace: Path, *, track: str = "", language: str = "", roundreturn ctx+def apply_run_knobs(ctx: ToolContext) -> dict[str, Any]:+ """The workspace run's variant ``[knobs]`` on this process's settings, for the server's lifetime.++ WHY: the run applies a variant's knobs in ITS process only (``tracks.lifecycle._apply_variant``),+ and this server is a separate process serving that one workspace — so ``argon_raw``'s+ ``scene_lib = false`` (D113) never reached the session's own ``build`` lint, which then passed a+ ``lib`` import the round's lint fails. The variant is the run's: the spec's frozen+ ``options.variant``, else the process switch resolved by the spec's generator+ (``BaseTrack.variant_for``). A user-stated field still wins (``apply_variant_knobs``); an unknown+ or unreadable variant applies nothing."""+ from codeverse3d.config import get_settings+ from codeverse3d.prompts.variants import apply_variant_knobs, resolve_variant, variant_info++ spec = spec_dict(ctx)+ settings = get_settings()+ try:+ name = str((spec.get("options") or {}).get("variant") or "").strip() or resolve_variant(+ settings, str((spec.get("backends") or {}).get("generator") or ""))+ return apply_variant_knobs(settings, variant_info(name)) if name else {}+ except ValueError as e:+ print(f"variant knobs not applied: {e}", file=sys.stderr)+ return {}++def encode_image(path: str, max_side: int = MAX_IMAGE_SIDE) -> str | None:"""PNG → base64 (downscaled so the long side is ≤ ``max_side``); None if unreadable."""try:@@ -219,6 +243,7 @@ def main(argv: list[str] | None = None) -> int:print(f"workspace not found: {ws}", file=sys.stderr)return 2ctx = build_context(ws, track=ns.track, language=ns.language, round_index=ns.round_index)+ apply_run_knobs(ctx)if ns.list:print(json.dumps([{"name": t.name, "description": t.description, "schema": t.schema()} for t in list_tools(track=ctx.track, language=ctx.language)], indent=1))return 0diff --git a/harness/codeverse3d/spatial/scene_placement.py b/harness/codeverse3d/spatial/scene_placement.pyindex b505a95e..92dda1b0 100644--- a/harness/codeverse3d/spatial/scene_placement.py+++ b/harness/codeverse3d/spatial/scene_placement.py@@ -276,8 +276,29 @@ LANGUAGE_WORDS: dict[str, dict[str, str]] = {}+#: scene_blender in raw mode (D113, ``Settings.scene_lib`` off): the hints that name ``lib.place.seat``+#: say what it does instead — no harness library ships, and an import of it is a lint ERROR+RAW_BPY_WORDS: dict[str, str] = {+ "free_exempt": ('obj["placement"] = "free" is for hanging / airborne things only (a bird, a hung lantern, a drone): '+ "delete the tag on everything that stands on something and seat it with ctx.height_at(x, y) at its "+ "lowest evaluated vertices"),+ "cantilever": ("seat every foot: follow the ground with ctx.height_at(x, y) at each corner (its lowest evaluated "+ "vertex on the lowest ground under it), sink it a few cm, or shorten the overhang"),+}+++def _ships_lib() -> bool:+ """The process's run's ``scene_lib`` (``prompts.variants.run_knob``, the rule the runtime follows)."""+ from codeverse3d.prompts.variants import run_knob++ return bool(run_knob("scene_lib"))++def placement_words(language: str | None) -> dict[str, str]:- return LANGUAGE_WORDS.get(str(language or "scene_threejs"), LANGUAGE_WORDS["scene_threejs"])+ words = LANGUAGE_WORDS.get(str(language or "scene_threejs"), LANGUAGE_WORDS["scene_threejs"])+ if str(language) == "scene_blender" and not _ships_lib():+ return {**words, **RAW_BPY_WORDS}+ return wordsdef _f(sev: Severity, msg: str, *, target: str, hint: str = "", kind: str, **data: Any) -> GateFinding:diff --git a/harness/codeverse3d/tracks/lifecycle.py b/harness/codeverse3d/tracks/lifecycle.pyindex b2f3e0c6..def1747d 100644--- a/harness/codeverse3d/tracks/lifecycle.py+++ b/harness/codeverse3d/tracks/lifecycle.py@@ -187,8 +187,17 @@ def _skeleton(track: BaseTrack, ctx: RunContext) -> list[str]:return [str(Path(p).relative_to(ctx.ws.root)) if Path(p).is_absolute() else str(p) for p in paths]+def _skeleton_key(ctx: RunContext) -> dict[str, Any]:+ """The plan and language — and, in scene_blender raw mode only (D113), ``scene_lib: False``: a resume+ that changed the mode writes the skeleton again instead of keeping the other mode's ``src/lib``.+ Library mode adds nothing, so every existing cache key stands."""+ from codeverse3d.tracks.scene_assets import ships_lib++ return {"plan": ctx.plan, "language": ctx.language.value, **({} if ships_lib(ctx) else {"scene_lib": False})}++#: the buildable placeholder of every file the plan names-SKELETON = StageNode("skeleton", _skeleton, key=lambda c: {"plan": c.plan, "language": c.language.value}, seeds_src=True)+SKELETON = StageNode("skeleton", _skeleton, key=_skeleton_key, seeds_src=True)#: the vendor CLI's workspace files (AGENTS.md / CLAUDE.md, the ignore file): once per agent kindMATERIALIZE = StageNode("materialize", lambda t, c: t.ensure_materialized(c))#: a stage boundary: the run stops here when the hard budget is spentdiff --git a/harness/codeverse3d/tracks/scene.py b/harness/codeverse3d/tracks/scene.pyindex 73421bbc..81f7368e 100644--- a/harness/codeverse3d/tracks/scene.py+++ b/harness/codeverse3d/tracks/scene.py@@ -64,6 +64,7 @@ from codeverse3d.tracks.scene_assets import (read_dedupe_note,run_asset_stage,select_assets,+ ships_lib,)from codeverse3d.tracks.zone_layout import layout_block, layout_zonesfrom codeverse3d.workspace import Workspace@@ -269,7 +270,7 @@ class SceneTrack(BaseTrack):if alias is None:_, alias = select_assets(list(plan.assets), MAX_ASSETS)ctx.extra["assets"], ctx.extra["asset_alias"] = assets, alias- return asset_api_summary(plan, assets, alias, language=ctx.language)+ return asset_api_summary(plan, assets, alias, language=ctx.language, lib=ships_lib(ctx))# ---- degradation ------------------------------------------------------def _strategy(self, ctx: RunContext, stage: str) -> RunContext:diff --git a/harness/codeverse3d/tracks/scene_assets.py b/harness/codeverse3d/tracks/scene_assets.pyindex cf0e239a..21bb1cae 100644--- a/harness/codeverse3d/tracks/scene_assets.py+++ b/harness/codeverse3d/tracks/scene_assets.py@@ -111,8 +111,24 @@ class AssetResult(BaseModel):+def ships_lib(ctx: RunContext) -> bool:+ """``Settings.scene_lib`` of the run: is the harness's bpy library in this workspace? ``False`` is+ raw mode (D113) — only scene_blender reads it (scene_threejs always ships its library). The run's+ real runtime answers (``SceneBlenderRuntime.ships_lib``): the skeleton it wrote and the lint it runs+ are the facts the prompts must match; a stand-in runtime (a rig) falls back to the same rule over+ ``ctx.settings`` (``prompts.variants.run_knob``)."""+ from codeverse3d.languages.scene_blender import SceneBlenderRuntime+ from codeverse3d.prompts.variants import run_knob++ if ctx.language != Language.SCENE_BLENDER:+ return True+ if isinstance(ctx.runtime, SceneBlenderRuntime):+ return ctx.runtime.ships_lib+ return bool(run_knob("scene_lib", ctx.settings))++def asset_api_summary(plan: ScenePlan, results: dict[str, AssetResult], alias: dict[str, str] | None = None, *,- language: Language = Language.SCENE_THREEJS) -> str:+ language: Language = Language.SCENE_THREEJS, lib: bool = True) -> str:"""What zone/composer tasks need to know about each asset (names + sizes + how to get it),in the words of the scene language that places them.@@ -121,7 +137,8 @@ def asset_api_summary(plan: ScenePlan, results: dict[str, AssetResult], alias: dthe ``opts.variant`` the zone must pass. bpy: the harness builds EVERY module (a mergedtwin's shim included) and imports every hero before any zone runs, so each is a Collectionat ``ctx.assets['<snake>']`` to place as a collection instance — the zone never imports or- calls a factory, and a merged twin needs no variant number."""+ calls a factory, and a merged twin needs no variant number. ``lib`` False (bpy raw mode, D113): the+ placing line names the collection-instance Empty itself, not the library call."""alias = alias or {}lines = []for a in plan.assets:@@ -142,10 +159,14 @@ def asset_api_summary(plan: ScenePlan, results: dict[str, AssetResult], alias: dlines.append(f"- {a.name}: preloaded at `ctx.assets['{to_snake(a.name)}']` (clone it; GLB public/assets/{to_snake(a.name)}.glb), "f"base at y=0, {s}{motion}{status}")if lines and language is Language.SCENE_BLENDER:+ place = ("place it with `lib.scatter.instance(ctx.collection, ctx.assets['<snake>'], name, x, y, "+ "height_at=ctx.height_at)` (a collection-instance Empty seated on the ground = ONE placement row)." if lib else+ "place it as a collection-instance Empty (`bpy.data.objects.new(name, None)` with `instance_type = 'COLLECTION'` "+ "and `instance_collection = ctx.assets['<snake>']`), linked into ctx.collection and seated on "+ "ctx.height_at(x, y) = ONE placement row.")lines.insert(0, "Sizes are width × height × depth in metres, the plan's Y-up order: in your Blender frame x = width, ""y = depth, z = height. Every entry is a Collection built at the origin with its base on z = 0 and its "- "front facing -Y; place it with `lib.scatter.instance(ctx.collection, ctx.assets['<snake>'], name, x, y, "- "height_at=ctx.height_at)` (a collection-instance Empty seated on the ground = ONE placement row).")+ "front facing -Y; " + place)return "\n".join(lines) or "(no assets)"@@ -780,12 +801,13 @@ _CATALOG_RES: dict[Language, tuple[re.Pattern[str], re.Pattern[str]]] = {}-def library_rows(description: str, language: Language = Language.SCENE_THREEJS) -> str:+def library_rows(description: str, language: Language = Language.SCENE_THREEJS, *, lib: bool = True) -> str:"""The effects-catalog rows of the library factories an asset sheet names, by call or by module(D100): a module asset may compose ``src/lib/``, and a single-shot writer cannot open themodule to learn the call — the rows carry it. The whole catalog is a zone-sized prompt.- ``""`` for a language without a catalog (a blender hero)."""- if language not in _CATALOG_RES:+ ``""`` for a language without a catalog (a blender hero), and with ``lib`` False (bpy raw mode,+ D113: no library ships, so no row may name one)."""+ if language not in _CATALOG_RES or not lib:return ""call_re, module_re = _CATALOG_RES[language]words = set(re.findall(r"\w+(?:\.\w+)*", description))@@ -798,7 +820,7 @@ def _asset_prompt(ctx: RunContext, asset: AssetPlan, rel: str, *, language: Langfiles = list(files or [rel])prompt = render(asset_template(language), **base_prompt_context(ctx, asset_name=asset.name, asset_kind=asset.kind, asset_description=asset.description, asset_size=asset.approx_size_m,- library_rows=library_rows(asset.description, language),+ library_rows=library_rows(asset.description, language, lib=ships_lib(ctx)),asset_file=rel, asset_files=files, asset_language=language.value, fix_instructions=[], current_code="",# a single-shot hero has to see the multi-file skeleton it is filling in, like a static objectskeleton_files=skeleton_files(ctx) if (ctx.single_shot and len(files) > 1) else {},@@ -916,8 +938,9 @@ BPY_CHECK_ZONE = "check"def _bpy_check_workspace(ws: Workspace, rel: str, snake: str) -> Workspace:"""A throw-away workspace under ``_assets/`` (git-ignored, beside the hero sub-workspaces)holding only what one module's build needs: an entry that lists this asset alone, the- module, the harness library it may import, and the probe zone. Rebuilt from scratch on- every check so a module's last attempt never shadows its next."""+ module, the harness library it may import (none in raw mode, D113: an absent ``src/lib``+ copies nothing), and the probe zone. Rebuilt from scratch on every check so a module's last+ attempt never shadows its next."""from codeverse3d.languages.scene_blender import render_scene_pyscratch = Workspace(ws.root / "_assets" / f"{snake}_check")diff --git a/harness/docs/ARCHITECTURE.md b/harness/docs/ARCHITECTURE.mdindex b53a2acd..9f1050ee 100644--- a/harness/docs/ARCHITECTURE.md+++ b/harness/docs/ARCHITECTURE.md@@ -142,7 +142,9 @@ codeverse3d/scene_blender/starter/src/ is its plan-less example (scene.py, env.py, zones/{hamlet,lakeside, orchard}.py, assets/{crate, lantern_post}.py) and lib/ the harness-owned bpy library(D51 for this language: noise, mesh, materials, terrain, sky, lighting, water, vegetation,- architecture, scatter, place, figure, motion), indexed by prompts/scene_blender/effects_catalog.md+ architecture, scatter, place, figure, motion), indexed by prompts/scene_blender/effects_catalog.md;+ Settings.scene_lib off is RAW mode (D113, the argon_raw variant): no lib/ ships, a `lib` import+ is a lint ERROR, the stubs and prompts are raw bpy / bmeshspatial/ node.py, render.py, observe.py, tool_common.py (shared tool plumbing),render_scene.py (judge view subset, content-fitted orbit),render_blender.py (scene_blender: Blender pixels under a GPU slot + CPU fallback,@@ -268,7 +270,8 @@ codeverse3d/BaseTrack.run sets around the whole run from RunOptions.variant, else theC3D_VARIANT / C3D_VARIANTS switch, resolved by exact generator id — never aregex); variant.toml = name/version/generators/knobs, variant_hash covers the- prompt + skills overlays and lands in the record. variants/argon/ ships empty.+ prompt + skills overlays and lands in the record. variants/argon/ ships empty;+ variants/argon_raw/ (D113) is scene_blender raw mode ([knobs] scene_lib = false).The other half of the split: codeverse3d/skills/ is what an AGENT choosesto read (SKILL.md + references/ + a _claims file pinning its numbers tolive constants). A file that tries to be both is the bug this prevents.diff --git a/harness/docs/RUNBOOK.md b/harness/docs/RUNBOOK.mdindex 4579f739..1dba7000 100644--- a/harness/docs/RUNBOOK.md+++ b/harness/docs/RUNBOOK.md@@ -60,6 +60,8 @@ paid grounding pass first, since the grounded spec is what it writes),`judge` read the same files; default: `C3D_VARIANT`, else `C3D_VARIANTS` keyed by the exactgenerator id — as typed, then by its served model — else the base prompts; an unknown name isrefused before the run directory exists; the run table prints `variant: argon v1 (<hash>)`).+`--variant argon_raw` on `--language scene_blender` is RAW mode (D113): no harness bpy library+ships into the workspace and the model writes every mesh, material, light, world and motion.Expected cost/time with gemini-3.7-flash: object tracks ≈ $0.7–0.9 and 12–36 min forbaseline + 1 refine; best-of-2 single-shot ≈ $0.25 / 8 min; graphics single-shot@@ -405,7 +407,7 @@ weather: they leave the provider's errors out (docs/COST.md §31); the ceiling dscenario to `SCENARIOS`.* **A per-model variant** (D105): `codeverse3d/prompts/variants/<name>/variant.toml` (`[variant]`name = the directory name, version, generators, description; optional `[knobs]` — `skills_max`,- `skills_only` — applied like a profile, a user-stated field wins) beside the prompt files that+ `skills_only`, `scene_lib` (D113) — applied like a profile, a user-stated field wins) beside the prompt files thatshadow the base ones by relative path (a template there may `include` a base file), and`codeverse3d/skills/variants/<name>/` for bundles that shadow base bundles by name, their`_claims/`, and `routes.toml` (`[[boost]]` skill + delta, `[[disable]]` rule, `[[route]]` extradiff --git a/harness/tests/core/test_doctor.py b/harness/tests/core/test_doctor.pyindex fb93de00..499b097c 100644--- a/harness/tests/core/test_doctor.py+++ b/harness/tests/core/test_doctor.py@@ -115,7 +115,10 @@ def test_doctor_skills_walks_every_shipped_overlay_and_labels_an_invalid_bundle_get_settings.cache_clear()-def test_doctor_skills_reports_the_shipped_argon_overlay(monkeypatch):+def test_doctor_skills_reports_every_shipped_overlay(monkeypatch):+ """One ``skills overlay`` row per shipped variant, in name order: ``argon`` (empty) and ``argon_raw``+ (D113: the three lib-free ``c3d-bpy-scene-*`` shadows, no routes) — a dict keyed by the row name+ would keep only the last, so the rows are read as a list."""from codeverse3d.config import get_settingsfrom codeverse3d.doctor import check_skills@@ -123,9 +126,11 @@ def test_doctor_skills_reports_the_shipped_argon_overlay(monkeypatch):monkeypatch.delenv("C3D_VARIANT", raising=False)get_settings.cache_clear()try:- rows = {name: (status, detail) for name, status, detail in check_skills()}+ rows = check_skills()finally: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")+ assert next(status for name, status, _ in rows if name == "skills library") == "OK"+ overlays = [(status, detail) for name, status, detail in rows if name == "skills overlay"]+ assert [status for status, _ in overlays] == ["OK", "OK"], overlays+ assert overlays[0][1].startswith("argon: 0 bundles, 0 invalid")+ assert overlays[1][1].startswith("argon_raw: 3 bundles, 0 invalid") and "routes.toml: no rows" in overlays[1][1]diff --git a/harness/tests/prompts/manifest.json b/harness/tests/prompts/manifest.jsonnew file mode 100644index 00000000..fa3ff094--- /dev/null+++ b/harness/tests/prompts/manifest.json@@ -0,0 +1,1054 @@+{+ "scenarios": {+ "articulated_object.urdf_blender.agent.fresh": {+ "payloads": {+ "chat:planner:planner-brief/messages": {"bytes": 135, "sha256": "f4b6bd05705cf97e37fd1b5483976030cb1f5e26788c27237a39a263c2e771ec"},+ "chat:planner:planner-brief/sampling": {"bytes": 4774, "sha256": "ac0bb868a0ed6551f5374840bf146b6e0b4fbb014f10a856fd306ec44357226a"},+ "chat:planner:planner-brief/system": {"bytes": 3133, "sha256": "a66f0fe3b4610d21d0969a732e8d15f208a1147fe6a0ec6ce97606e400142580"},+ "chat:planner:planner-retry/messages": {"bytes": 4720, "sha256": "8b537a73ffc185efeab6a1913d09b28fe3b3d59c0dd702c6b13ea1d02f9ce6b8"},+ "chat:planner:planner-retry/sampling": {"bytes": 10001, "sha256": "0ff37a3ae43fdf878dd0911a9954d57e49365ad788c84818ea01d350310ab401"},+ "chat:planner:planner-retry/system": {"bytes": 20030, "sha256": "45dccfcf72b4c6e46b7ceeaae8af0ebddf6f6e6b5970cda5fe900aa47682bf06"},+ "chat:planner:planner/messages": {"bytes": 1328, "sha256": "313c87553cf38df423dc9245a8af4cca5a41a844b489e13a5dc08e8c44eabba5"},+ "chat:planner:planner/sampling": {"bytes": 10001, "sha256": "0ff37a3ae43fdf878dd0911a9954d57e49365ad788c84818ea01d350310ab401"},+ "chat:planner:planner/system": {"bytes": 20030, "sha256": "45dccfcf72b4c6e46b7ceeaae8af0ebddf6f6e6b5970cda5fe900aa47682bf06"},+ "context:runs/run/files": {"bytes": 45536, "sha256": "754895270e93f3df8388927163e85613f5012f44b2c2c028b5cf651b42d8f095"},+ "job:baseline@r00/prompt": {"bytes": 20078, "sha256": "d81c6b7a20cbaea5300ea8ceb1bfcac6d10b5a78b7a72e85787ac5cb54a988aa"},+ "job:baseline@r00/scope": {"bytes": 383, "sha256": "7187fd726a9f499668ae3df0399ed4a3e08b7cb7a9de5ba753b8775448ea876e"},+ "job:baseline@r00/system": {"bytes": 3271, "sha256": "29f5a9b2e7b9a879be58963ce95ae6fbec7460dae6785d542b214d6b850e21f4"},+ "job:refine@r01/prompt": {"bytes": 7562, "sha256": "328c6f4ffce62283a158a78af4dd3f87b0322efdca2679da200b3b9139464e60"},+ "job:refine@r01/scope": {"bytes": 379, "sha256": "d17ae76997ec9443d52089e32ec81ecac3ba2c93529b227533942e84598113d9"},+ "job:refine@r01/system": {"bytes": 3271, "sha256": "29f5a9b2e7b9a879be58963ce95ae6fbec7460dae6785d542b214d6b850e21f4"},+ "judge:articulated_v1:runs/run/artifacts/renders/r00/input": {"bytes": 9884, "sha256": "b8b8e6c5f11f440a8563eb9bbb1c2dd9fd32f78da6d35078e1f54eb231cc80c0"},+ "judge:articulated_v1:runs/run/artifacts/renders/r00/messages": {"bytes": 7266, "sha256": "44869437393997f2107fdf0a59b70d830557064fa5958abfbee786e535323a2c"},+ "judge:articulated_v1:runs/run/artifacts/renders/r00/sampling": {"bytes": 11989, "sha256": "e93c46f5a7a740cd7cf30206976488736804f2b016f39424b2f0e41bfbea1c29"},+ "judge:articulated_v1:runs/run/artifacts/renders/r00/system": {"bytes": 13132, "sha256": "559ab1621aef1f28ee9c9d235bf78a1003cb94358ed85248cf0d652bb40498d1"},+ "judge:articulated_v1:runs/run/artifacts/renders/r01/input": {"bytes": 10787, "sha256": "ccb99967b785a412cbd6bdbf0b1ecfc92cb5ba25747e678bbcc6a8c4e56b83e1"},+ "judge:articulated_v1:runs/run/artifacts/renders/r01/messages": {"bytes": 7591, "sha256": "a2e7394b1d8515b0256e914ceb6b07eaf526a634104ea03829c559e5fd7ebf67"},+ "judge:articulated_v1:runs/run/artifacts/renders/r01/sampling": {"bytes": 11989, "sha256": "e93c46f5a7a740cd7cf30206976488736804f2b016f39424b2f0e41bfbea1c29"},+ "judge:articulated_v1:runs/run/artifacts/renders/r01/system": {"bytes": 13132, "sha256": "559ab1621aef1f28ee9c9d235bf78a1003cb94358ed85248cf0d652bb40498d1"},+ "skills:runs/run:baseline@r00/routed": {"bytes": 125, "sha256": "7e099a4ebdaae69160ddbaf1be8d8c7349914d676244b57b1815508b507fd177"},+ "skills:runs/run:refine@r01/routed": {"bytes": 125, "sha256": "5c725d8f66ce509d26245268d4c3525c99ce65ff9a56b94c708a74934ae2edf4"}+ },+ "stage_keys": {+ "runs/run:plan": "1247d7fb9fd2",+ "runs/run:skeleton": "7e94e98a2207"+ }+ },+ "articulated_object.urdf_blender.single_shot.fresh": {+ "payloads": {+ "chat:model:baseline:r00/messages": {"bytes": 26236, "sha256": "e6a4ef76efd527c72c17975c264f10bf8e6b6aed2fa6f8f6e2df00d1a12fb683"},+ "chat:model:baseline:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:baseline:r00/system": {"bytes": 5628, "sha256": "36a03396a5b24842f018dc01b5ab0d5b7bb59c18de46cfa59bdeb3ab2a0f1e41"},+ "chat:model:refine:r01/messages": {"bytes": 13007, "sha256": "5d208c2fda5e6bfea23d5a0373ac8903364c49974b4b513656452f519afef449"},+ "chat:model:refine:r01/sampling": {"bytes": 92, "sha256": "2a36044e5c117fc288123a5937c6e3cb5845f040b4de69f9c2440f623956c381"},+ "chat:model:refine:r01/system": {"bytes": 5628, "sha256": "36a03396a5b24842f018dc01b5ab0d5b7bb59c18de46cfa59bdeb3ab2a0f1e41"},+ "chat:planner:planner-brief/messages": {"bytes": 135, "sha256": "f4b6bd05705cf97e37fd1b5483976030cb1f5e26788c27237a39a263c2e771ec"},+ "chat:planner:planner-brief/sampling": {"bytes": 4774, "sha256": "ac0bb868a0ed6551f5374840bf146b6e0b4fbb014f10a856fd306ec44357226a"},+ "chat:planner:planner-brief/system": {"bytes": 3133, "sha256": "a66f0fe3b4610d21d0969a732e8d15f208a1147fe6a0ec6ce97606e400142580"},+ "chat:planner:planner-retry/messages": {"bytes": 4720, "sha256": "8b537a73ffc185efeab6a1913d09b28fe3b3d59c0dd702c6b13ea1d02f9ce6b8"},+ "chat:planner:planner-retry/sampling": {"bytes": 10001, "sha256": "0ff37a3ae43fdf878dd0911a9954d57e49365ad788c84818ea01d350310ab401"},+ "chat:planner:planner-retry/system": {"bytes": 20030, "sha256": "45dccfcf72b4c6e46b7ceeaae8af0ebddf6f6e6b5970cda5fe900aa47682bf06"},+ "chat:planner:planner/messages": {"bytes": 1328, "sha256": "313c87553cf38df423dc9245a8af4cca5a41a844b489e13a5dc08e8c44eabba5"},+ "chat:planner:planner/sampling": {"bytes": 10001, "sha256": "0ff37a3ae43fdf878dd0911a9954d57e49365ad788c84818ea01d350310ab401"},+ "chat:planner:planner/system": {"bytes": 20030, "sha256": "45dccfcf72b4c6e46b7ceeaae8af0ebddf6f6e6b5970cda5fe900aa47682bf06"},+ "judge:articulated_v1:runs/run/artifacts/renders/r00/input": {"bytes": 9604, "sha256": "80435bd0207e04f9d3384039b4b2c140056e8406af4c3616cfc019430969244b"},+ "judge:articulated_v1:runs/run/artifacts/renders/r00/messages": {"bytes": 7120, "sha256": "7a0ef8d51456faa2c38867eea6c502fbe1a7aa30d6cd9f23b44701a2d11846bf"},+ "judge:articulated_v1:runs/run/artifacts/renders/r00/sampling": {"bytes": 11989, "sha256": "e93c46f5a7a740cd7cf30206976488736804f2b016f39424b2f0e41bfbea1c29"},+ "judge:articulated_v1:runs/run/artifacts/renders/r00/system": {"bytes": 13132, "sha256": "559ab1621aef1f28ee9c9d235bf78a1003cb94358ed85248cf0d652bb40498d1"},+ "judge:articulated_v1:runs/run/artifacts/renders/r01/input": {"bytes": 10507, "sha256": "1dc1b1c082595444ef377d6bce19d98357d14450f414fca3dc0e80728a12da8d"},+ "judge:articulated_v1:runs/run/artifacts/renders/r01/messages": {"bytes": 7445, "sha256": "2a654e5bb10f8a642367b40c8893a16dce24c4bc4f6941cfbba76ce348ad4f1c"},+ "judge:articulated_v1:runs/run/artifacts/renders/r01/sampling": {"bytes": 11989, "sha256": "e93c46f5a7a740cd7cf30206976488736804f2b016f39424b2f0e41bfbea1c29"},+ "judge:articulated_v1:runs/run/artifacts/renders/r01/system": {"bytes": 13132, "sha256": "559ab1621aef1f28ee9c9d235bf78a1003cb94358ed85248cf0d652bb40498d1"},+ "skills:runs/run:baseline@r00/routed": {"bytes": 138, "sha256": "cb0610ba263bbb5cbeadf679a8213b52ece498906fabcdf2f8e5937d23c94c0b"},+ "skills:runs/run:refine@r01/routed": {"bytes": 138, "sha256": "cb0610ba263bbb5cbeadf679a8213b52ece498906fabcdf2f8e5937d23c94c0b"}+ },+ "stage_keys": {+ "runs/run:plan": "1247d7fb9fd2",+ "runs/run:skeleton": "7e94e98a2207"+ }+ },+ "graphics.glsl_shader.agent.best_of_2": {+ "payloads": {+ "chat:planner:planner/messages": {"bytes": 348, "sha256": "f50fc3cdf3a426fc9c9b830b6e68d2cfe9fd9b7125550362b018f9c9b454b25c"},+ "chat:planner:planner/sampling": {"bytes": 3421, "sha256": "918170272cea656e8c542c54b777c57d1a4567a8cc36a0c1cd825cb81a01b9bb"},+ "chat:planner:planner/system": {"bytes": 11922, "sha256": "172a4deaa1499e7ee80be931e5840b293ed81ee0a74262e20459261d81d40f43"},+ "context:runs/run/_cand/c0/files": {"bytes": 32162, "sha256": "37bbde6b0aeceba63e2706842f0598cbeed13e67efa8dbd1f5c75f08248e9ce6"},+ "context:runs/run/_cand/c1/files": {"bytes": 32162, "sha256": "37bbde6b0aeceba63e2706842f0598cbeed13e67efa8dbd1f5c75f08248e9ce6"},+ "context:runs/run/files": {"bytes": 32162, "sha256": "37bbde6b0aeceba63e2706842f0598cbeed13e67efa8dbd1f5c75f08248e9ce6"},+ "job:baseline_c0@r00/prompt": {"bytes": 11359, "sha256": "d55a46da0bbbd9106773fd9d0664b2f52ac44d84988a5d3dac1bc5e66cdea589"},+ "job:baseline_c0@r00/scope": {"bytes": 383, "sha256": "51d22961200ef987a7c652af48ff2897b910803baa672d3081f53c3fb819a685"},+ "job:baseline_c0@r00/system": {"bytes": 3176, "sha256": "3483d6a17a75ef02d53f4addcc8713e0b7e281c092fa88a854524c2bae344f32"},+ "job:baseline_c1@r00/prompt": {"bytes": 11359, "sha256": "d55a46da0bbbd9106773fd9d0664b2f52ac44d84988a5d3dac1bc5e66cdea589"},+ "job:baseline_c1@r00/scope": {"bytes": 383, "sha256": "831265b54627f1f6c1bfadebefa4e898d6b543b253bf6be0685b5383bd39fb57"},+ "job:baseline_c1@r00/system": {"bytes": 3176, "sha256": "3483d6a17a75ef02d53f4addcc8713e0b7e281c092fa88a854524c2bae344f32"},+ "judge:shader_v2:runs/run/_cand/c0/artifacts/renders/r00/input": {"bytes": 4078, "sha256": "e3dd787e6b7cc0aab8d35ce01ff5fbd42a3da389411b7402e6b15a0301f21f8a"},+ "judge:shader_v2:runs/run/_cand/c0/artifacts/renders/r00/messages": {"bytes": 3727, "sha256": "d7deb2c4a1fa8e9b015a4e81439f9781e7618be6a01b013d18bb3acc4f6a32b9"},+ "judge:shader_v2:runs/run/_cand/c0/artifacts/renders/r00/sampling": {"bytes": 11659, "sha256": "2f41a011f9775b7aaf1ec8c1594be4e9172d23f6eb6dfc4b262c6e6bf1097792"},+ "judge:shader_v2:runs/run/_cand/c0/artifacts/renders/r00/system": {"bytes": 11256, "sha256": "27c834df165bcb2e2406b0045b141fd290cf85edc1fc104a1e95b959d51aec57"},+ "judge:shader_v2:runs/run/_cand/c1/artifacts/renders/r00/input": {"bytes": 4078, "sha256": "c825f0fbe74ca0c4fd90b8b3ff2bc2177851d4598ef3878e6ed7753d87d772a3"},+ "judge:shader_v2:runs/run/_cand/c1/artifacts/renders/r00/messages": {"bytes": 3727, "sha256": "d7deb2c4a1fa8e9b015a4e81439f9781e7618be6a01b013d18bb3acc4f6a32b9"},+ "judge:shader_v2:runs/run/_cand/c1/artifacts/renders/r00/sampling": {"bytes": 11659, "sha256": "2f41a011f9775b7aaf1ec8c1594be4e9172d23f6eb6dfc4b262c6e6bf1097792"},+ "judge:shader_v2:runs/run/_cand/c1/artifacts/renders/r00/system": {"bytes": 11256, "sha256": "27c834df165bcb2e2406b0045b141fd290cf85edc1fc104a1e95b959d51aec57"},+ "judge:shader_v2:runs/run/artifacts/renders/r00/input": {"bytes": 4024, "sha256": "f7a7cf02a2ac234aa62fc4ab4e3be6cb6cf2305a24c07c66bafec8e728038efd"},+ "judge:shader_v2:runs/run/artifacts/renders/r00/messages": {"bytes": 3727, "sha256": "d7deb2c4a1fa8e9b015a4e81439f9781e7618be6a01b013d18bb3acc4f6a32b9"},+ "judge:shader_v2:runs/run/artifacts/renders/r00/sampling": {"bytes": 11659, "sha256": "2f41a011f9775b7aaf1ec8c1594be4e9172d23f6eb6dfc4b262c6e6bf1097792"},+ "judge:shader_v2:runs/run/artifacts/renders/r00/system": {"bytes": 11256, "sha256": "27c834df165bcb2e2406b0045b141fd290cf85edc1fc104a1e95b959d51aec57"},+ "skills:runs/run/_cand/c0:baseline@r00/routed": {"bytes": 56, "sha256": "400eb18b3e0ca869392d11f9fc95c12140d8234f3efe8f3c1ec66b5c43d1ffa6"},+ "skills:runs/run/_cand/c1:baseline@r00/routed": {"bytes": 56, "sha256": "400eb18b3e0ca869392d11f9fc95c12140d8234f3efe8f3c1ec66b5c43d1ffa6"},+ "skills:runs/run:baseline@r00/routed": {"bytes": 56, "sha256": "400eb18b3e0ca869392d11f9fc95c12140d8234f3efe8f3c1ec66b5c43d1ffa6"}+ },+ "stage_keys": {+ "runs/run:plan": "d1428ecadc7f",+ "runs/run:skeleton": "7ad4f988e9ca"+ }+ },+ "graphics.glsl_shader.agent.fresh": {+ "payloads": {+ "chat:planner:planner/messages": {"bytes": 348, "sha256": "f50fc3cdf3a426fc9c9b830b6e68d2cfe9fd9b7125550362b018f9c9b454b25c"},+ "chat:planner:planner/sampling": {"bytes": 3421, "sha256": "918170272cea656e8c542c54b777c57d1a4567a8cc36a0c1cd825cb81a01b9bb"},+ "chat:planner:planner/system": {"bytes": 11922, "sha256": "172a4deaa1499e7ee80be931e5840b293ed81ee0a74262e20459261d81d40f43"},+ "context:runs/run/files": {"bytes": 32162, "sha256": "37bbde6b0aeceba63e2706842f0598cbeed13e67efa8dbd1f5c75f08248e9ce6"},+ "job:baseline@r00/prompt": {"bytes": 11359, "sha256": "d55a46da0bbbd9106773fd9d0664b2f52ac44d84988a5d3dac1bc5e66cdea589"},+ "job:baseline@r00/scope": {"bytes": 379, "sha256": "831e9c99bdd04789b89bfddb89c97939a813323c9173d742adabbb5f1f8a7dc1"},+ "job:baseline@r00/system": {"bytes": 3176, "sha256": "3483d6a17a75ef02d53f4addcc8713e0b7e281c092fa88a854524c2bae344f32"},+ "job:refine@r01/prompt": {"bytes": 4829, "sha256": "701203307b2677078ab21caca6c39556b594c220e1642a242e45fad4caf905f1"},+ "job:refine@r01/scope": {"bytes": 375, "sha256": "f106c6fcaee6849acebc6005bde1bad2939260265ed9c794846543d16e84edce"},+ "job:refine@r01/system": {"bytes": 3176, "sha256": "3483d6a17a75ef02d53f4addcc8713e0b7e281c092fa88a854524c2bae344f32"},+ "job:refine@r02/prompt": {"bytes": 4828, "sha256": "f02f3a218edb95d79000fd339cc556045baccd5087231dd293db83195c927fa7"},+ "job:refine@r02/scope": {"bytes": 375, "sha256": "c4a7fdb0b390ec75d595006e11b9982113e60c49f5a62a978153167053bbcd33"},+ "job:refine@r02/system": {"bytes": 3176, "sha256": "3483d6a17a75ef02d53f4addcc8713e0b7e281c092fa88a854524c2bae344f32"},+ "judge:shader_v2:runs/run/artifacts/renders/r00/input": {"bytes": 4024, "sha256": "77a8a69c16f42514152b7169c1afc91bca46d4ececc6bf60e826020cfb87af09"},+ "judge:shader_v2:runs/run/artifacts/renders/r00/messages": {"bytes": 3727, "sha256": "d7deb2c4a1fa8e9b015a4e81439f9781e7618be6a01b013d18bb3acc4f6a32b9"},+ "judge:shader_v2:runs/run/artifacts/renders/r00/sampling": {"bytes": 11659, "sha256": "2f41a011f9775b7aaf1ec8c1594be4e9172d23f6eb6dfc4b262c6e6bf1097792"},+ "judge:shader_v2:runs/run/artifacts/renders/r00/system": {"bytes": 11256, "sha256": "27c834df165bcb2e2406b0045b141fd290cf85edc1fc104a1e95b959d51aec57"},+ "judge:shader_v2:runs/run/artifacts/renders/r01/input": {"bytes": 5077, "sha256": "91baae5de582cf7919bad97282b84d07db84fed38e5a2304e901dfd2a2748b0a"},+ "judge:shader_v2:runs/run/artifacts/renders/r01/messages": {"bytes": 4123, "sha256": "a1f0c207406de6f415fdb8516b695aaedf7f06d25598f33932d2ad728f8c881f"},+ "judge:shader_v2:runs/run/artifacts/renders/r01/sampling": {"bytes": 11659, "sha256": "2f41a011f9775b7aaf1ec8c1594be4e9172d23f6eb6dfc4b262c6e6bf1097792"},+ "judge:shader_v2:runs/run/artifacts/renders/r01/system": {"bytes": 11256, "sha256": "27c834df165bcb2e2406b0045b141fd290cf85edc1fc104a1e95b959d51aec57"},+ "judge:shader_v2:runs/run/artifacts/renders/r02/input": {"bytes": 5073, "sha256": "f441039d9cbbfd50ed5d1a38fb008fc63e2c19ed191a866351532a6a190e1c35"},+ "judge:shader_v2:runs/run/artifacts/renders/r02/messages": {"bytes": 4123, "sha256": "5b81b09f9d6a7e3225549454099d07143f5bb726c3ccff263b4afc7bfe13d88b"},+ "judge:shader_v2:runs/run/artifacts/renders/r02/sampling": {"bytes": 11659, "sha256": "2f41a011f9775b7aaf1ec8c1594be4e9172d23f6eb6dfc4b262c6e6bf1097792"},+ "judge:shader_v2:runs/run/artifacts/renders/r02/system": {"bytes": 11256, "sha256": "27c834df165bcb2e2406b0045b141fd290cf85edc1fc104a1e95b959d51aec57"},+ "skills:runs/run:baseline@r00/routed": {"bytes": 56, "sha256": "400eb18b3e0ca869392d11f9fc95c12140d8234f3efe8f3c1ec66b5c43d1ffa6"},+ "skills:runs/run:refine@r01/routed": {"bytes": 56, "sha256": "400eb18b3e0ca869392d11f9fc95c12140d8234f3efe8f3c1ec66b5c43d1ffa6"},+ "skills:runs/run:refine@r02/routed": {"bytes": 56, "sha256": "400eb18b3e0ca869392d11f9fc95c12140d8234f3efe8f3c1ec66b5c43d1ffa6"}+ },+ "stage_keys": {+ "runs/run:plan": "d1428ecadc7f",+ "runs/run:skeleton": "7ad4f988e9ca"+ }+ },+ "graphics.glsl_shader.agent.rebuild": {+ "payloads": {+ "chat:planner:planner/messages": {"bytes": 348, "sha256": "f50fc3cdf3a426fc9c9b830b6e68d2cfe9fd9b7125550362b018f9c9b454b25c"},+ "chat:planner:planner/sampling": {"bytes": 3421, "sha256": "918170272cea656e8c542c54b777c57d1a4567a8cc36a0c1cd825cb81a01b9bb"},+ "chat:planner:planner/system": {"bytes": 11922, "sha256": "172a4deaa1499e7ee80be931e5840b293ed81ee0a74262e20459261d81d40f43"},+ "context:runs/run/files": {"bytes": 32162, "sha256": "37bbde6b0aeceba63e2706842f0598cbeed13e67efa8dbd1f5c75f08248e9ce6"},+ "job:baseline@r00/prompt": {"bytes": 11359, "sha256": "d55a46da0bbbd9106773fd9d0664b2f52ac44d84988a5d3dac1bc5e66cdea589"},+ "job:baseline@r00/scope": {"bytes": 379, "sha256": "831e9c99bdd04789b89bfddb89c97939a813323c9173d742adabbb5f1f8a7dc1"},+ "job:baseline@r00/system": {"bytes": 3176, "sha256": "3483d6a17a75ef02d53f4addcc8713e0b7e281c092fa88a854524c2bae344f32"},+ "job:r00_baseline_repair1@r00/prompt": {"bytes": 2407, "sha256": "056a91d52ba3c3b09efd2fe13f139c6953fe99205e7c7b53ffc26331b1701b72"},+ "job:r00_baseline_repair1@r00/scope": {"bytes": 389, "sha256": "6e9ef696a5ada34a890d14e7cd2de9c69d51e95e9a36bd0d8d9db7b043e06671"},+ "job:r00_baseline_repair1@r00/system": {"bytes": 9640, "sha256": "253de140b4d3eba01e244c0dd785548f1241a91dc42495e34a98cdcd3284b4fc"},+ "job:r00_baseline_repair2@r00/prompt": {"bytes": 2712, "sha256": "aa2cfd9457a008820bb834e4931277ad4e7d8826de45de18fd13c21045617991"},+ "job:r00_baseline_repair2@r00/scope": {"bytes": 391, "sha256": "7e0dbd43421db95ef9078ca03fd146cccc2cc8372380a72fd55fa12ff7217db0"},+ "job:r00_baseline_repair2@r00/system": {"bytes": 9640, "sha256": "253de140b4d3eba01e244c0dd785548f1241a91dc42495e34a98cdcd3284b4fc"},+ "job:rebuild@r01/prompt": {"bytes": 11542, "sha256": "79d440c92dc02752e64ab8d61dde2ae6bd75c737e26d9ed0f9da75e12f6080ff"},+ "job:rebuild@r01/scope": {"bytes": 379, "sha256": "471fba995682e47fe12099cb5881743a8aeae71a0243fa3598c72d69a5b31f98"},+ "job:rebuild@r01/system": {"bytes": 3176, "sha256": "3483d6a17a75ef02d53f4addcc8713e0b7e281c092fa88a854524c2bae344f32"},+ "judge:shader_v2:runs/run/artifacts/renders/r01/input": {"bytes": 4024, "sha256": "f6637594bb85a4806d5e768a6467825652abb7855d33ae866733714bf4489f62"},+ "judge:shader_v2:runs/run/artifacts/renders/r01/messages": {"bytes": 3727, "sha256": "d7deb2c4a1fa8e9b015a4e81439f9781e7618be6a01b013d18bb3acc4f6a32b9"},+ "judge:shader_v2:runs/run/artifacts/renders/r01/sampling": {"bytes": 11659, "sha256": "2f41a011f9775b7aaf1ec8c1594be4e9172d23f6eb6dfc4b262c6e6bf1097792"},+ "judge:shader_v2:runs/run/artifacts/renders/r01/system": {"bytes": 11256, "sha256": "27c834df165bcb2e2406b0045b141fd290cf85edc1fc104a1e95b959d51aec57"},+ "skills:runs/run:baseline@r00/routed": {"bytes": 56, "sha256": "400eb18b3e0ca869392d11f9fc95c12140d8234f3efe8f3c1ec66b5c43d1ffa6"},+ "skills:runs/run:refine@r01/routed": {"bytes": 56, "sha256": "400eb18b3e0ca869392d11f9fc95c12140d8234f3efe8f3c1ec66b5c43d1ffa6"}+ },+ "stage_keys": {+ "runs/run:plan": "d1428ecadc7f",+ "runs/run:skeleton": "7ad4f988e9ca"+ }+ },+ "graphics.glsl_shader.single_shot.fresh": {+ "payloads": {+ "chat:model:baseline:r00/messages": {"bytes": 20198, "sha256": "cd7e4a7b6be62c421c035311b610f14624ab9c66f2f30d475004c136273565f8"},+ "chat:model:baseline:r00/sampling": {"bytes": 92, "sha256": "ed52acf6f9a2dcc4c97fd8698b845dfed301b15f5fc05262bd934a525b14fc9b"},+ "chat:model:baseline:r00/system": {"bytes": 5518, "sha256": "4692c1cfe4fedae824d44f13ea4902d1139b025c5c4d565c26332a6fd2f8f0f3"},+ "chat:model:refine:r01/messages": {"bytes": 11028, "sha256": "9b8c9a691c8d022fe9052ed4cc9a8dbcc87bf7887b239d97a2703cedcb069c4c"},+ "chat:model:refine:r01/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:refine:r01/system": {"bytes": 5518, "sha256": "4692c1cfe4fedae824d44f13ea4902d1139b025c5c4d565c26332a6fd2f8f0f3"},+ "chat:planner:planner/messages": {"bytes": 348, "sha256": "f50fc3cdf3a426fc9c9b830b6e68d2cfe9fd9b7125550362b018f9c9b454b25c"},+ "chat:planner:planner/sampling": {"bytes": 3421, "sha256": "918170272cea656e8c542c54b777c57d1a4567a8cc36a0c1cd825cb81a01b9bb"},+ "chat:planner:planner/system": {"bytes": 11922, "sha256": "172a4deaa1499e7ee80be931e5840b293ed81ee0a74262e20459261d81d40f43"},+ "judge:shader_v2:runs/run/artifacts/renders/r00/input": {"bytes": 4041, "sha256": "b1c2c219851e29fdf3e2ef55acdcbd05f50f1306cb15e643990d5c550a860a0f"},+ "judge:shader_v2:runs/run/artifacts/renders/r00/messages": {"bytes": 3727, "sha256": "d7deb2c4a1fa8e9b015a4e81439f9781e7618be6a01b013d18bb3acc4f6a32b9"},+ "judge:shader_v2:runs/run/artifacts/renders/r00/sampling": {"bytes": 11659, "sha256": "2f41a011f9775b7aaf1ec8c1594be4e9172d23f6eb6dfc4b262c6e6bf1097792"},+ "judge:shader_v2:runs/run/artifacts/renders/r00/system": {"bytes": 11256, "sha256": "27c834df165bcb2e2406b0045b141fd290cf85edc1fc104a1e95b959d51aec57"},+ "judge:shader_v2:runs/run/artifacts/renders/r01/input": {"bytes": 5094, "sha256": "329efb6f51153caef8363b23519c03cff958df73f76dd6a6f0eb4a539efb97f2"},+ "judge:shader_v2:runs/run/artifacts/renders/r01/messages": {"bytes": 4123, "sha256": "a1f0c207406de6f415fdb8516b695aaedf7f06d25598f33932d2ad728f8c881f"},+ "judge:shader_v2:runs/run/artifacts/renders/r01/sampling": {"bytes": 11659, "sha256": "2f41a011f9775b7aaf1ec8c1594be4e9172d23f6eb6dfc4b262c6e6bf1097792"},+ "judge:shader_v2:runs/run/artifacts/renders/r01/system": {"bytes": 11256, "sha256": "27c834df165bcb2e2406b0045b141fd290cf85edc1fc104a1e95b959d51aec57"},+ "skills:runs/run:baseline@r00/routed": {"bytes": 68, "sha256": "cf6a7b5027626c144cf9f6ccc254f9bf6332217398c364638db88002139012ad"},+ "skills:runs/run:refine@r01/routed": {"bytes": 68, "sha256": "cf6a7b5027626c144cf9f6ccc254f9bf6332217398c364638db88002139012ad"}+ },+ "stage_keys": {+ "runs/run:plan": "d1428ecadc7f",+ "runs/run:skeleton": "7ad4f988e9ca"+ }+ },+ "graphics.opengl_python.agent.fresh": {+ "payloads": {+ "chat:planner:planner/messages": {"bytes": 348, "sha256": "f50fc3cdf3a426fc9c9b830b6e68d2cfe9fd9b7125550362b018f9c9b454b25c"},+ "chat:planner:planner/sampling": {"bytes": 3421, "sha256": "918170272cea656e8c542c54b777c57d1a4567a8cc36a0c1cd825cb81a01b9bb"},+ "chat:planner:planner/system": {"bytes": 14279, "sha256": "b9199fdf3a0bc64a88587f4b8c8efe1443bc20164e1b9e5eada29c7762adff2f"},+ "context:runs/run/files": {"bytes": 37038, "sha256": "3e27549d87e15bcfade7e49453aa3d98c42af816dc415e1a77229059c6194ff2"},+ "job:baseline@r00/prompt": {"bytes": 13696, "sha256": "b58dab6f7321774b49471e2ba461c767090d8a99fc9d546e194dffc551137e07"},+ "job:baseline@r00/scope": {"bytes": 358, "sha256": "b0e9a906ab8df3ff56acc08198289aa3958c470e5fd16a4e0225178a2d88e715"},+ "job:baseline@r00/system": {"bytes": 2729, "sha256": "d12d4891ce72156aa561bdfa0ed1fb20c5826412024b0be07b423949528e5df6"},+ "job:refine@r01/prompt": {"bytes": 4809, "sha256": "564c35401c05213d9906d0ecf84ead9e8c8a54ef51cae13eeb59fcb98e1b7275"},+ "job:refine@r01/scope": {"bytes": 354, "sha256": "81a4042ba077832530b2a9f64d3e1415da1b655b00caf1006ed51ee616a7b17b"},+ "job:refine@r01/system": {"bytes": 2729, "sha256": "d12d4891ce72156aa561bdfa0ed1fb20c5826412024b0be07b423949528e5df6"},+ "judge:shader_v2:runs/run/artifacts/renders/r00/input": {"bytes": 4028, "sha256": "c73efe7b56d4885794e8bc52178cd5d56c0c1edc71cae0eb72159619e69e6d75"},+ "judge:shader_v2:runs/run/artifacts/renders/r00/messages": {"bytes": 3731, "sha256": "355b5a5eb7617171897155fe818a3975dea97d127ae8416f1352a67bb6a84a19"},+ "judge:shader_v2:runs/run/artifacts/renders/r00/sampling": {"bytes": 11659, "sha256": "2f41a011f9775b7aaf1ec8c1594be4e9172d23f6eb6dfc4b262c6e6bf1097792"},+ "judge:shader_v2:runs/run/artifacts/renders/r00/system": {"bytes": 11256, "sha256": "27c834df165bcb2e2406b0045b141fd290cf85edc1fc104a1e95b959d51aec57"},+ "judge:shader_v2:runs/run/artifacts/renders/r01/input": {"bytes": 5081, "sha256": "d780a48e47e0701679920bd7b03fb703275968f4d36ee59e257453d45942a00c"},+ "judge:shader_v2:runs/run/artifacts/renders/r01/messages": {"bytes": 4127, "sha256": "a4c4a41eea8d4af3df6646d2aa757c01a0ab663614361e61e76e84e21f9d5378"},+ "judge:shader_v2:runs/run/artifacts/renders/r01/sampling": {"bytes": 11659, "sha256": "2f41a011f9775b7aaf1ec8c1594be4e9172d23f6eb6dfc4b262c6e6bf1097792"},+ "judge:shader_v2:runs/run/artifacts/renders/r01/system": {"bytes": 11256, "sha256": "27c834df165bcb2e2406b0045b141fd290cf85edc1fc104a1e95b959d51aec57"},+ "skills:runs/run:baseline@r00/routed": {"bytes": 61, "sha256": "6cf132dce307379276e442875a061e8e0d099d50b70a8d18d4622abd9ce8ee8c"},+ "skills:runs/run:refine@r01/routed": {"bytes": 61, "sha256": "6cf132dce307379276e442875a061e8e0d099d50b70a8d18d4622abd9ce8ee8c"}+ },+ "stage_keys": {+ "runs/run:plan": "f8b3f2dab137",+ "runs/run:skeleton": "52e9bc1e1abd"+ }+ },+ "mcp_tools": {+ "payloads": {+ "mcp_tools:articulated_object/urdf_blender": {"bytes": 6076, "sha256": "9ba4d7a23a10235a73e05c3b69a938a311ab8676de2c23e0724b4ca5b1df3c8c"},+ "mcp_tools:graphics/glsl_shader": {"bytes": 1758, "sha256": "dc50d45f22bfe4528834be2cc0e531ac3b61e4e2ca9fd695b75dce4e167d10d9"},+ "mcp_tools:graphics/opengl_python": {"bytes": 1758, "sha256": "dc50d45f22bfe4528834be2cc0e531ac3b61e4e2ca9fd695b75dce4e167d10d9"},+ "mcp_tools:scene/scene_blender": {"bytes": 2296, "sha256": "ab7fadea23288126101bbf33846e7e92d913dd80531c02073a9df72957d285b6"},+ "mcp_tools:scene/scene_threejs": {"bytes": 2648, "sha256": "45aee92d251829133bd551af187d455f1d11574a0ab28b33672635c552986796"},+ "mcp_tools:static_object/blender": {"bytes": 5345, "sha256": "d8e63f813e62440d94b37885f96a8cbe4b6c51dc191994baad5f18793098e57f"},+ "mcp_tools:static_object/cadquery": {"bytes": 5345, "sha256": "d8e63f813e62440d94b37885f96a8cbe4b6c51dc191994baad5f18793098e57f"},+ "mcp_tools:static_object/threejs": {"bytes": 5345, "sha256": "d8e63f813e62440d94b37885f96a8cbe4b6c51dc191994baad5f18793098e57f"}+ },+ "stage_keys": {}+ },+ "scene.scene_blender.agent.fresh": {+ "payloads": {+ "chat:model:asset_bollard:r00/messages": {"bytes": 11438, "sha256": "286832c63fa85410abe298f1bade7635df3045c972b9f32b49ad793ed71d630f"},+ "chat:model:asset_bollard:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_bollard:r00/system": {"bytes": 5023, "sha256": "d074993ed2d086f4f56f2dec743149795d59a213b8a178434af2a1761aab6a38"},+ "chat:model:asset_bollard_retry1:r00/messages": {"bytes": 11886, "sha256": "873bd0176ff772854cd05fdeb09e9924df69cf3b34eb1535ecea6a8d31021897"},+ "chat:model:asset_bollard_retry1:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_bollard_retry1:r00/system": {"bytes": 5023, "sha256": "d074993ed2d086f4f56f2dec743149795d59a213b8a178434af2a1761aab6a38"},+ "chat:model:asset_fishing_boat:r00/messages": {"bytes": 11482, "sha256": "61079d91f9d725f8ed23264f3f207041aa993d79144615358bd8e9691f9ebc7b"},+ "chat:model:asset_fishing_boat:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_fishing_boat:r00/system": {"bytes": 5023, "sha256": "d074993ed2d086f4f56f2dec743149795d59a213b8a178434af2a1761aab6a38"},+ "chat:planner:planner/messages": {"bytes": 204, "sha256": "b91c27cbf7a8071bf320a68a6113bd25896bf0422f92b9087fb155bad18dbdc1"},+ "chat:planner:planner/sampling": {"bytes": 8144, "sha256": "e3636117bd8a55214485c988e6b225712ac0da4431deaed3e9f6c3c4b8a79620"},+ "chat:planner:planner/system": {"bytes": 29723, "sha256": "c8bf6f664d7fd15dbae799dc6c0f904f7f13289b06daf476a7889160a1754ef8"},+ "chat:planner:zone-layout#0/messages": {"bytes": 331, "sha256": "eeefd42e9d8d37a901af0ae126aebf39fb2e7861fabe6208d3a9408e1a3c1b37"},+ "chat:planner:zone-layout#0/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#0/system": {"bytes": 3326, "sha256": "494acec302dd23fa2fc6ee1eb6d48e873d6cf0ad98bad413e27578cf062313d4"},+ "chat:planner:zone-layout#1/messages": {"bytes": 401, "sha256": "73206223434695497c74e5f8f5bc0a0f1b147a7dc38147645c6cf42b5372484b"},+ "chat:planner:zone-layout#1/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#1/system": {"bytes": 3391, "sha256": "fa6d28546a947ddc6ab8d0adb8af97a1605873109a47cf7f097f72d9788fd678"},+ "chat:planner:zone-layout#2/messages": {"bytes": 485, "sha256": "67e917190ee227c5ed3415ab4b03c072af313d7040704e7de671e63c42e2ab52"},+ "chat:planner:zone-layout#2/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#2/system": {"bytes": 3326, "sha256": "494acec302dd23fa2fc6ee1eb6d48e873d6cf0ad98bad413e27578cf062313d4"},+ "context:runs/run/files": {"bytes": 54602, "sha256": "3436b3a05bb9589304ea215d21a50b25e0a26f27c3879f445f7749a5b8b9911f"},+ "job:asset_bollard@r00/prompt": {"bytes": 12995, "sha256": "06653ddff53c0086045d18d4920a0e504ae9472547a06262501b5fd30be8a05a"},+ "job:asset_bollard@r00/scope": {"bytes": 357, "sha256": "ac9f0a7bea99ed4a97d2a2d943a7949b7d27a7dac648d57df5712db049586c00"},+ "job:asset_bollard@r00/system": {"bytes": 2537, "sha256": "7e9f8a86b9f2d38b846e5caad4949915462a3ce3411edfeabe7ed58d245eccb0"},+ "job:env@r00/prompt": {"bytes": 44177, "sha256": "37aaba781940e905e9e64d0e3a9668f4bb0318b6c5c3c07e79551549fd5a6d8e"},+ "job:env@r00/scope": {"bytes": 334, "sha256": "e47a619bae6cbaf0dd3d1feb2dc417f786a475434f454187f7446f3747c94ca5"},+ "job:env@r00/system": {"bytes": 6011, "sha256": "84a58b966fee66290cfdf85997e8ae0f25f840e457f4b331cac118873d2c5cef"},+ "job:refine_quay@r01/prompt": {"bytes": 11287, "sha256": "bac1bdf29a014cea74b373b222484c0b5e69d192bd2d65176e51833ac891ee2a"},+ "job:refine_quay@r01/scope": {"bytes": 352, "sha256": "132e651c00e62ebe39769b0c1d18930badf17f7c6e2bfe32e968931e71ce298f"},+ "job:refine_quay@r01/system": {"bytes": 6011, "sha256": "84a58b966fee66290cfdf85997e8ae0f25f840e457f4b331cac118873d2c5cef"},+ "job:refine_quay@r02/prompt": {"bytes": 11286, "sha256": "6e33c3bb70f189155de4ea700c2d2e109384a5040e9a7952d2eab639092f4571"},+ "job:refine_quay@r02/scope": {"bytes": 352, "sha256": "7c7d445e558ef3e5ec4bec50662efa7ea9db1310c1ca6fb401b05d0cdbc02cb0"},+ "job:refine_quay@r02/system": {"bytes": 6011, "sha256": "84a58b966fee66290cfdf85997e8ae0f25f840e457f4b331cac118873d2c5cef"},+ "job:refine_water@r01/prompt": {"bytes": 11292, "sha256": "f4835b7bfe0d270ed99f6835ecba39fa1e2be07fed39f4ad47fa5b9f13a10ef2"},+ "job:refine_water@r01/scope": {"bytes": 354, "sha256": "e684bc294d73d267c4447ebc58f2c16ded8cce6f7f032d9fa09ad4822d9b6f70"},+ "job:refine_water@r01/system": {"bytes": 6011, "sha256": "84a58b966fee66290cfdf85997e8ae0f25f840e457f4b331cac118873d2c5cef"},+ "job:refine_water@r02/prompt": {"bytes": 11291, "sha256": "2eaf0608ecf6b1d04397cbf7a09319f5d0c5f8ce70e73321580dbd8a3b54d407"},+ "job:refine_water@r02/scope": {"bytes": 354, "sha256": "41695e17f6da944fc5d7894428b9009e2785cf51bf0c7de1c2f99bde50f9c9eb"},+ "job:refine_water@r02/system": {"bytes": 6011, "sha256": "84a58b966fee66290cfdf85997e8ae0f25f840e457f4b331cac118873d2c5cef"},+ "job:zones_quay_water@r00/prompt": {"bytes": 50923, "sha256": "0f6b6c68040e7d87ba4125f9dcd91823cfee0e47d6849aa41a3f1c4e0d3f4c25"},+ "job:zones_quay_water@r00/scope": {"bytes": 379, "sha256": "d7cde9503b57c30d54062b7f12f1023f1510fad249cff287c3b771c306a065bf"},+ "job:zones_quay_water@r00/system": {"bytes": 6011, "sha256": "84a58b966fee66290cfdf85997e8ae0f25f840e457f4b331cac118873d2c5cef"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/input": {"bytes": 3755, "sha256": "11c9b8092135f98b61dfe0e47b77561a374ab89aaa22ed9472b9b731e3bf8e7f"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/messages": {"bytes": 4930, "sha256": "676859b5172ea33c86195b543b5c80e49dc907598dbdddb57a9734e58df9e8a1"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/sampling": {"bytes": 14066, "sha256": "1f67b211de491259bed48f1499b8dbd9fa2037a903a637ba53befda40ade693d"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/system": {"bytes": 21575, "sha256": "5e41f4637a72b54b410e31a08f362357d645437afaae85d69e15b7a5738aa307"},+ "judge:scene_v2:runs/run/artifacts/renders/r01/input": {"bytes": 4755, "sha256": "3788f8a25412e088c56476fd218179fa5dd0704ab1b8da7ae9dc8eb5551647e1"},+ "judge:scene_v2:runs/run/artifacts/renders/r01/messages": {"bytes": 5298, "sha256": "35679341c294b774ac1c228d9a2bc56f4792f8831dd1c216b513e4427e6cb0c1"},+ "judge:scene_v2:runs/run/artifacts/renders/r01/sampling": {"bytes": 14066, "sha256": "1f67b211de491259bed48f1499b8dbd9fa2037a903a637ba53befda40ade693d"},+ "judge:scene_v2:runs/run/artifacts/renders/r01/system": {"bytes": 21575, "sha256": "5e41f4637a72b54b410e31a08f362357d645437afaae85d69e15b7a5738aa307"},+ "judge:scene_v2:runs/run/artifacts/renders/r02/input": {"bytes": 4751, "sha256": "0afb2dd38366bbb0bbb539c943ef4eeeaf4bea82f8748de687eda5af887da0fe"},+ "judge:scene_v2:runs/run/artifacts/renders/r02/messages": {"bytes": 5298, "sha256": "0b15d27d13b64c082c86c2e4cea5d85a7f0b3e9daef93b5cb62f698d06570437"},+ "judge:scene_v2:runs/run/artifacts/renders/r02/sampling": {"bytes": 14066, "sha256": "1f67b211de491259bed48f1499b8dbd9fa2037a903a637ba53befda40ade693d"},+ "judge:scene_v2:runs/run/artifacts/renders/r02/system": {"bytes": 21575, "sha256": "5e41f4637a72b54b410e31a08f362357d645437afaae85d69e15b7a5738aa307"},+ "skills:runs/run:baseline@r00/routed": {"bytes": 35, "sha256": "607ad2fd09f3e6a0617f5d52cff3edf2a91bd286e8bf5b18d5f7c0e5f6dfff80"},+ "skills:runs/run:env@r00/routed": {"bytes": 122, "sha256": "b71c5d72d6d4265e0a320839c1e742785860c6103adf2bf6b62f85c6c7739d0c"},+ "skills:runs/run:refine@r01/routed": {"bytes": 122, "sha256": "b71c5d72d6d4265e0a320839c1e742785860c6103adf2bf6b62f85c6c7739d0c"},+ "skills:runs/run:refine@r02/routed": {"bytes": 122, "sha256": "b71c5d72d6d4265e0a320839c1e742785860c6103adf2bf6b62f85c6c7739d0c"},+ "skills:runs/run:zone@r00/routed": {"bytes": 122, "sha256": "b71c5d72d6d4265e0a320839c1e742785860c6103adf2bf6b62f85c6c7739d0c"}+ },+ "stage_keys": {+ "runs/run:assemble": "8cb488f00680",+ "runs/run:assets": "47a6e0c9cb08",+ "runs/run:env": "47a6e0c9cb08",+ "runs/run:layouts": "47a6e0c9cb08",+ "runs/run:plan": "8e0191e2d157",+ "runs/run:skeleton": "e42c2d2f88e0",+ "runs/run:zones": "ffb8ffe86289"+ }+ },+ "scene.scene_blender.agent.variant_argon_raw": {+ "payloads": {+ "chat:model:asset_bollard:r00/messages": {"bytes": 12581, "sha256": "d9b2993d620102574de019e2bffda4507df066a9f6620f539f752116a0171253"},+ "chat:model:asset_bollard:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_bollard:r00/system": {"bytes": 5223, "sha256": "a07eba89fabc4086ed399f0efda35c6bc78a8fc54c1b30bbff08fffb0a922b27"},+ "chat:model:asset_fishing_boat:r00/messages": {"bytes": 12625, "sha256": "896f312b383beaa6b22bdf5bb2ff49eda0d40467d4f4bef70306efa5fa0f82d4"},+ "chat:model:asset_fishing_boat:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_fishing_boat:r00/system": {"bytes": 5223, "sha256": "a07eba89fabc4086ed399f0efda35c6bc78a8fc54c1b30bbff08fffb0a922b27"},+ "chat:planner:planner/messages": {"bytes": 204, "sha256": "b91c27cbf7a8071bf320a68a6113bd25896bf0422f92b9087fb155bad18dbdc1"},+ "chat:planner:planner/sampling": {"bytes": 8144, "sha256": "e3636117bd8a55214485c988e6b225712ac0da4431deaed3e9f6c3c4b8a79620"},+ "chat:planner:planner/system": {"bytes": 29205, "sha256": "71ee264a440c3797e52f7e98a1cc4fd1b7d36336d100c5b85a176817947f8bbf"},+ "chat:planner:zone-layout#0/messages": {"bytes": 331, "sha256": "eeefd42e9d8d37a901af0ae126aebf39fb2e7861fabe6208d3a9408e1a3c1b37"},+ "chat:planner:zone-layout#0/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#0/system": {"bytes": 3326, "sha256": "494acec302dd23fa2fc6ee1eb6d48e873d6cf0ad98bad413e27578cf062313d4"},+ "chat:planner:zone-layout#1/messages": {"bytes": 401, "sha256": "73206223434695497c74e5f8f5bc0a0f1b147a7dc38147645c6cf42b5372484b"},+ "chat:planner:zone-layout#1/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#1/system": {"bytes": 3391, "sha256": "fa6d28546a947ddc6ab8d0adb8af97a1605873109a47cf7f097f72d9788fd678"},+ "chat:planner:zone-layout#2/messages": {"bytes": 485, "sha256": "67e917190ee227c5ed3415ab4b03c072af313d7040704e7de671e63c42e2ab52"},+ "chat:planner:zone-layout#2/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#2/system": {"bytes": 3326, "sha256": "494acec302dd23fa2fc6ee1eb6d48e873d6cf0ad98bad413e27578cf062313d4"},+ "context:runs/run/files": {"bytes": 60478, "sha256": "6016dbaa5b9008112d07be60ac672fcede80635a530805c9a8f8c4b5bf4b0250"},+ "job:env@r00/prompt": {"bytes": 31821, "sha256": "452285156323952fc678cadeca942364e31c196fab266b5c9cc2109daae102a5"},+ "job:env@r00/scope": {"bytes": 334, "sha256": "e47a619bae6cbaf0dd3d1feb2dc417f786a475434f454187f7446f3747c94ca5"},+ "job:env@r00/system": {"bytes": 7284, "sha256": "13fb6151a371cd11e8892f5b046bca581b917ccc1a267fef0aa4c189b26983f3"},+ "job:refine_quay@r01/prompt": {"bytes": 11824, "sha256": "5263700826ee3d83e98fd00bc5bdc1fa9310ff45edaa072f2e93dee55c2cf911"},+ "job:refine_quay@r01/scope": {"bytes": 352, "sha256": "132e651c00e62ebe39769b0c1d18930badf17f7c6e2bfe32e968931e71ce298f"},+ "job:refine_quay@r01/system": {"bytes": 7284, "sha256": "13fb6151a371cd11e8892f5b046bca581b917ccc1a267fef0aa4c189b26983f3"},+ "job:refine_water@r01/prompt": {"bytes": 11829, "sha256": "c71f602bcf91c347635f2fd4fc2cc453718dfc0b8d25a5288c51f17c6c7f1961"},+ "job:refine_water@r01/scope": {"bytes": 354, "sha256": "e684bc294d73d267c4447ebc58f2c16ded8cce6f7f032d9fa09ad4822d9b6f70"},+ "job:refine_water@r01/system": {"bytes": 7284, "sha256": "13fb6151a371cd11e8892f5b046bca581b917ccc1a267fef0aa4c189b26983f3"},+ "job:zones_quay_water@r00/prompt": {"bytes": 38696, "sha256": "8524b350a4485277de24641c0a67881e56b7c25879100cee0210417af6403a62"},+ "job:zones_quay_water@r00/scope": {"bytes": 379, "sha256": "d7cde9503b57c30d54062b7f12f1023f1510fad249cff287c3b771c306a065bf"},+ "job:zones_quay_water@r00/system": {"bytes": 7284, "sha256": "13fb6151a371cd11e8892f5b046bca581b917ccc1a267fef0aa4c189b26983f3"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/input": {"bytes": 3755, "sha256": "11c9b8092135f98b61dfe0e47b77561a374ab89aaa22ed9472b9b731e3bf8e7f"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/messages": {"bytes": 4930, "sha256": "676859b5172ea33c86195b543b5c80e49dc907598dbdddb57a9734e58df9e8a1"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/sampling": {"bytes": 14066, "sha256": "1f67b211de491259bed48f1499b8dbd9fa2037a903a637ba53befda40ade693d"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/system": {"bytes": 21575, "sha256": "5e41f4637a72b54b410e31a08f362357d645437afaae85d69e15b7a5738aa307"},+ "judge:scene_v2:runs/run/artifacts/renders/r01/input": {"bytes": 4755, "sha256": "3788f8a25412e088c56476fd218179fa5dd0704ab1b8da7ae9dc8eb5551647e1"},+ "judge:scene_v2:runs/run/artifacts/renders/r01/messages": {"bytes": 5298, "sha256": "35679341c294b774ac1c228d9a2bc56f4792f8831dd1c216b513e4427e6cb0c1"},+ "judge:scene_v2:runs/run/artifacts/renders/r01/sampling": {"bytes": 14066, "sha256": "1f67b211de491259bed48f1499b8dbd9fa2037a903a637ba53befda40ade693d"},+ "judge:scene_v2:runs/run/artifacts/renders/r01/system": {"bytes": 21575, "sha256": "5e41f4637a72b54b410e31a08f362357d645437afaae85d69e15b7a5738aa307"},+ "skills:runs/run:baseline@r00/routed": {"bytes": 35, "sha256": "607ad2fd09f3e6a0617f5d52cff3edf2a91bd286e8bf5b18d5f7c0e5f6dfff80"},+ "skills:runs/run:env@r00/routed": {"bytes": 122, "sha256": "b71c5d72d6d4265e0a320839c1e742785860c6103adf2bf6b62f85c6c7739d0c"},+ "skills:runs/run:refine@r01/routed": {"bytes": 122, "sha256": "b71c5d72d6d4265e0a320839c1e742785860c6103adf2bf6b62f85c6c7739d0c"},+ "skills:runs/run:zone@r00/routed": {"bytes": 122, "sha256": "b71c5d72d6d4265e0a320839c1e742785860c6103adf2bf6b62f85c6c7739d0c"}+ },+ "stage_keys": {+ "runs/run:assemble": "8cb488f00680",+ "runs/run:assets": "47a6e0c9cb08",+ "runs/run:env": "47a6e0c9cb08",+ "runs/run:layouts": "47a6e0c9cb08",+ "runs/run:plan": "b72e02659933",+ "runs/run:skeleton": "bb3344ab52c5",+ "runs/run:zones": "7dd540d9edd0"+ }+ },+ "scene.scene_blender.single_shot.fresh": {+ "payloads": {+ "chat:model:asset_bollard:r00#0/messages": {"bytes": 11438, "sha256": "286832c63fa85410abe298f1bade7635df3045c972b9f32b49ad793ed71d630f"},+ "chat:model:asset_bollard:r00#0/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_bollard:r00#0/system": {"bytes": 5023, "sha256": "d074993ed2d086f4f56f2dec743149795d59a213b8a178434af2a1761aab6a38"},+ "chat:model:asset_bollard:r00#1/messages": {"bytes": 11438, "sha256": "286832c63fa85410abe298f1bade7635df3045c972b9f32b49ad793ed71d630f"},+ "chat:model:asset_bollard:r00#1/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_bollard:r00#1/system": {"bytes": 5023, "sha256": "d074993ed2d086f4f56f2dec743149795d59a213b8a178434af2a1761aab6a38"},+ "chat:model:asset_bollard_retry1:r00/messages": {"bytes": 11886, "sha256": "873bd0176ff772854cd05fdeb09e9924df69cf3b34eb1535ecea6a8d31021897"},+ "chat:model:asset_bollard_retry1:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_bollard_retry1:r00/system": {"bytes": 5023, "sha256": "d074993ed2d086f4f56f2dec743149795d59a213b8a178434af2a1761aab6a38"},+ "chat:model:asset_fishing_boat:r00/messages": {"bytes": 11482, "sha256": "61079d91f9d725f8ed23264f3f207041aa993d79144615358bd8e9691f9ebc7b"},+ "chat:model:asset_fishing_boat:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_fishing_boat:r00/system": {"bytes": 5023, "sha256": "d074993ed2d086f4f56f2dec743149795d59a213b8a178434af2a1761aab6a38"},+ "chat:model:env:r00/messages": {"bytes": 53645, "sha256": "f5a27a05db78d65d9733377ff3e04229e4582f56bbdafb62d44e010157bc550e"},+ "chat:model:env:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:env:r00/system": {"bytes": 8371, "sha256": "d3578f116524eeb784b11d30ac62f981658be43de7b2cea76782e99c223f36fc"},+ "chat:model:refine_quay:r01/messages": {"bytes": 20274, "sha256": "d718a55dc3aead09c7bc1c9ec1bee81204eefcec7210323e5f8e841732c35081"},+ "chat:model:refine_quay:r01/sampling": {"bytes": 92, "sha256": "2a36044e5c117fc288123a5937c6e3cb5845f040b4de69f9c2440f623956c381"},+ "chat:model:refine_quay:r01/system": {"bytes": 8371, "sha256": "d3578f116524eeb784b11d30ac62f981658be43de7b2cea76782e99c223f36fc"},+ "chat:model:refine_water:r01/messages": {"bytes": 20280, "sha256": "61da533b7ca292e0bb5ee93b96d63127cda8ec61c86affc40bb99d96cc4f484c"},+ "chat:model:refine_water:r01/sampling": {"bytes": 92, "sha256": "2a36044e5c117fc288123a5937c6e3cb5845f040b4de69f9c2440f623956c381"},+ "chat:model:refine_water:r01/system": {"bytes": 8371, "sha256": "d3578f116524eeb784b11d30ac62f981658be43de7b2cea76782e99c223f36fc"},+ "chat:model:zones_quay_water:r00/messages": {"bytes": 60377, "sha256": "60b16c78e669d6f4eeacc0a4f638ef4f247d5457a616f64aa65c2c58c279fee9"},+ "chat:model:zones_quay_water:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:zones_quay_water:r00/system": {"bytes": 8371, "sha256": "d3578f116524eeb784b11d30ac62f981658be43de7b2cea76782e99c223f36fc"},+ "chat:planner:planner/messages": {"bytes": 204, "sha256": "b91c27cbf7a8071bf320a68a6113bd25896bf0422f92b9087fb155bad18dbdc1"},+ "chat:planner:planner/sampling": {"bytes": 8144, "sha256": "e3636117bd8a55214485c988e6b225712ac0da4431deaed3e9f6c3c4b8a79620"},+ "chat:planner:planner/system": {"bytes": 29723, "sha256": "c8bf6f664d7fd15dbae799dc6c0f904f7f13289b06daf476a7889160a1754ef8"},+ "chat:planner:zone-layout#0/messages": {"bytes": 331, "sha256": "eeefd42e9d8d37a901af0ae126aebf39fb2e7861fabe6208d3a9408e1a3c1b37"},+ "chat:planner:zone-layout#0/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#0/system": {"bytes": 3326, "sha256": "494acec302dd23fa2fc6ee1eb6d48e873d6cf0ad98bad413e27578cf062313d4"},+ "chat:planner:zone-layout#1/messages": {"bytes": 401, "sha256": "73206223434695497c74e5f8f5bc0a0f1b147a7dc38147645c6cf42b5372484b"},+ "chat:planner:zone-layout#1/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#1/system": {"bytes": 3391, "sha256": "fa6d28546a947ddc6ab8d0adb8af97a1605873109a47cf7f097f72d9788fd678"},+ "chat:planner:zone-layout#2/messages": {"bytes": 485, "sha256": "67e917190ee227c5ed3415ab4b03c072af313d7040704e7de671e63c42e2ab52"},+ "chat:planner:zone-layout#2/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#2/system": {"bytes": 3326, "sha256": "494acec302dd23fa2fc6ee1eb6d48e873d6cf0ad98bad413e27578cf062313d4"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/input": {"bytes": 3772, "sha256": "ff1c9893cb3e5f4d8f726e4d35fd23a0532523af32df0ca593728608b89a34c3"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/messages": {"bytes": 4930, "sha256": "676859b5172ea33c86195b543b5c80e49dc907598dbdddb57a9734e58df9e8a1"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/sampling": {"bytes": 14066, "sha256": "1f67b211de491259bed48f1499b8dbd9fa2037a903a637ba53befda40ade693d"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/system": {"bytes": 21575, "sha256": "5e41f4637a72b54b410e31a08f362357d645437afaae85d69e15b7a5738aa307"},+ "skills:runs/run:baseline@r00/routed": {"bytes": 35, "sha256": "607ad2fd09f3e6a0617f5d52cff3edf2a91bd286e8bf5b18d5f7c0e5f6dfff80"},+ "skills:runs/run:env@r00/routed": {"bytes": 143, "sha256": "a2ca52eb478b4f896bec65a65d4385cc8c79db85d5f827f556ded75fa5812d5f"},+ "skills:runs/run:refine@r01/routed": {"bytes": 143, "sha256": "a2ca52eb478b4f896bec65a65d4385cc8c79db85d5f827f556ded75fa5812d5f"},+ "skills:runs/run:zone@r00/routed": {"bytes": 143, "sha256": "a2ca52eb478b4f896bec65a65d4385cc8c79db85d5f827f556ded75fa5812d5f"}+ },+ "stage_keys": {+ "runs/run:assemble": "8cb488f00680",+ "runs/run:assets": "65004503e9ac",+ "runs/run:env": "65004503e9ac",+ "runs/run:layouts": "65004503e9ac",+ "runs/run:plan": "8e0191e2d157",+ "runs/run:skeleton": "e42c2d2f88e0",+ "runs/run:zones": "dd826357aa4a"+ }+ },+ "scene.scene_threejs.agent.fresh": {+ "payloads": {+ "chat:model:asset_bollard:r00/messages": {"bytes": 3327, "sha256": "1a2c11617634f2944f0e66819a64d644a0180612213856e98575191a481f2a5b"},+ "chat:model:asset_bollard:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_bollard:r00/system": {"bytes": 3483, "sha256": "79f9f153926a1b9edee34e0fbc13767ff419319c18575fc0ad2bb553d9e6f3ad"},+ "chat:model:asset_bollard_retry1:r00/messages": {"bytes": 3785, "sha256": "5cb8fc62c626a2507e6b13708c0d90296b98cae926de90debba50ee7540f1d15"},+ "chat:model:asset_bollard_retry1:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_bollard_retry1:r00/system": {"bytes": 3483, "sha256": "79f9f153926a1b9edee34e0fbc13767ff419319c18575fc0ad2bb553d9e6f3ad"},+ "chat:model:asset_fishing_boat:r00/messages": {"bytes": 3365, "sha256": "583f9c5888c4ff1567e3cbb2d9e3e8701e31169fd30f295d89dae16e046e55cc"},+ "chat:model:asset_fishing_boat:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_fishing_boat:r00/system": {"bytes": 3483, "sha256": "79f9f153926a1b9edee34e0fbc13767ff419319c18575fc0ad2bb553d9e6f3ad"},+ "chat:planner:planner/messages": {"bytes": 204, "sha256": "b91c27cbf7a8071bf320a68a6113bd25896bf0422f92b9087fb155bad18dbdc1"},+ "chat:planner:planner/sampling": {"bytes": 8047, "sha256": "ac5eba7173d30fcdfc0682ff102fc65e9f4325a5a4f1fbdaca4b0dcd4547d4b1"},+ "chat:planner:planner/system": {"bytes": 26885, "sha256": "1dd3bb7f2490e9e655149e12cffeebcb43c6b91559b78bc942a4e38f741f7223"},+ "chat:planner:zone-layout#0/messages": {"bytes": 331, "sha256": "eeefd42e9d8d37a901af0ae126aebf39fb2e7861fabe6208d3a9408e1a3c1b37"},+ "chat:planner:zone-layout#0/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#0/system": {"bytes": 3326, "sha256": "494acec302dd23fa2fc6ee1eb6d48e873d6cf0ad98bad413e27578cf062313d4"},+ "chat:planner:zone-layout#1/messages": {"bytes": 401, "sha256": "73206223434695497c74e5f8f5bc0a0f1b147a7dc38147645c6cf42b5372484b"},+ "chat:planner:zone-layout#1/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#1/system": {"bytes": 3391, "sha256": "fa6d28546a947ddc6ab8d0adb8af97a1605873109a47cf7f097f72d9788fd678"},+ "chat:planner:zone-layout#2/messages": {"bytes": 485, "sha256": "67e917190ee227c5ed3415ab4b03c072af313d7040704e7de671e63c42e2ab52"},+ "chat:planner:zone-layout#2/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#2/system": {"bytes": 3326, "sha256": "494acec302dd23fa2fc6ee1eb6d48e873d6cf0ad98bad413e27578cf062313d4"},+ "context:runs/run/files": {"bytes": 55862, "sha256": "86406a7632ccef0cc564c8b96fafddfe0bb401dfeeeccfdb476e730ac5a1661b"},+ "job:asset_bollard@r00/prompt": {"bytes": 5182, "sha256": "eb2371d5d91daf0664ea4155eed95618b5798277e9b8e5cd118e48181aa499a3"},+ "job:asset_bollard@r00/scope": {"bytes": 357, "sha256": "450d659126efa73cdfe3371f18464e6ab40230af78367de6994d4712c9a8aaaf"},+ "job:asset_bollard@r00/system": {"bytes": 997, "sha256": "20d72b3bb074ab09ce4b2b6656b8bd0fcffef4fd3d437f2c171cb3efd96d475c"},+ "job:env@r00/prompt": {"bytes": 47541, "sha256": "9b99f01eaaca7ad62a4e0ba8210f3c6c6d70fc095631a0c616dbbf067f597fb6"},+ "job:env@r00/scope": {"bytes": 334, "sha256": "b94c09720c9e481759ea0408d7ef708c4d5a3e47b1c2b28a8d901a7c77d7c66b"},+ "job:env@r00/system": {"bytes": 5614, "sha256": "b23b5fa6365b226f94f9cf4e9f3f7235628d22c1bee3ca22c6f44406ce518cdb"},+ "job:refine_quay@r01/prompt": {"bytes": 10092, "sha256": "7424fa604c576ccaa58bb104174f27b1ff6b38ea9682f3335170b1d821e73bd0"},+ "job:refine_quay@r01/scope": {"bytes": 352, "sha256": "95a620093126d95e34400b4879d58c03bb641810cf02cc497835c80890c54a01"},+ "job:refine_quay@r01/system": {"bytes": 5614, "sha256": "b23b5fa6365b226f94f9cf4e9f3f7235628d22c1bee3ca22c6f44406ce518cdb"},+ "job:refine_quay@r02/prompt": {"bytes": 10091, "sha256": "a7903f9067f34e57d0427111e8fe759f3f3d34e7c654b8f8baf2798aaa19bdc8"},+ "job:refine_quay@r02/scope": {"bytes": 352, "sha256": "8aa778406fd06798c42801c5bc312072027e3d61c29b95e15a785dd2bdff4d2d"},+ "job:refine_quay@r02/system": {"bytes": 5614, "sha256": "b23b5fa6365b226f94f9cf4e9f3f7235628d22c1bee3ca22c6f44406ce518cdb"},+ "job:refine_water@r01/prompt": {"bytes": 10097, "sha256": "2af3470e4b4cf5e411e22cc5402886696b2adc9eaf0460a7b934b5351ccb73e0"},+ "job:refine_water@r01/scope": {"bytes": 354, "sha256": "5c7aa29b996f768b637082248e69fbe65f7ed49d9f5abff27c464da564365b74"},+ "job:refine_water@r01/system": {"bytes": 5614, "sha256": "b23b5fa6365b226f94f9cf4e9f3f7235628d22c1bee3ca22c6f44406ce518cdb"},+ "job:refine_water@r02/prompt": {"bytes": 10096, "sha256": "99d6e0866d9bc4a9475f55db3e6b6efc7166bcb74b0bd80dd8157fa319086045"},+ "job:refine_water@r02/scope": {"bytes": 354, "sha256": "cbf41e8b42c1c64671a237a42d06bd8188616fd533a767c716e64758d211f737"},+ "job:refine_water@r02/system": {"bytes": 5614, "sha256": "b23b5fa6365b226f94f9cf4e9f3f7235628d22c1bee3ca22c6f44406ce518cdb"},+ "job:zones_quay_water@r00/prompt": {"bytes": 53496, "sha256": "82b80505d5bb0ecc0ed5c7bc53f7d0bafdb8dc8102cb51c314e6628b3e7ffbcc"},+ "job:zones_quay_water@r00/scope": {"bytes": 379, "sha256": "5b1def419a1370ab2d9f2345bc4a5232ef3c793d4e4f1e01bd5ab9a3a8e88a7d"},+ "job:zones_quay_water@r00/system": {"bytes": 5614, "sha256": "b23b5fa6365b226f94f9cf4e9f3f7235628d22c1bee3ca22c6f44406ce518cdb"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/input": {"bytes": 3755, "sha256": "7fa5ae748295e277f0edb9fc51a241ac20ccf6c64a88431cb95bf08313fb661a"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/messages": {"bytes": 4930, "sha256": "562ef4bfc6b24c34604482cb73a02fb4b01da5c0e70685e3a1a4e1dda616a827"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/sampling": {"bytes": 14066, "sha256": "1f67b211de491259bed48f1499b8dbd9fa2037a903a637ba53befda40ade693d"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/system": {"bytes": 21575, "sha256": "5e41f4637a72b54b410e31a08f362357d645437afaae85d69e15b7a5738aa307"},+ "judge:scene_v2:runs/run/artifacts/renders/r01/input": {"bytes": 4755, "sha256": "b386a92b7164f283a376ee84122a5ab109a1b709e28ade5a269337fe8c587ae0"},+ "judge:scene_v2:runs/run/artifacts/renders/r01/messages": {"bytes": 5298, "sha256": "c9a488e3385bb803ce084eda9a1ad2ed58c338201f1ad6d7f416cf0070f1a9f1"},+ "judge:scene_v2:runs/run/artifacts/renders/r01/sampling": {"bytes": 14066, "sha256": "1f67b211de491259bed48f1499b8dbd9fa2037a903a637ba53befda40ade693d"},+ "judge:scene_v2:runs/run/artifacts/renders/r01/system": {"bytes": 21575, "sha256": "5e41f4637a72b54b410e31a08f362357d645437afaae85d69e15b7a5738aa307"},+ "judge:scene_v2:runs/run/artifacts/renders/r02/input": {"bytes": 4751, "sha256": "2300148c08e41d46deca89c02bad3af6d0f0170538b7ab50c270c8ad09977938"},+ "judge:scene_v2:runs/run/artifacts/renders/r02/messages": {"bytes": 5298, "sha256": "d8e7af12d299bcc4d09f7b68a6cdf3de2816e89d0d785ff88153c9e3aa5ce8cd"},+ "judge:scene_v2:runs/run/artifacts/renders/r02/sampling": {"bytes": 14066, "sha256": "1f67b211de491259bed48f1499b8dbd9fa2037a903a637ba53befda40ade693d"},+ "judge:scene_v2:runs/run/artifacts/renders/r02/system": {"bytes": 21575, "sha256": "5e41f4637a72b54b410e31a08f362357d645437afaae85d69e15b7a5738aa307"},+ "skills:runs/run:baseline@r00/routed": {"bytes": 156, "sha256": "cae5ab46c39f9f4efb7ae3c4758b05d768025f93d525d5e13812b916a583fd30"},+ "skills:runs/run:env@r00/routed": {"bytes": 164, "sha256": "eb0e2aca5a76b26e49a2d2c862a9405ef2e3e1130e719cca9a1f23fe1b264402"},+ "skills:runs/run:refine@r01/routed": {"bytes": 156, "sha256": "cae5ab46c39f9f4efb7ae3c4758b05d768025f93d525d5e13812b916a583fd30"},+ "skills:runs/run:refine@r02/routed": {"bytes": 156, "sha256": "cae5ab46c39f9f4efb7ae3c4758b05d768025f93d525d5e13812b916a583fd30"},+ "skills:runs/run:zone@r00/routed": {"bytes": 161, "sha256": "c2efc99419ed923cc9093c675fa27abc39d11613b9d2ac59e2cc5aea67d7d191"}+ },+ "stage_keys": {+ "runs/run:assemble": "eb288074ac5b",+ "runs/run:assets": "e3fcf2d29017",+ "runs/run:env": "e3fcf2d29017",+ "runs/run:layouts": "e3fcf2d29017",+ "runs/run:plan": "28eda606da62",+ "runs/run:skeleton": "6bd35d0cf375",+ "runs/run:zones": "0526c0ee5233"+ }+ },+ "scene.scene_threejs.agent.hero": {+ "payloads": {+ "chat:model:asset_bollard:r00/messages": {"bytes": 3327, "sha256": "1a2c11617634f2944f0e66819a64d644a0180612213856e98575191a481f2a5b"},+ "chat:model:asset_bollard:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_bollard:r00/system": {"bytes": 3483, "sha256": "79f9f153926a1b9edee34e0fbc13767ff419319c18575fc0ad2bb553d9e6f3ad"},+ "chat:model:asset_crate:r00/messages": {"bytes": 28754, "sha256": "76710705dfa70657bd10f155601464201cd7506c683f102e892e122f18906f98"},+ "chat:model:asset_crate:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_crate:r00/system": {"bytes": 6102, "sha256": "b932457fbc413fc389a472807f935cc2723359ace21242ed41eb255a6fcaeff8"},+ "chat:model:asset_crate_fix:r00/messages": {"bytes": 15864, "sha256": "a4ba0af706d2dc66f5b5a3d243bc2b5e91cb1d8b8c5d7535f3ccc60800bd04a9"},+ "chat:model:asset_crate_fix:r00/sampling": {"bytes": 92, "sha256": "2a36044e5c117fc288123a5937c6e3cb5845f040b4de69f9c2440f623956c381"},+ "chat:model:asset_crate_fix:r00/system": {"bytes": 6102, "sha256": "b932457fbc413fc389a472807f935cc2723359ace21242ed41eb255a6fcaeff8"},+ "chat:model:asset_crate_retry1:r00/messages": {"bytes": 16322, "sha256": "c542d6ccdea3f9c537d189cdbc13c978dad34be8893c5c77fb6c376ff7f9d308"},+ "chat:model:asset_crate_retry1:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_crate_retry1:r00/system": {"bytes": 6102, "sha256": "b932457fbc413fc389a472807f935cc2723359ace21242ed41eb255a6fcaeff8"},+ "chat:model:asset_fishing_boat:r00/messages": {"bytes": 3365, "sha256": "583f9c5888c4ff1567e3cbb2d9e3e8701e31169fd30f295d89dae16e046e55cc"},+ "chat:model:asset_fishing_boat:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_fishing_boat:r00/system": {"bytes": 3483, "sha256": "79f9f153926a1b9edee34e0fbc13767ff419319c18575fc0ad2bb553d9e6f3ad"},+ "chat:model:planner-brief/messages": {"bytes": 150, "sha256": "0e611164b25a22a92f87f33ae2b588b8f67ab88423523ab8983799456104bede"},+ "chat:model:planner-brief/sampling": {"bytes": 4774, "sha256": "ac0bb868a0ed6551f5374840bf146b6e0b4fbb014f10a856fd306ec44357226a"},+ "chat:model:planner-brief/system": {"bytes": 3133, "sha256": "a66f0fe3b4610d21d0969a732e8d15f208a1147fe6a0ec6ce97606e400142580"},+ "chat:model:planner/messages": {"bytes": 1365, "sha256": "6325382c4f0b1d922a2c10300ef002b9571f58f4689d3f5f85cf23f7b6e13036"},+ "chat:model:planner/sampling": {"bytes": 6272, "sha256": "04dbfbbd42d8b93a12571a1908beacc7eb471e6f2c0fc077371aa86e2a99fb40"},+ "chat:model:planner/system": {"bytes": 20977, "sha256": "0a3c2ea2bfb39981a166952054d1dcc10dffdf097d493e89b03e0b8586d2ee8e"},+ "chat:planner:planner/messages": {"bytes": 204, "sha256": "b91c27cbf7a8071bf320a68a6113bd25896bf0422f92b9087fb155bad18dbdc1"},+ "chat:planner:planner/sampling": {"bytes": 8047, "sha256": "ac5eba7173d30fcdfc0682ff102fc65e9f4325a5a4f1fbdaca4b0dcd4547d4b1"},+ "chat:planner:planner/system": {"bytes": 26885, "sha256": "1dd3bb7f2490e9e655149e12cffeebcb43c6b91559b78bc942a4e38f741f7223"},+ "chat:planner:zone-layout#0/messages": {"bytes": 401, "sha256": "73206223434695497c74e5f8f5bc0a0f1b147a7dc38147645c6cf42b5372484b"},+ "chat:planner:zone-layout#0/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#0/system": {"bytes": 3391, "sha256": "fa6d28546a947ddc6ab8d0adb8af97a1605873109a47cf7f097f72d9788fd678"},+ "chat:planner:zone-layout#1/messages": {"bytes": 578, "sha256": "b1ea4d4560c019eb95849ddd349110ffa3f71202a0774115bad9e5b0c46c17e1"},+ "chat:planner:zone-layout#1/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#1/system": {"bytes": 3361, "sha256": "9acfcedb047a4f1623c483cb99c1f8aa30fd1158e56f88d1c1518f138db1b34f"},+ "chat:planner:zone-layout#2/messages": {"bytes": 338, "sha256": "cf35cdac8d52e9f3d5da4cb2419e4bc4292f83757f4f60afa75b94ab4bfea20f"},+ "chat:planner:zone-layout#2/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#2/system": {"bytes": 3361, "sha256": "9acfcedb047a4f1623c483cb99c1f8aa30fd1158e56f88d1c1518f138db1b34f"},+ "context:runs/run/_assets/crate/files": {"bytes": 32490, "sha256": "6bba6c21d5e1c44df63b28444347a0322975c382acbc24df63c93830f972761c"},+ "context:runs/run/files": {"bytes": 55862, "sha256": "86406a7632ccef0cc564c8b96fafddfe0bb401dfeeeccfdb476e730ac5a1661b"},+ "job:asset_crate@r00/prompt": {"bytes": 18032, "sha256": "27dfd5f4bedcc036f93c844230347401da2c4c4f8b1d300bfaece147b704c3fc"},+ "job:asset_crate@r00/scope": {"bytes": 430, "sha256": "3c4b45fd7cc847cc6a6a5f3b83784cddab99440be445d61f924f56b834cd1476"},+ "job:asset_crate@r00/system": {"bytes": 3716, "sha256": "6068eff7b8c36b4edcc5d64ead79bd3de7386e0bbaf4fb141210883fb34f8518"},+ "job:env@r00/prompt": {"bytes": 47541, "sha256": "9b99f01eaaca7ad62a4e0ba8210f3c6c6d70fc095631a0c616dbbf067f597fb6"},+ "job:env@r00/scope": {"bytes": 334, "sha256": "b94c09720c9e481759ea0408d7ef708c4d5a3e47b1c2b28a8d901a7c77d7c66b"},+ "job:env@r00/system": {"bytes": 5614, "sha256": "b23b5fa6365b226f94f9cf4e9f3f7235628d22c1bee3ca22c6f44406ce518cdb"},+ "job:zones_quay_water@r00/prompt": {"bytes": 53676, "sha256": "3b2b4db061b894aca9121f762690c234369d83ea0d960bb5172ad2f4a5684726"},+ "job:zones_quay_water@r00/scope": {"bytes": 379, "sha256": "5b1def419a1370ab2d9f2345bc4a5232ef3c793d4e4f1e01bd5ab9a3a8e88a7d"},+ "job:zones_quay_water@r00/system": {"bytes": 5614, "sha256": "b23b5fa6365b226f94f9cf4e9f3f7235628d22c1bee3ca22c6f44406ce518cdb"},+ "judge:asset_v1:runs/run/_assets/crate/artifacts/renders/r00/assets/crate/input": {"bytes": 3824, "sha256": "d2b8392354ef8ee0eaaa261eedb39f1c73fddc4373960c48d513e50b707daa57"},+ "judge:asset_v1:runs/run/_assets/crate/artifacts/renders/r00/assets/crate/messages": {"bytes": 3099, "sha256": "eee511c765a105054417cb3fa37bf67c24bcf9022da44dc086385878a61d5f67"},+ "judge:asset_v1:runs/run/_assets/crate/artifacts/renders/r00/assets/crate/sampling": {"bytes": 8355, "sha256": "a80299c8dfc30739d05a0274526c361cb406c78a1ab5e923fcdf78d8c78ea73a"},+ "judge:asset_v1:runs/run/_assets/crate/artifacts/renders/r00/assets/crate/system": {"bytes": 8837, "sha256": "6dbacdd03ad0deab9f9264199b854eb37d8c29b58b5eaab8d1e78544f319a4f5"},+ "judge:asset_v1:runs/run/_assets/crate/artifacts/renders/r00/assets/crate_fix/input": {"bytes": 3844, "sha256": "f53c37a588a498c52a403ce9178c0aea6e599a0b8ec944c1a9a88baf0e6ef175"},+ "judge:asset_v1:runs/run/_assets/crate/artifacts/renders/r00/assets/crate_fix/messages": {"bytes": 3099, "sha256": "eee511c765a105054417cb3fa37bf67c24bcf9022da44dc086385878a61d5f67"},+ "judge:asset_v1:runs/run/_assets/crate/artifacts/renders/r00/assets/crate_fix/sampling": {"bytes": 8355, "sha256": "a80299c8dfc30739d05a0274526c361cb406c78a1ab5e923fcdf78d8c78ea73a"},+ "judge:asset_v1:runs/run/_assets/crate/artifacts/renders/r00/assets/crate_fix/system": {"bytes": 8837, "sha256": "6dbacdd03ad0deab9f9264199b854eb37d8c29b58b5eaab8d1e78544f319a4f5"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/input": {"bytes": 3762, "sha256": "44cfcf9a5d4f9e2ccb999185652b82d5b75a589f088dedcce128cbe2e0d0b958"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/messages": {"bytes": 4937, "sha256": "407f918497c4e96ed25d4a9c5c968993644c2a43fadfcc1bc6a0c4f7e6a9d99f"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/sampling": {"bytes": 14066, "sha256": "1f67b211de491259bed48f1499b8dbd9fa2037a903a637ba53befda40ade693d"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/system": {"bytes": 21575, "sha256": "5e41f4637a72b54b410e31a08f362357d645437afaae85d69e15b7a5738aa307"},+ "skills:runs/run:baseline@r00/routed": {"bytes": 156, "sha256": "cae5ab46c39f9f4efb7ae3c4758b05d768025f93d525d5e13812b916a583fd30"},+ "skills:runs/run:env@r00/routed": {"bytes": 164, "sha256": "eb0e2aca5a76b26e49a2d2c862a9405ef2e3e1130e719cca9a1f23fe1b264402"},+ "skills:runs/run:zone@r00/routed": {"bytes": 161, "sha256": "c2efc99419ed923cc9093c675fa27abc39d11613b9d2ac59e2cc5aea67d7d191"}+ },+ "stage_keys": {+ "runs/run:assemble": "ede2340ac2e9",+ "runs/run:assets": "2e61537ff1c0",+ "runs/run:env": "2e61537ff1c0",+ "runs/run:layouts": "2e61537ff1c0",+ "runs/run:plan": "28eda606da62",+ "runs/run:skeleton": "dba1ece541d0",+ "runs/run:zones": "77a6039e286c"+ }+ },+ "scene.scene_threejs.agent.no_layouts": {+ "payloads": {+ "chat:model:asset_bollard:r00/messages": {"bytes": 3327, "sha256": "1a2c11617634f2944f0e66819a64d644a0180612213856e98575191a481f2a5b"},+ "chat:model:asset_bollard:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_bollard:r00/system": {"bytes": 3483, "sha256": "79f9f153926a1b9edee34e0fbc13767ff419319c18575fc0ad2bb553d9e6f3ad"},+ "chat:model:asset_fishing_boat:r00/messages": {"bytes": 3365, "sha256": "583f9c5888c4ff1567e3cbb2d9e3e8701e31169fd30f295d89dae16e046e55cc"},+ "chat:model:asset_fishing_boat:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_fishing_boat:r00/system": {"bytes": 3483, "sha256": "79f9f153926a1b9edee34e0fbc13767ff419319c18575fc0ad2bb553d9e6f3ad"},+ "chat:planner:planner/messages": {"bytes": 204, "sha256": "b91c27cbf7a8071bf320a68a6113bd25896bf0422f92b9087fb155bad18dbdc1"},+ "chat:planner:planner/sampling": {"bytes": 8047, "sha256": "ac5eba7173d30fcdfc0682ff102fc65e9f4325a5a4f1fbdaca4b0dcd4547d4b1"},+ "chat:planner:planner/system": {"bytes": 26885, "sha256": "1dd3bb7f2490e9e655149e12cffeebcb43c6b91559b78bc942a4e38f741f7223"},+ "context:runs/run/files": {"bytes": 55862, "sha256": "86406a7632ccef0cc564c8b96fafddfe0bb401dfeeeccfdb476e730ac5a1661b"},+ "job:env@r00/prompt": {"bytes": 47541, "sha256": "9b99f01eaaca7ad62a4e0ba8210f3c6c6d70fc095631a0c616dbbf067f597fb6"},+ "job:env@r00/scope": {"bytes": 334, "sha256": "b94c09720c9e481759ea0408d7ef708c4d5a3e47b1c2b28a8d901a7c77d7c66b"},+ "job:env@r00/system": {"bytes": 5614, "sha256": "b23b5fa6365b226f94f9cf4e9f3f7235628d22c1bee3ca22c6f44406ce518cdb"},+ "job:zones_quay_water@r00/prompt": {"bytes": 52823, "sha256": "2a2e8d28955755da2036d29d9deb83a462d43e649e2e0845f0bab8cb746edf1c"},+ "job:zones_quay_water@r00/scope": {"bytes": 379, "sha256": "5b1def419a1370ab2d9f2345bc4a5232ef3c793d4e4f1e01bd5ab9a3a8e88a7d"},+ "job:zones_quay_water@r00/system": {"bytes": 5614, "sha256": "b23b5fa6365b226f94f9cf4e9f3f7235628d22c1bee3ca22c6f44406ce518cdb"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/input": {"bytes": 3755, "sha256": "c1ace02589db83a171c73e42785af63acd95ac141b2c40cb1439e12ded9bd12c"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/messages": {"bytes": 4930, "sha256": "562ef4bfc6b24c34604482cb73a02fb4b01da5c0e70685e3a1a4e1dda616a827"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/sampling": {"bytes": 14066, "sha256": "1f67b211de491259bed48f1499b8dbd9fa2037a903a637ba53befda40ade693d"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/system": {"bytes": 21575, "sha256": "5e41f4637a72b54b410e31a08f362357d645437afaae85d69e15b7a5738aa307"},+ "skills:runs/run:baseline@r00/routed": {"bytes": 156, "sha256": "cae5ab46c39f9f4efb7ae3c4758b05d768025f93d525d5e13812b916a583fd30"},+ "skills:runs/run:env@r00/routed": {"bytes": 164, "sha256": "eb0e2aca5a76b26e49a2d2c862a9405ef2e3e1130e719cca9a1f23fe1b264402"},+ "skills:runs/run:zone@r00/routed": {"bytes": 161, "sha256": "c2efc99419ed923cc9093c675fa27abc39d11613b9d2ac59e2cc5aea67d7d191"}+ },+ "stage_keys": {+ "runs/run:assemble": "eb288074ac5b",+ "runs/run:assets": "e3fcf2d29017",+ "runs/run:env": "e3fcf2d29017",+ "runs/run:plan": "28eda606da62",+ "runs/run:skeleton": "6bd35d0cf375",+ "runs/run:zones": "799b540cc58b"+ }+ },+ "scene.scene_threejs.agent.rebuild": {+ "payloads": {+ "chat:model:asset_bollard:r00/messages": {"bytes": 3327, "sha256": "1a2c11617634f2944f0e66819a64d644a0180612213856e98575191a481f2a5b"},+ "chat:model:asset_bollard:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_bollard:r00/system": {"bytes": 3483, "sha256": "79f9f153926a1b9edee34e0fbc13767ff419319c18575fc0ad2bb553d9e6f3ad"},+ "chat:model:asset_fishing_boat:r00/messages": {"bytes": 3365, "sha256": "583f9c5888c4ff1567e3cbb2d9e3e8701e31169fd30f295d89dae16e046e55cc"},+ "chat:model:asset_fishing_boat:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_fishing_boat:r00/system": {"bytes": 3483, "sha256": "79f9f153926a1b9edee34e0fbc13767ff419319c18575fc0ad2bb553d9e6f3ad"},+ "chat:planner:planner/messages": {"bytes": 204, "sha256": "b91c27cbf7a8071bf320a68a6113bd25896bf0422f92b9087fb155bad18dbdc1"},+ "chat:planner:planner/sampling": {"bytes": 8047, "sha256": "ac5eba7173d30fcdfc0682ff102fc65e9f4325a5a4f1fbdaca4b0dcd4547d4b1"},+ "chat:planner:planner/system": {"bytes": 26885, "sha256": "1dd3bb7f2490e9e655149e12cffeebcb43c6b91559b78bc942a4e38f741f7223"},+ "chat:planner:zone-layout#0/messages": {"bytes": 331, "sha256": "eeefd42e9d8d37a901af0ae126aebf39fb2e7861fabe6208d3a9408e1a3c1b37"},+ "chat:planner:zone-layout#0/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#0/system": {"bytes": 3326, "sha256": "494acec302dd23fa2fc6ee1eb6d48e873d6cf0ad98bad413e27578cf062313d4"},+ "chat:planner:zone-layout#1/messages": {"bytes": 401, "sha256": "73206223434695497c74e5f8f5bc0a0f1b147a7dc38147645c6cf42b5372484b"},+ "chat:planner:zone-layout#1/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#1/system": {"bytes": 3391, "sha256": "fa6d28546a947ddc6ab8d0adb8af97a1605873109a47cf7f097f72d9788fd678"},+ "chat:planner:zone-layout#2/messages": {"bytes": 485, "sha256": "67e917190ee227c5ed3415ab4b03c072af313d7040704e7de671e63c42e2ab52"},+ "chat:planner:zone-layout#2/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#2/system": {"bytes": 3326, "sha256": "494acec302dd23fa2fc6ee1eb6d48e873d6cf0ad98bad413e27578cf062313d4"},+ "context:runs/run/files": {"bytes": 55862, "sha256": "86406a7632ccef0cc564c8b96fafddfe0bb401dfeeeccfdb476e730ac5a1661b"},+ "job:env@r00/prompt": {"bytes": 47541, "sha256": "9b99f01eaaca7ad62a4e0ba8210f3c6c6d70fc095631a0c616dbbf067f597fb6"},+ "job:env@r00/scope": {"bytes": 334, "sha256": "b94c09720c9e481759ea0408d7ef708c4d5a3e47b1c2b28a8d901a7c77d7c66b"},+ "job:env@r00/system": {"bytes": 5614, "sha256": "b23b5fa6365b226f94f9cf4e9f3f7235628d22c1bee3ca22c6f44406ce518cdb"},+ "job:r00_baseline_repair1@r00/prompt": {"bytes": 3261, "sha256": "d6f7ee211ced016d303fba6017d6c0d86148b201135f6b9e659220f797bcc967"},+ "job:r00_baseline_repair1@r00/scope": {"bytes": 392, "sha256": "3321d34981a6a1b8621a35e4260c3378e9659f6371db48dbcfbd6a23e7d8547d"},+ "job:r00_baseline_repair1@r00/system": {"bytes": 22966, "sha256": "3256222fb8ed89256633f06e4d5e772a25f523ae19e4d6664030233ce3a2b92f"},+ "job:r00_baseline_repair2@r00/prompt": {"bytes": 3566, "sha256": "9095f72e1353c3ec863bff95f03c6de38ed4f19dc90420926eac8b9be360b7ec"},+ "job:r00_baseline_repair2@r00/scope": {"bytes": 394, "sha256": "7cb6a3e71ece9cc8d28cb865866a4877727e69d379c03d4a45a411b5414741d1"},+ "job:r00_baseline_repair2@r00/system": {"bytes": 22966, "sha256": "3256222fb8ed89256633f06e4d5e772a25f523ae19e4d6664030233ce3a2b92f"},+ "job:r01_refine_repair1@r01/prompt": {"bytes": 3261, "sha256": "d6f7ee211ced016d303fba6017d6c0d86148b201135f6b9e659220f797bcc967"},+ "job:r01_refine_repair1@r01/scope": {"bytes": 390, "sha256": "c69eaed8419cbb3ca77f53c7d3c95376ea17825ab53ecfb476b9c77c389a31d3"},+ "job:r01_refine_repair1@r01/system": {"bytes": 22966, "sha256": "3256222fb8ed89256633f06e4d5e772a25f523ae19e4d6664030233ce3a2b92f"},+ "job:r01_refine_repair2@r01/prompt": {"bytes": 3566, "sha256": "9095f72e1353c3ec863bff95f03c6de38ed4f19dc90420926eac8b9be360b7ec"},+ "job:r01_refine_repair2@r01/scope": {"bytes": 392, "sha256": "68a7f7b764450f2c01bca83cc4ff4ccf70cc065902e80b97985922a7383ecd19"},+ "job:r01_refine_repair2@r01/system": {"bytes": 22966, "sha256": "3256222fb8ed89256633f06e4d5e772a25f523ae19e4d6664030233ce3a2b92f"},+ "job:rebuild@r01/prompt": {"bytes": 10049, "sha256": "aa103063270f75b7b12d2f4e9d0795c02c69651ae119a3ee404e2e59391260a1"},+ "job:rebuild@r01/scope": {"bytes": 382, "sha256": "6ea60c37d5ea2360a24a236ed77174ca29ebdcb1ed8331da08e68fc494305dc9"},+ "job:rebuild@r01/system": {"bytes": 5614, "sha256": "b23b5fa6365b226f94f9cf4e9f3f7235628d22c1bee3ca22c6f44406ce518cdb"},+ "job:zones_quay_water@r00/prompt": {"bytes": 53496, "sha256": "82b80505d5bb0ecc0ed5c7bc53f7d0bafdb8dc8102cb51c314e6628b3e7ffbcc"},+ "job:zones_quay_water@r00/scope": {"bytes": 379, "sha256": "5b1def419a1370ab2d9f2345bc4a5232ef3c793d4e4f1e01bd5ab9a3a8e88a7d"},+ "job:zones_quay_water@r00/system": {"bytes": 5614, "sha256": "b23b5fa6365b226f94f9cf4e9f3f7235628d22c1bee3ca22c6f44406ce518cdb"},+ "skills:runs/run:baseline@r00/routed": {"bytes": 156, "sha256": "cae5ab46c39f9f4efb7ae3c4758b05d768025f93d525d5e13812b916a583fd30"},+ "skills:runs/run:env@r00/routed": {"bytes": 164, "sha256": "eb0e2aca5a76b26e49a2d2c862a9405ef2e3e1130e719cca9a1f23fe1b264402"},+ "skills:runs/run:refine@r01/routed": {"bytes": 156, "sha256": "cae5ab46c39f9f4efb7ae3c4758b05d768025f93d525d5e13812b916a583fd30"},+ "skills:runs/run:zone@r00/routed": {"bytes": 161, "sha256": "c2efc99419ed923cc9093c675fa27abc39d11613b9d2ac59e2cc5aea67d7d191"}+ },+ "stage_keys": {+ "runs/run:assemble": "eb288074ac5b",+ "runs/run:assets": "e3fcf2d29017",+ "runs/run:env": "e3fcf2d29017",+ "runs/run:layouts": "e3fcf2d29017",+ "runs/run:plan": "28eda606da62",+ "runs/run:skeleton": "6bd35d0cf375",+ "runs/run:zones": "0526c0ee5233"+ }+ },+ "scene.scene_threejs.agent.textures": {+ "payloads": {+ "chat:model:asset_bollard:r00/messages": {"bytes": 3327, "sha256": "1a2c11617634f2944f0e66819a64d644a0180612213856e98575191a481f2a5b"},+ "chat:model:asset_bollard:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_bollard:r00/system": {"bytes": 3483, "sha256": "79f9f153926a1b9edee34e0fbc13767ff419319c18575fc0ad2bb553d9e6f3ad"},+ "chat:model:asset_fishing_boat:r00/messages": {"bytes": 3365, "sha256": "583f9c5888c4ff1567e3cbb2d9e3e8701e31169fd30f295d89dae16e046e55cc"},+ "chat:model:asset_fishing_boat:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_fishing_boat:r00/system": {"bytes": 3483, "sha256": "79f9f153926a1b9edee34e0fbc13767ff419319c18575fc0ad2bb553d9e6f3ad"},+ "chat:planner:planner/messages": {"bytes": 204, "sha256": "b91c27cbf7a8071bf320a68a6113bd25896bf0422f92b9087fb155bad18dbdc1"},+ "chat:planner:planner/sampling": {"bytes": 8047, "sha256": "ac5eba7173d30fcdfc0682ff102fc65e9f4325a5a4f1fbdaca4b0dcd4547d4b1"},+ "chat:planner:planner/system": {"bytes": 26885, "sha256": "1dd3bb7f2490e9e655149e12cffeebcb43c6b91559b78bc942a4e38f741f7223"},+ "chat:planner:zone-layout#0/messages": {"bytes": 331, "sha256": "eeefd42e9d8d37a901af0ae126aebf39fb2e7861fabe6208d3a9408e1a3c1b37"},+ "chat:planner:zone-layout#0/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#0/system": {"bytes": 3326, "sha256": "494acec302dd23fa2fc6ee1eb6d48e873d6cf0ad98bad413e27578cf062313d4"},+ "chat:planner:zone-layout#1/messages": {"bytes": 401, "sha256": "73206223434695497c74e5f8f5bc0a0f1b147a7dc38147645c6cf42b5372484b"},+ "chat:planner:zone-layout#1/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#1/system": {"bytes": 3391, "sha256": "fa6d28546a947ddc6ab8d0adb8af97a1605873109a47cf7f097f72d9788fd678"},+ "chat:planner:zone-layout#2/messages": {"bytes": 485, "sha256": "67e917190ee227c5ed3415ab4b03c072af313d7040704e7de671e63c42e2ab52"},+ "chat:planner:zone-layout#2/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#2/system": {"bytes": 3326, "sha256": "494acec302dd23fa2fc6ee1eb6d48e873d6cf0ad98bad413e27578cf062313d4"},+ "context:runs/run/files": {"bytes": 55862, "sha256": "86406a7632ccef0cc564c8b96fafddfe0bb401dfeeeccfdb476e730ac5a1661b"},+ "job:env@r00/prompt": {"bytes": 48546, "sha256": "6108648e54442871662fc2e5d3d3df97856d185e5f06bbe3fef7915c4b7b54da"},+ "job:env@r00/scope": {"bytes": 334, "sha256": "b94c09720c9e481759ea0408d7ef708c4d5a3e47b1c2b28a8d901a7c77d7c66b"},+ "job:env@r00/system": {"bytes": 5614, "sha256": "b23b5fa6365b226f94f9cf4e9f3f7235628d22c1bee3ca22c6f44406ce518cdb"},+ "job:refine_quay@r01/prompt": {"bytes": 10092, "sha256": "7424fa604c576ccaa58bb104174f27b1ff6b38ea9682f3335170b1d821e73bd0"},+ "job:refine_quay@r01/scope": {"bytes": 352, "sha256": "95a620093126d95e34400b4879d58c03bb641810cf02cc497835c80890c54a01"},+ "job:refine_quay@r01/system": {"bytes": 5614, "sha256": "b23b5fa6365b226f94f9cf4e9f3f7235628d22c1bee3ca22c6f44406ce518cdb"},+ "job:refine_water@r01/prompt": {"bytes": 10097, "sha256": "2af3470e4b4cf5e411e22cc5402886696b2adc9eaf0460a7b934b5351ccb73e0"},+ "job:refine_water@r01/scope": {"bytes": 354, "sha256": "5c7aa29b996f768b637082248e69fbe65f7ed49d9f5abff27c464da564365b74"},+ "job:refine_water@r01/system": {"bytes": 5614, "sha256": "b23b5fa6365b226f94f9cf4e9f3f7235628d22c1bee3ca22c6f44406ce518cdb"},+ "job:zones_quay_water@r00/prompt": {"bytes": 54501, "sha256": "daf87c38db35731f599f42c8028f4c1111a2d346ee7ac3c482f809208db9513a"},+ "job:zones_quay_water@r00/scope": {"bytes": 379, "sha256": "5b1def419a1370ab2d9f2345bc4a5232ef3c793d4e4f1e01bd5ab9a3a8e88a7d"},+ "job:zones_quay_water@r00/system": {"bytes": 5614, "sha256": "b23b5fa6365b226f94f9cf4e9f3f7235628d22c1bee3ca22c6f44406ce518cdb"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/input": {"bytes": 3755, "sha256": "c1ace02589db83a171c73e42785af63acd95ac141b2c40cb1439e12ded9bd12c"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/messages": {"bytes": 4930, "sha256": "562ef4bfc6b24c34604482cb73a02fb4b01da5c0e70685e3a1a4e1dda616a827"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/sampling": {"bytes": 14066, "sha256": "1f67b211de491259bed48f1499b8dbd9fa2037a903a637ba53befda40ade693d"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/system": {"bytes": 21575, "sha256": "5e41f4637a72b54b410e31a08f362357d645437afaae85d69e15b7a5738aa307"},+ "judge:scene_v2:runs/run/artifacts/renders/r01/input": {"bytes": 4755, "sha256": "b386a92b7164f283a376ee84122a5ab109a1b709e28ade5a269337fe8c587ae0"},+ "judge:scene_v2:runs/run/artifacts/renders/r01/messages": {"bytes": 5298, "sha256": "c9a488e3385bb803ce084eda9a1ad2ed58c338201f1ad6d7f416cf0070f1a9f1"},+ "judge:scene_v2:runs/run/artifacts/renders/r01/sampling": {"bytes": 14066, "sha256": "1f67b211de491259bed48f1499b8dbd9fa2037a903a637ba53befda40ade693d"},+ "judge:scene_v2:runs/run/artifacts/renders/r01/system": {"bytes": 21575, "sha256": "5e41f4637a72b54b410e31a08f362357d645437afaae85d69e15b7a5738aa307"},+ "skills:runs/run:baseline@r00/routed": {"bytes": 156, "sha256": "cae5ab46c39f9f4efb7ae3c4758b05d768025f93d525d5e13812b916a583fd30"},+ "skills:runs/run:env@r00/routed": {"bytes": 164, "sha256": "eb0e2aca5a76b26e49a2d2c862a9405ef2e3e1130e719cca9a1f23fe1b264402"},+ "skills:runs/run:refine@r01/routed": {"bytes": 156, "sha256": "cae5ab46c39f9f4efb7ae3c4758b05d768025f93d525d5e13812b916a583fd30"},+ "skills:runs/run:zone@r00/routed": {"bytes": 161, "sha256": "c2efc99419ed923cc9093c675fa27abc39d11613b9d2ac59e2cc5aea67d7d191"}+ },+ "stage_keys": {+ "runs/run:assemble": "eb288074ac5b",+ "runs/run:assets": "e3fcf2d29017",+ "runs/run:env": "da005e145164",+ "runs/run:layouts": "e3fcf2d29017",+ "runs/run:plan": "28eda606da62",+ "runs/run:skeleton": "6bd35d0cf375",+ "runs/run:textures": "eb288074ac5b",+ "runs/run:zones": "df7f829d5cce"+ }+ },+ "scene.scene_threejs.agent.variant_argon": {+ "payloads": {+ "chat:model:asset_bollard:r00/messages": {"bytes": 3327, "sha256": "1a2c11617634f2944f0e66819a64d644a0180612213856e98575191a481f2a5b"},+ "chat:model:asset_bollard:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_bollard:r00/system": {"bytes": 3483, "sha256": "79f9f153926a1b9edee34e0fbc13767ff419319c18575fc0ad2bb553d9e6f3ad"},+ "chat:model:asset_fishing_boat:r00/messages": {"bytes": 3365, "sha256": "583f9c5888c4ff1567e3cbb2d9e3e8701e31169fd30f295d89dae16e046e55cc"},+ "chat:model:asset_fishing_boat:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_fishing_boat:r00/system": {"bytes": 3483, "sha256": "79f9f153926a1b9edee34e0fbc13767ff419319c18575fc0ad2bb553d9e6f3ad"},+ "chat:planner:planner/messages": {"bytes": 204, "sha256": "b91c27cbf7a8071bf320a68a6113bd25896bf0422f92b9087fb155bad18dbdc1"},+ "chat:planner:planner/sampling": {"bytes": 8047, "sha256": "ac5eba7173d30fcdfc0682ff102fc65e9f4325a5a4f1fbdaca4b0dcd4547d4b1"},+ "chat:planner:planner/system": {"bytes": 26885, "sha256": "1dd3bb7f2490e9e655149e12cffeebcb43c6b91559b78bc942a4e38f741f7223"},+ "chat:planner:zone-layout#0/messages": {"bytes": 331, "sha256": "eeefd42e9d8d37a901af0ae126aebf39fb2e7861fabe6208d3a9408e1a3c1b37"},+ "chat:planner:zone-layout#0/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#0/system": {"bytes": 3326, "sha256": "494acec302dd23fa2fc6ee1eb6d48e873d6cf0ad98bad413e27578cf062313d4"},+ "chat:planner:zone-layout#1/messages": {"bytes": 401, "sha256": "73206223434695497c74e5f8f5bc0a0f1b147a7dc38147645c6cf42b5372484b"},+ "chat:planner:zone-layout#1/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#1/system": {"bytes": 3391, "sha256": "fa6d28546a947ddc6ab8d0adb8af97a1605873109a47cf7f097f72d9788fd678"},+ "chat:planner:zone-layout#2/messages": {"bytes": 485, "sha256": "67e917190ee227c5ed3415ab4b03c072af313d7040704e7de671e63c42e2ab52"},+ "chat:planner:zone-layout#2/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#2/system": {"bytes": 3326, "sha256": "494acec302dd23fa2fc6ee1eb6d48e873d6cf0ad98bad413e27578cf062313d4"},+ "context:runs/run/files": {"bytes": 55862, "sha256": "86406a7632ccef0cc564c8b96fafddfe0bb401dfeeeccfdb476e730ac5a1661b"},+ "job:env@r00/prompt": {"bytes": 47541, "sha256": "9b99f01eaaca7ad62a4e0ba8210f3c6c6d70fc095631a0c616dbbf067f597fb6"},+ "job:env@r00/scope": {"bytes": 334, "sha256": "b94c09720c9e481759ea0408d7ef708c4d5a3e47b1c2b28a8d901a7c77d7c66b"},+ "job:env@r00/system": {"bytes": 5614, "sha256": "b23b5fa6365b226f94f9cf4e9f3f7235628d22c1bee3ca22c6f44406ce518cdb"},+ "job:refine_quay@r01/prompt": {"bytes": 10092, "sha256": "7424fa604c576ccaa58bb104174f27b1ff6b38ea9682f3335170b1d821e73bd0"},+ "job:refine_quay@r01/scope": {"bytes": 352, "sha256": "95a620093126d95e34400b4879d58c03bb641810cf02cc497835c80890c54a01"},+ "job:refine_quay@r01/system": {"bytes": 5614, "sha256": "b23b5fa6365b226f94f9cf4e9f3f7235628d22c1bee3ca22c6f44406ce518cdb"},+ "job:refine_water@r01/prompt": {"bytes": 10097, "sha256": "2af3470e4b4cf5e411e22cc5402886696b2adc9eaf0460a7b934b5351ccb73e0"},+ "job:refine_water@r01/scope": {"bytes": 354, "sha256": "5c7aa29b996f768b637082248e69fbe65f7ed49d9f5abff27c464da564365b74"},+ "job:refine_water@r01/system": {"bytes": 5614, "sha256": "b23b5fa6365b226f94f9cf4e9f3f7235628d22c1bee3ca22c6f44406ce518cdb"},+ "job:zones_quay_water@r00/prompt": {"bytes": 53496, "sha256": "82b80505d5bb0ecc0ed5c7bc53f7d0bafdb8dc8102cb51c314e6628b3e7ffbcc"},+ "job:zones_quay_water@r00/scope": {"bytes": 379, "sha256": "5b1def419a1370ab2d9f2345bc4a5232ef3c793d4e4f1e01bd5ab9a3a8e88a7d"},+ "job:zones_quay_water@r00/system": {"bytes": 5614, "sha256": "b23b5fa6365b226f94f9cf4e9f3f7235628d22c1bee3ca22c6f44406ce518cdb"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/input": {"bytes": 3755, "sha256": "7fa5ae748295e277f0edb9fc51a241ac20ccf6c64a88431cb95bf08313fb661a"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/messages": {"bytes": 4930, "sha256": "562ef4bfc6b24c34604482cb73a02fb4b01da5c0e70685e3a1a4e1dda616a827"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/sampling": {"bytes": 14066, "sha256": "1f67b211de491259bed48f1499b8dbd9fa2037a903a637ba53befda40ade693d"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/system": {"bytes": 21575, "sha256": "5e41f4637a72b54b410e31a08f362357d645437afaae85d69e15b7a5738aa307"},+ "judge:scene_v2:runs/run/artifacts/renders/r01/input": {"bytes": 4755, "sha256": "b386a92b7164f283a376ee84122a5ab109a1b709e28ade5a269337fe8c587ae0"},+ "judge:scene_v2:runs/run/artifacts/renders/r01/messages": {"bytes": 5298, "sha256": "c9a488e3385bb803ce084eda9a1ad2ed58c338201f1ad6d7f416cf0070f1a9f1"},+ "judge:scene_v2:runs/run/artifacts/renders/r01/sampling": {"bytes": 14066, "sha256": "1f67b211de491259bed48f1499b8dbd9fa2037a903a637ba53befda40ade693d"},+ "judge:scene_v2:runs/run/artifacts/renders/r01/system": {"bytes": 21575, "sha256": "5e41f4637a72b54b410e31a08f362357d645437afaae85d69e15b7a5738aa307"},+ "skills:runs/run:baseline@r00/routed": {"bytes": 156, "sha256": "cae5ab46c39f9f4efb7ae3c4758b05d768025f93d525d5e13812b916a583fd30"},+ "skills:runs/run:env@r00/routed": {"bytes": 164, "sha256": "eb0e2aca5a76b26e49a2d2c862a9405ef2e3e1130e719cca9a1f23fe1b264402"},+ "skills:runs/run:refine@r01/routed": {"bytes": 156, "sha256": "cae5ab46c39f9f4efb7ae3c4758b05d768025f93d525d5e13812b916a583fd30"},+ "skills:runs/run:zone@r00/routed": {"bytes": 161, "sha256": "c2efc99419ed923cc9093c675fa27abc39d11613b9d2ac59e2cc5aea67d7d191"}+ },+ "stage_keys": {+ "runs/run:assemble": "eb288074ac5b",+ "runs/run:assets": "e3fcf2d29017",+ "runs/run:env": "e3fcf2d29017",+ "runs/run:layouts": "e3fcf2d29017",+ "runs/run:plan": "6aa5a2da6b3e",+ "runs/run:skeleton": "6bd35d0cf375",+ "runs/run:zones": "0526c0ee5233"+ }+ },+ "scene.scene_threejs.single_shot.fresh": {+ "payloads": {+ "chat:model:asset_bollard:r00#0/messages": {"bytes": 3327, "sha256": "1a2c11617634f2944f0e66819a64d644a0180612213856e98575191a481f2a5b"},+ "chat:model:asset_bollard:r00#0/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_bollard:r00#0/system": {"bytes": 3483, "sha256": "79f9f153926a1b9edee34e0fbc13767ff419319c18575fc0ad2bb553d9e6f3ad"},+ "chat:model:asset_bollard:r00#1/messages": {"bytes": 3327, "sha256": "1a2c11617634f2944f0e66819a64d644a0180612213856e98575191a481f2a5b"},+ "chat:model:asset_bollard:r00#1/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_bollard:r00#1/system": {"bytes": 3483, "sha256": "79f9f153926a1b9edee34e0fbc13767ff419319c18575fc0ad2bb553d9e6f3ad"},+ "chat:model:asset_bollard_retry1:r00/messages": {"bytes": 3785, "sha256": "5cb8fc62c626a2507e6b13708c0d90296b98cae926de90debba50ee7540f1d15"},+ "chat:model:asset_bollard_retry1:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_bollard_retry1:r00/system": {"bytes": 3483, "sha256": "79f9f153926a1b9edee34e0fbc13767ff419319c18575fc0ad2bb553d9e6f3ad"},+ "chat:model:asset_fishing_boat:r00/messages": {"bytes": 3365, "sha256": "583f9c5888c4ff1567e3cbb2d9e3e8701e31169fd30f295d89dae16e046e55cc"},+ "chat:model:asset_fishing_boat:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:asset_fishing_boat:r00/system": {"bytes": 3483, "sha256": "79f9f153926a1b9edee34e0fbc13767ff419319c18575fc0ad2bb553d9e6f3ad"},+ "chat:model:env:r00/messages": {"bytes": 50719, "sha256": "3b8afa7c088512b3bfc6445896fed38aacaa43edaf26c960e1865834cd332c94"},+ "chat:model:env:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:env:r00/system": {"bytes": 7632, "sha256": "2c187b396badbf62b604234f29d488679bf5a0446f67f0cfacb703509fc1e8ea"},+ "chat:model:refine_quay:r01/messages": {"bytes": 12743, "sha256": "6e2f8e2e31894a19a9b2f53eeaf49a912d8c275000d544fdbe8799914fbf8424"},+ "chat:model:refine_quay:r01/sampling": {"bytes": 92, "sha256": "2a36044e5c117fc288123a5937c6e3cb5845f040b4de69f9c2440f623956c381"},+ "chat:model:refine_quay:r01/system": {"bytes": 7632, "sha256": "2c187b396badbf62b604234f29d488679bf5a0446f67f0cfacb703509fc1e8ea"},+ "chat:model:refine_water:r01/messages": {"bytes": 12749, "sha256": "6d7aa7a9336bc7c56c169f3e59e64f8ea5ca1f703bdc22442d5a57ac48c19f61"},+ "chat:model:refine_water:r01/sampling": {"bytes": 92, "sha256": "2a36044e5c117fc288123a5937c6e3cb5845f040b4de69f9c2440f623956c381"},+ "chat:model:refine_water:r01/system": {"bytes": 7632, "sha256": "2c187b396badbf62b604234f29d488679bf5a0446f67f0cfacb703509fc1e8ea"},+ "chat:model:zones_quay_water:r00/messages": {"bytes": 56535, "sha256": "94637b6f2d5ffd44651f34af82ae45502fdd75bd8df1250c2a12ace6c2fa87d5"},+ "chat:model:zones_quay_water:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:zones_quay_water:r00/system": {"bytes": 7632, "sha256": "2c187b396badbf62b604234f29d488679bf5a0446f67f0cfacb703509fc1e8ea"},+ "chat:planner:planner/messages": {"bytes": 204, "sha256": "b91c27cbf7a8071bf320a68a6113bd25896bf0422f92b9087fb155bad18dbdc1"},+ "chat:planner:planner/sampling": {"bytes": 8047, "sha256": "ac5eba7173d30fcdfc0682ff102fc65e9f4325a5a4f1fbdaca4b0dcd4547d4b1"},+ "chat:planner:planner/system": {"bytes": 26885, "sha256": "1dd3bb7f2490e9e655149e12cffeebcb43c6b91559b78bc942a4e38f741f7223"},+ "chat:planner:zone-layout#0/messages": {"bytes": 331, "sha256": "eeefd42e9d8d37a901af0ae126aebf39fb2e7861fabe6208d3a9408e1a3c1b37"},+ "chat:planner:zone-layout#0/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#0/system": {"bytes": 3326, "sha256": "494acec302dd23fa2fc6ee1eb6d48e873d6cf0ad98bad413e27578cf062313d4"},+ "chat:planner:zone-layout#1/messages": {"bytes": 401, "sha256": "73206223434695497c74e5f8f5bc0a0f1b147a7dc38147645c6cf42b5372484b"},+ "chat:planner:zone-layout#1/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#1/system": {"bytes": 3391, "sha256": "fa6d28546a947ddc6ab8d0adb8af97a1605873109a47cf7f097f72d9788fd678"},+ "chat:planner:zone-layout#2/messages": {"bytes": 485, "sha256": "67e917190ee227c5ed3415ab4b03c072af313d7040704e7de671e63c42e2ab52"},+ "chat:planner:zone-layout#2/sampling": {"bytes": 3397, "sha256": "160445a83ede28afc0191547fd42d9341e694ef70aaad380bebf60ead0a65c49"},+ "chat:planner:zone-layout#2/system": {"bytes": 3326, "sha256": "494acec302dd23fa2fc6ee1eb6d48e873d6cf0ad98bad413e27578cf062313d4"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/input": {"bytes": 3772, "sha256": "b905874db5d6112f7b8a77387b6158354f02e473d901f29516e684e3d56b80ab"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/messages": {"bytes": 4930, "sha256": "562ef4bfc6b24c34604482cb73a02fb4b01da5c0e70685e3a1a4e1dda616a827"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/sampling": {"bytes": 14066, "sha256": "1f67b211de491259bed48f1499b8dbd9fa2037a903a637ba53befda40ade693d"},+ "judge:scene_v2:runs/run/artifacts/renders/r00/system": {"bytes": 21575, "sha256": "5e41f4637a72b54b410e31a08f362357d645437afaae85d69e15b7a5738aa307"},+ "skills:runs/run:baseline@r00/routed": {"bytes": 169, "sha256": "6ccf83dd133ef358e077dc682854e631d69bb44f6a3db6e91910c6f89d8d9455"},+ "skills:runs/run:env@r00/routed": {"bytes": 177, "sha256": "997130b7576c4ce74eaf0489faf7318c0c1815f8f5337cdc081b1b20295b8bd9"},+ "skills:runs/run:refine@r01/routed": {"bytes": 169, "sha256": "6ccf83dd133ef358e077dc682854e631d69bb44f6a3db6e91910c6f89d8d9455"},+ "skills:runs/run:zone@r00/routed": {"bytes": 174, "sha256": "12a61a473fd3ef3f19c0ba43f1608e885bd736a2dd94f454d8f8ffbe96cfe6a6"}+ },+ "stage_keys": {+ "runs/run:assemble": "eb288074ac5b",+ "runs/run:assets": "05ff6fdbf6e4",+ "runs/run:env": "05ff6fdbf6e4",+ "runs/run:layouts": "05ff6fdbf6e4",+ "runs/run:plan": "28eda606da62",+ "runs/run:skeleton": "6bd35d0cf375",+ "runs/run:zones": "f535201189a7"+ }+ },+ "static_object.blender.agent.best_of_2": {+ "payloads": {+ "chat:planner:planner-brief/messages": {"bytes": 170, "sha256": "c59acfe245bb7cf2ca7111a65960824587e06cd8914a4d7ca9c8eba234fe6393"},+ "chat:planner:planner-brief/sampling": {"bytes": 4774, "sha256": "ac0bb868a0ed6551f5374840bf146b6e0b4fbb014f10a856fd306ec44357226a"},+ "chat:planner:planner-brief/system": {"bytes": 3133, "sha256": "a66f0fe3b4610d21d0969a732e8d15f208a1147fe6a0ec6ce97606e400142580"},+ "chat:planner:planner/messages": {"bytes": 1354, "sha256": "5b1a589e27562a3668649aed4be4857a34804a2acdc140eb8fb3630d970f71a6"},+ "chat:planner:planner/sampling": {"bytes": 6272, "sha256": "04dbfbbd42d8b93a12571a1908beacc7eb471e6f2c0fc077371aa86e2a99fb40"},+ "chat:planner:planner/system": {"bytes": 20977, "sha256": "0a3c2ea2bfb39981a166952054d1dcc10dffdf097d493e89b03e0b8586d2ee8e"},+ "context:runs/run/_cand/c0/files": {"bytes": 46888, "sha256": "ecc25aaa2d6ad33ac74a2f8379b2814e8f27e3c09e8fce879118fd31183a3d76"},+ "context:runs/run/_cand/c1/files": {"bytes": 46888, "sha256": "ecc25aaa2d6ad33ac74a2f8379b2814e8f27e3c09e8fce879118fd31183a3d76"},+ "context:runs/run/files": {"bytes": 46888, "sha256": "ecc25aaa2d6ad33ac74a2f8379b2814e8f27e3c09e8fce879118fd31183a3d76"},+ "job:baseline_c0@r00/prompt": {"bytes": 20798, "sha256": "eb5375ddaa912a3cc1d7cb4abbad186e9a57dccd552b447681f82acd22e9b21a"},+ "job:baseline_c0@r00/scope": {"bytes": 434, "sha256": "2654f6339a446c7181633e50fb347ef3b3002dd0dc96cd6f88db21018f2fd4ba"},+ "job:baseline_c0@r00/system": {"bytes": 2865, "sha256": "e8bdde0b2251c9f422c9a02c8c457543798280f5215e740312ffb73f1d0d867f"},+ "job:baseline_c1@r00/prompt": {"bytes": 20798, "sha256": "eb5375ddaa912a3cc1d7cb4abbad186e9a57dccd552b447681f82acd22e9b21a"},+ "job:baseline_c1@r00/scope": {"bytes": 434, "sha256": "ea7fa63b68b2e822ddab3b4fbe0fcd7db185a3127ef747f85616b2784fa63311"},+ "job:baseline_c1@r00/system": {"bytes": 2865, "sha256": "e8bdde0b2251c9f422c9a02c8c457543798280f5215e740312ffb73f1d0d867f"},+ "job:refine@r01/prompt": {"bytes": 7333, "sha256": "d0c65719f1734b9f7ee2f082d1b772314daebebdbafde9fdb36694833aed20c1"},+ "job:refine@r01/scope": {"bytes": 426, "sha256": "3a39df2f37665e52ae78549431ea567fa9591605332e152cd7d41d2b58914893"},+ "job:refine@r01/system": {"bytes": 2865, "sha256": "e8bdde0b2251c9f422c9a02c8c457543798280f5215e740312ffb73f1d0d867f"},+ "judge:static_object_v1:runs/run/_cand/c0/artifacts/renders/r00/quick/input": {"bytes": 5545, "sha256": "6041286d7536f146c7f66b22021c7fcf38a73e1627be58ab10dd741251d9a242"},+ "judge:static_object_v1:runs/run/_cand/c0/artifacts/renders/r00/quick/messages": {"bytes": 4246, "sha256": "029c3c03fe1f78f6f0d8b6b1b6bb4825d2851b55595a3c15c1a03f052b0b9771"},+ "judge:static_object_v1:runs/run/_cand/c0/artifacts/renders/r00/quick/sampling": {"bytes": 11368, "sha256": "d689cdebe9d63a438597fd51e16228f8d5fed5d5693c736223ce782f62a12242"},+ "judge:static_object_v1:runs/run/_cand/c0/artifacts/renders/r00/quick/system": {"bytes": 15181, "sha256": "3575c0106dc2f760c7b997e75932b9e37662f45394bba5516c5feebac72fe1bc"},+ "judge:static_object_v1:runs/run/_cand/c1/artifacts/renders/r00/quick/input": {"bytes": 5545, "sha256": "cec8a9d579957e61327fef43f3d0a0568555b0b162ffea5e140d78a6f1714524"},+ "judge:static_object_v1:runs/run/_cand/c1/artifacts/renders/r00/quick/messages": {"bytes": 4246, "sha256": "029c3c03fe1f78f6f0d8b6b1b6bb4825d2851b55595a3c15c1a03f052b0b9771"},+ "judge:static_object_v1:runs/run/_cand/c1/artifacts/renders/r00/quick/sampling": {"bytes": 11368, "sha256": "d689cdebe9d63a438597fd51e16228f8d5fed5d5693c736223ce782f62a12242"},+ "judge:static_object_v1:runs/run/_cand/c1/artifacts/renders/r00/quick/system": {"bytes": 15181, "sha256": "3575c0106dc2f760c7b997e75932b9e37662f45394bba5516c5feebac72fe1bc"},+ "judge:static_object_v1:runs/run/artifacts/renders/r00/input": {"bytes": 9108, "sha256": "060f49684b12ce285d2616a38f07d5c1b01c6c0bf15ccc9408a74f5ab7fcaba0"},+ "judge:static_object_v1:runs/run/artifacts/renders/r00/messages": {"bytes": 6699, "sha256": "7df542d34f969f456ab2fcd720b5ccf3a4547b1c57ed59a81df0a84a4d540b9a"},+ "judge:static_object_v1:runs/run/artifacts/renders/r00/sampling": {"bytes": 11368, "sha256": "d689cdebe9d63a438597fd51e16228f8d5fed5d5693c736223ce782f62a12242"},+ "judge:static_object_v1:runs/run/artifacts/renders/r00/system": {"bytes": 15181, "sha256": "3575c0106dc2f760c7b997e75932b9e37662f45394bba5516c5feebac72fe1bc"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/input": {"bytes": 10321, "sha256": "8d9c8fd2cf83b0c69df1888ac52b8021dec2b05af26ed4575ecf3d92d2d3c583"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/messages": {"bytes": 7124, "sha256": "a800f572433fa02006cc5a02c883359497949586963a0edeb799e047048d8f2c"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/sampling": {"bytes": 11368, "sha256": "d689cdebe9d63a438597fd51e16228f8d5fed5d5693c736223ce782f62a12242"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/system": {"bytes": 15181, "sha256": "3575c0106dc2f760c7b997e75932b9e37662f45394bba5516c5feebac72fe1bc"},+ "skills:runs/run/_cand/c0:baseline@r00/routed": {"bytes": 133, "sha256": "53e382eba5cd3e9e5438941f437cd2148cca27c331d46ccbb73fb8b1b092a9dc"},+ "skills:runs/run/_cand/c1:baseline@r00/routed": {"bytes": 133, "sha256": "53e382eba5cd3e9e5438941f437cd2148cca27c331d46ccbb73fb8b1b092a9dc"},+ "skills:runs/run:baseline@r00/routed": {"bytes": 133, "sha256": "53e382eba5cd3e9e5438941f437cd2148cca27c331d46ccbb73fb8b1b092a9dc"},+ "skills:runs/run:refine@r01/routed": {"bytes": 133, "sha256": "53e382eba5cd3e9e5438941f437cd2148cca27c331d46ccbb73fb8b1b092a9dc"}+ },+ "stage_keys": {+ "runs/run:plan": "6f3091aaf16f",+ "runs/run:skeleton": "65d9bf7a6805"+ }+ },+ "static_object.cadquery.agent.rebuild": {+ "payloads": {+ "chat:planner:planner-brief/messages": {"bytes": 170, "sha256": "c59acfe245bb7cf2ca7111a65960824587e06cd8914a4d7ca9c8eba234fe6393"},+ "chat:planner:planner-brief/sampling": {"bytes": 4774, "sha256": "ac0bb868a0ed6551f5374840bf146b6e0b4fbb014f10a856fd306ec44357226a"},+ "chat:planner:planner-brief/system": {"bytes": 3133, "sha256": "a66f0fe3b4610d21d0969a732e8d15f208a1147fe6a0ec6ce97606e400142580"},+ "chat:planner:planner/messages": {"bytes": 1354, "sha256": "8681af8220fc76fb89bbaacf34c658644272af66ace3045ccef202e75e29482f"},+ "chat:planner:planner/sampling": {"bytes": 6272, "sha256": "04dbfbbd42d8b93a12571a1908beacc7eb471e6f2c0fc077371aa86e2a99fb40"},+ "chat:planner:planner/system": {"bytes": 15857, "sha256": "faf1d558f09254b16c3f0680aa2117737c72dea402b3b7a0be721c46bdd169fe"},+ "context:runs/run/files": {"bytes": 36504, "sha256": "578e4dc3d8c54ccbd30277ca69f1d07ec772db970fcc323f10489d6638b57f60"},+ "job:baseline@r00/prompt": {"bytes": 15607, "sha256": "3254852ee1e82f9e70218f15256197a1254a53613724cf29db9f3d6bdd5959e4"},+ "job:baseline@r00/scope": {"bytes": 354, "sha256": "2b65c930399cda88341114c6d8289228fedde80a1d17568900e1fe5a055915bd"},+ "job:baseline@r00/system": {"bytes": 2205, "sha256": "2ca6cc8997115b5940dcef874355b65c82f25ee8000b964fe0ad96dce25ac0e8"},+ "job:r00_baseline_repair1@r00/prompt": {"bytes": 4263, "sha256": "29f3ed4e23f478da88b532f0466a296ebf3caa10b37a9165b0923b8a43c18561"},+ "job:r00_baseline_repair1@r00/scope": {"bytes": 364, "sha256": "85e6f91d3c4a250a9e87e59d65b4efd696c810c90e29c3f79023bddf6b5a3c5d"},+ "job:r00_baseline_repair1@r00/system": {"bytes": 8927, "sha256": "68a64536d16663f907c98fbaa27f8187acecc86c831acae03b02e43e02350b6d"},+ "job:r00_baseline_repair2@r00/prompt": {"bytes": 4568, "sha256": "e99cc8438646c5bf900d1e7c52ec48e168915c98278aa24ca9cdfb642a5d812d"},+ "job:r00_baseline_repair2@r00/scope": {"bytes": 366, "sha256": "8376d6d1c2ec92f74c51f366e6b62aeb24d6874dc5dc3374a29947d6bbe70fc1"},+ "job:r00_baseline_repair2@r00/system": {"bytes": 8927, "sha256": "68a64536d16663f907c98fbaa27f8187acecc86c831acae03b02e43e02350b6d"},+ "job:rebuild@r01/prompt": {"bytes": 15825, "sha256": "cd88de36ee94c5e6b9593082a3aff513b93a615177d7a83528570e86fd1c414c"},+ "job:rebuild@r01/scope": {"bytes": 354, "sha256": "a7a5b56da832d44db1fb9d7ce73874b02ac672544ad8cc045c987ba82d7e8872"},+ "job:rebuild@r01/system": {"bytes": 2205, "sha256": "2ca6cc8997115b5940dcef874355b65c82f25ee8000b964fe0ad96dce25ac0e8"},+ "job:refine@r02/prompt": {"bytes": 7510, "sha256": "da99d8d8621d2de04fbd11e07303ba2ffe71b771338f95d5b2bf705e2002c682"},+ "job:refine@r02/scope": {"bytes": 350, "sha256": "4e7e7adc88c67e32725d4fbf7d2f95b24d0166d57881f69cf543ab1c6936ea35"},+ "job:refine@r02/system": {"bytes": 2205, "sha256": "2ca6cc8997115b5940dcef874355b65c82f25ee8000b964fe0ad96dce25ac0e8"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/input": {"bytes": 9513, "sha256": "397a05e8b108eb96ce4df58b830bb9bfabf0d38468b77243008f0c43d12cd594"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/messages": {"bytes": 6808, "sha256": "afe220b9286ff63c1e78b62cf853ead93c525947a873c6eaea80d9094a9d483e"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/sampling": {"bytes": 11368, "sha256": "d689cdebe9d63a438597fd51e16228f8d5fed5d5693c736223ce782f62a12242"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/system": {"bytes": 15181, "sha256": "3575c0106dc2f760c7b997e75932b9e37662f45394bba5516c5feebac72fe1bc"},+ "judge:static_object_v1:runs/run/artifacts/renders/r02/input": {"bytes": 10722, "sha256": "7b7dcb7f4afcb9e67f86062daa7ab7dd547a9fb54fae165c8a032c84c40cebaf"},+ "judge:static_object_v1:runs/run/artifacts/renders/r02/messages": {"bytes": 7233, "sha256": "d6a82300f22e09f4cc9f7d5a09ec89e5c6e9b300eab6b8899fc61648ac406c21"},+ "judge:static_object_v1:runs/run/artifacts/renders/r02/sampling": {"bytes": 11368, "sha256": "d689cdebe9d63a438597fd51e16228f8d5fed5d5693c736223ce782f62a12242"},+ "judge:static_object_v1:runs/run/artifacts/renders/r02/system": {"bytes": 15181, "sha256": "3575c0106dc2f760c7b997e75932b9e37662f45394bba5516c5feebac72fe1bc"},+ "skills:runs/run:baseline@r00/routed": {"bytes": 134, "sha256": "45a5c9d0f2d8993a70bbe476733dab64bd31eb2555d5850e2936724b07404966"},+ "skills:runs/run:refine@r01/routed": {"bytes": 134, "sha256": "45a5c9d0f2d8993a70bbe476733dab64bd31eb2555d5850e2936724b07404966"},+ "skills:runs/run:refine@r02/routed": {"bytes": 134, "sha256": "f11f63910f028add64068034f65c2875924ea57ea94bc407859b8b1e1050c6b6"}+ },+ "stage_keys": {+ "runs/run:plan": "5f878927a85a",+ "runs/run:skeleton": "1a2d68e2a2e3"+ }+ },+ "static_object.threejs.agent.fresh": {+ "payloads": {+ "chat:planner:planner-brief/messages": {"bytes": 170, "sha256": "c59acfe245bb7cf2ca7111a65960824587e06cd8914a4d7ca9c8eba234fe6393"},+ "chat:planner:planner-brief/sampling": {"bytes": 4774, "sha256": "ac0bb868a0ed6551f5374840bf146b6e0b4fbb014f10a856fd306ec44357226a"},+ "chat:planner:planner-brief/system": {"bytes": 3133, "sha256": "a66f0fe3b4610d21d0969a732e8d15f208a1147fe6a0ec6ce97606e400142580"},+ "chat:planner:planner/messages": {"bytes": 1354, "sha256": "5b1a589e27562a3668649aed4be4857a34804a2acdc140eb8fb3630d970f71a6"},+ "chat:planner:planner/sampling": {"bytes": 6272, "sha256": "04dbfbbd42d8b93a12571a1908beacc7eb471e6f2c0fc077371aa86e2a99fb40"},+ "chat:planner:planner/system": {"bytes": 18298, "sha256": "0483e07168e1b18aeb18cda38887e719a4c3993161c600c61da469ff2fccd4f4"},+ "context:runs/run/files": {"bytes": 41466, "sha256": "307c5e3ede2e759f1084c24ec5a52f6e31695d4302278577b98a434db5686e4a"},+ "job:baseline@r00/prompt": {"bytes": 18120, "sha256": "0a20305dcfbe7b51bf9078f42be61d15c79316b65c4249651c7275e24351471e"},+ "job:baseline@r00/scope": {"bytes": 432, "sha256": "b7970aa82707a446f41764e551d45617767914f38d6861453d2d61991d48ed05"},+ "job:baseline@r00/system": {"bytes": 3208, "sha256": "e24e99f321231e5587cae7f4fbbbcc50fbd254768f4f4c860c4dfa8f83804810"},+ "job:refine@r01/prompt": {"bytes": 7470, "sha256": "e4594e140c01ba0341cc17ad7606f0a7815963f324228caa29612390f3ff26b6"},+ "job:refine@r01/scope": {"bytes": 428, "sha256": "186e31cec33c5144bbc9713eb76374ef7608534682433c9a9288191efc417ec4"},+ "job:refine@r01/system": {"bytes": 3208, "sha256": "e24e99f321231e5587cae7f4fbbbcc50fbd254768f4f4c860c4dfa8f83804810"},+ "job:refine@r02/prompt": {"bytes": 7469, "sha256": "6670e07ec1dfbd701d3777c92d02e55a317bdd71c2e52e615973192828466a27"},+ "job:refine@r02/scope": {"bytes": 428, "sha256": "57e2f2633c63ce908a2842199385fe002439dcc7d6f68ffac0261d5be22cb8e1"},+ "job:refine@r02/system": {"bytes": 3208, "sha256": "e24e99f321231e5587cae7f4fbbbcc50fbd254768f4f4c860c4dfa8f83804810"},+ "judge:static_object_v1:runs/run/artifacts/renders/r00/input": {"bytes": 9307, "sha256": "1bab6f0b46195a81bcb86db47342c74c5a55d095435d24e05122a952253c3057"},+ "judge:static_object_v1:runs/run/artifacts/renders/r00/messages": {"bytes": 6756, "sha256": "447c252713a4d26c70c0b368c30217605f33543c3a329b6c32bee7099bdb1860"},+ "judge:static_object_v1:runs/run/artifacts/renders/r00/sampling": {"bytes": 11368, "sha256": "d689cdebe9d63a438597fd51e16228f8d5fed5d5693c736223ce782f62a12242"},+ "judge:static_object_v1:runs/run/artifacts/renders/r00/system": {"bytes": 15181, "sha256": "3575c0106dc2f760c7b997e75932b9e37662f45394bba5516c5feebac72fe1bc"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/input": {"bytes": 10520, "sha256": "bada44f0350738b015ac2a5dfea12eb03fc89080f48ec848c793e87964d3fea8"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/messages": {"bytes": 7181, "sha256": "0ee41f64bf25c8490c05f3478f11afde83f2d8fc7f4753553d7497f1ef83543a"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/sampling": {"bytes": 11368, "sha256": "d689cdebe9d63a438597fd51e16228f8d5fed5d5693c736223ce782f62a12242"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/system": {"bytes": 15181, "sha256": "3575c0106dc2f760c7b997e75932b9e37662f45394bba5516c5feebac72fe1bc"},+ "judge:static_object_v1:runs/run/artifacts/renders/r02/input": {"bytes": 10516, "sha256": "e52a0b8b6bf1f9df4e18cd6289b2d80e98d4ae669cc0273e2e34f0ac7653a43b"},+ "judge:static_object_v1:runs/run/artifacts/renders/r02/messages": {"bytes": 7181, "sha256": "61b52dd59cc941e842e0e789faf595cd9ed24187eba10e7cc399e1ca792eb099"},+ "judge:static_object_v1:runs/run/artifacts/renders/r02/sampling": {"bytes": 11368, "sha256": "d689cdebe9d63a438597fd51e16228f8d5fed5d5693c736223ce782f62a12242"},+ "judge:static_object_v1:runs/run/artifacts/renders/r02/system": {"bytes": 15181, "sha256": "3575c0106dc2f760c7b997e75932b9e37662f45394bba5516c5feebac72fe1bc"},+ "skills:runs/run:baseline@r00/routed": {"bytes": 133, "sha256": "537d8d98029fd6345c9d4a73eaf3615c7924c18a405b3ab633283694e23b1804"},+ "skills:runs/run:refine@r01/routed": {"bytes": 133, "sha256": "518f7b7ba0343e508a61d4b00f2c7628ee771ef0cd1766d631194f988152e858"},+ "skills:runs/run:refine@r02/routed": {"bytes": 133, "sha256": "518f7b7ba0343e508a61d4b00f2c7628ee771ef0cd1766d631194f988152e858"}+ },+ "stage_keys": {+ "runs/run:plan": "31ab234e1554",+ "runs/run:skeleton": "58657cfb09d9"+ }+ },+ "static_object.threejs.agent.many_parts": {+ "payloads": {+ "chat:planner:planner-brief/messages": {"bytes": 170, "sha256": "c59acfe245bb7cf2ca7111a65960824587e06cd8914a4d7ca9c8eba234fe6393"},+ "chat:planner:planner-brief/sampling": {"bytes": 4774, "sha256": "ac0bb868a0ed6551f5374840bf146b6e0b4fbb014f10a856fd306ec44357226a"},+ "chat:planner:planner-brief/system": {"bytes": 3133, "sha256": "a66f0fe3b4610d21d0969a732e8d15f208a1147fe6a0ec6ce97606e400142580"},+ "chat:planner:planner/messages": {"bytes": 1354, "sha256": "5b1a589e27562a3668649aed4be4857a34804a2acdc140eb8fb3630d970f71a6"},+ "chat:planner:planner/sampling": {"bytes": 6272, "sha256": "04dbfbbd42d8b93a12571a1908beacc7eb471e6f2c0fc077371aa86e2a99fb40"},+ "chat:planner:planner/system": {"bytes": 18298, "sha256": "0483e07168e1b18aeb18cda38887e719a4c3993161c600c61da469ff2fccd4f4"},+ "context:runs/run/files": {"bytes": 41466, "sha256": "307c5e3ede2e759f1084c24ec5a52f6e31695d4302278577b98a434db5686e4a"},+ "job:baseline@r00/prompt": {"bytes": 18089, "sha256": "04f9c0f40a2f4d04b973d0c75d76e577f8c406fbaf2f02495d8ee39d2a1dddb2"},+ "job:baseline@r00/scope": {"bytes": 648, "sha256": "eed11065615f36b3d1b869300d16518bd4ec6e258630c204fdeff14e676cc2d8"},+ "job:baseline@r00/system": {"bytes": 3208, "sha256": "e24e99f321231e5587cae7f4fbbbcc50fbd254768f4f4c860c4dfa8f83804810"},+ "job:refine@r01/prompt": {"bytes": 9156, "sha256": "f8e4ad5d4b7d1ccdc149f77b7e6302e6d364dc62ccb9e98a45fb8c190f3c7f7d"},+ "job:refine@r01/scope": {"bytes": 644, "sha256": "f5e0c8fc1e3c0527734f358ad11929cedc505d872e61bbbfa4926d2cf5f4a1d0"},+ "job:refine@r01/system": {"bytes": 3208, "sha256": "e24e99f321231e5587cae7f4fbbbcc50fbd254768f4f4c860c4dfa8f83804810"},+ "judge:static_object_v1:runs/run/artifacts/renders/r00/input": {"bytes": 11212, "sha256": "054fc9378fe72d6263cc8be55114c6ffcd74e380ac652375c8873c708e632c6b"},+ "judge:static_object_v1:runs/run/artifacts/renders/r00/messages": {"bytes": 7002, "sha256": "90d9f0c3e869c20608b23834b3a93df8242b1dd3324fdfda3b91de9542337eb0"},+ "judge:static_object_v1:runs/run/artifacts/renders/r00/sampling": {"bytes": 11134, "sha256": "f825a8da4e119120216c23d2d3433cbf49ab7107bb97d58f7cd8359d7bd8eb45"},+ "judge:static_object_v1:runs/run/artifacts/renders/r00/system": {"bytes": 15181, "sha256": "3575c0106dc2f760c7b997e75932b9e37662f45394bba5516c5feebac72fe1bc"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/input": {"bytes": 12397, "sha256": "942ff240dcba105727d8ff15dbc2e0b0535ae4958ec8731ea993d70d79b49bdc"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/messages": {"bytes": 7429, "sha256": "70fca81684fcce477eadc3e0d5c329b3dcc31dcc527958abf29e484a0d555a7c"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/sampling": {"bytes": 11134, "sha256": "f825a8da4e119120216c23d2d3433cbf49ab7107bb97d58f7cd8359d7bd8eb45"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/system": {"bytes": 15181, "sha256": "3575c0106dc2f760c7b997e75932b9e37662f45394bba5516c5feebac72fe1bc"},+ "skills:runs/run:baseline@r00/routed": {"bytes": 104, "sha256": "754997d8db8e89f9b7b0379fceda29998c2e42d362fcaec169d7bd48fc097d3b"},+ "skills:runs/run:refine@r01/routed": {"bytes": 104, "sha256": "754997d8db8e89f9b7b0379fceda29998c2e42d362fcaec169d7bd48fc097d3b"}+ },+ "stage_keys": {+ "runs/run:plan": "31ab234e1554",+ "runs/run:skeleton": "fb24414f9aea"+ }+ },+ "static_object.threejs.agent.resume": {+ "payloads": {+ "chat:planner:planner-brief/messages": {"bytes": 170, "sha256": "c59acfe245bb7cf2ca7111a65960824587e06cd8914a4d7ca9c8eba234fe6393"},+ "chat:planner:planner-brief/sampling": {"bytes": 4774, "sha256": "ac0bb868a0ed6551f5374840bf146b6e0b4fbb014f10a856fd306ec44357226a"},+ "chat:planner:planner-brief/system": {"bytes": 3133, "sha256": "a66f0fe3b4610d21d0969a732e8d15f208a1147fe6a0ec6ce97606e400142580"},+ "chat:planner:planner/messages": {"bytes": 1354, "sha256": "5b1a589e27562a3668649aed4be4857a34804a2acdc140eb8fb3630d970f71a6"},+ "chat:planner:planner/sampling": {"bytes": 6272, "sha256": "04dbfbbd42d8b93a12571a1908beacc7eb471e6f2c0fc077371aa86e2a99fb40"},+ "chat:planner:planner/system": {"bytes": 18298, "sha256": "0483e07168e1b18aeb18cda38887e719a4c3993161c600c61da469ff2fccd4f4"},+ "context:runs/run/files": {"bytes": 41466, "sha256": "307c5e3ede2e759f1084c24ec5a52f6e31695d4302278577b98a434db5686e4a"},+ "job:baseline@r00/prompt": {"bytes": 18120, "sha256": "0a20305dcfbe7b51bf9078f42be61d15c79316b65c4249651c7275e24351471e"},+ "job:baseline@r00/scope": {"bytes": 432, "sha256": "b7970aa82707a446f41764e551d45617767914f38d6861453d2d61991d48ed05"},+ "job:baseline@r00/system": {"bytes": 3208, "sha256": "e24e99f321231e5587cae7f4fbbbcc50fbd254768f4f4c860c4dfa8f83804810"},+ "job:refine@r01/prompt": {"bytes": 7307, "sha256": "51c6293407b6d9352ac4e6c529907570d21b681e740f2f548c359f2d061c499c"},+ "job:refine@r01/scope": {"bytes": 428, "sha256": "186e31cec33c5144bbc9713eb76374ef7608534682433c9a9288191efc417ec4"},+ "job:refine@r01/system": {"bytes": 3208, "sha256": "e24e99f321231e5587cae7f4fbbbcc50fbd254768f4f4c860c4dfa8f83804810"},+ "judge:static_object_v1:runs/run/artifacts/renders/r00/input": {"bytes": 9108, "sha256": "de6324c2e5fffad8f4ae1e87cb2e54e6c347b1f9cc8d0f07479274fd6acb4e31"},+ "judge:static_object_v1:runs/run/artifacts/renders/r00/messages": {"bytes": 6699, "sha256": "6e3964ce3478de892b3c5dde9eb3154e9a54c2a669315a8e6f4b808c15dd930c"},+ "judge:static_object_v1:runs/run/artifacts/renders/r00/sampling": {"bytes": 11368, "sha256": "d689cdebe9d63a438597fd51e16228f8d5fed5d5693c736223ce782f62a12242"},+ "judge:static_object_v1:runs/run/artifacts/renders/r00/system": {"bytes": 15181, "sha256": "3575c0106dc2f760c7b997e75932b9e37662f45394bba5516c5feebac72fe1bc"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/input": {"bytes": 10321, "sha256": "0bdbcf6b262451c2f914db0f1501ffa30d50795fc7f8c6dbea0fdaf8f1ed2d14"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/messages": {"bytes": 7124, "sha256": "0e3a5d3ed25799eec213d2d7fd92ae5009e4d88d5a818eeaf0aef3de8d47b932"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/sampling": {"bytes": 11368, "sha256": "d689cdebe9d63a438597fd51e16228f8d5fed5d5693c736223ce782f62a12242"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/system": {"bytes": 15181, "sha256": "3575c0106dc2f760c7b997e75932b9e37662f45394bba5516c5feebac72fe1bc"},+ "skills:runs/run:baseline@r00/routed": {"bytes": 133, "sha256": "537d8d98029fd6345c9d4a73eaf3615c7924c18a405b3ab633283694e23b1804"},+ "skills:runs/run:refine@r01/routed": {"bytes": 133, "sha256": "537d8d98029fd6345c9d4a73eaf3615c7924c18a405b3ab633283694e23b1804"}+ },+ "stage_keys": {+ "runs/run:plan": "31ab234e1554",+ "runs/run:skeleton": "58657cfb09d9"+ }+ },+ "static_object.threejs.single_shot.repair": {+ "payloads": {+ "chat:model:baseline:r00/messages": {"bytes": 24978, "sha256": "95c6c4e648e5751c926da6b005ca4c5537c0d9aef80c273362073daf1f021c78"},+ "chat:model:baseline:r00/sampling": {"bytes": 92, "sha256": "08e72af1b4fb249378c5a151e019ded70a1014eafa4d50f70927bb225f695678"},+ "chat:model:baseline:r00/system": {"bytes": 5516, "sha256": "4f39c82bc5c139cb7564823120ed18ae1a9ed94b84bdf99563292d0860394e3f"},+ "chat:model:r00_baseline_repair1:r00/messages": {"bytes": 2019, "sha256": "d7fd178860643c0fb77bd83a729b0229baece14da27ce07517f81a2e7a0c14db"},+ "chat:model:r00_baseline_repair1:r00/sampling": {"bytes": 92, "sha256": "1ce73c4d8b7c06d8e295413591db369fae9570968bd051ceb1eb70d0402a26ca"},+ "chat:model:r00_baseline_repair1:r00/system": {"bytes": 14882, "sha256": "cf2354ea9acba5921cbdb586a5c28662910a629a2135239ec8ea1dad215e9372"},+ "chat:model:refine:r01/messages": {"bytes": 13654, "sha256": "81fe85d485acfc5ad1e84dc16abbc49e1b20144a12ba98131a796707d50753e2"},+ "chat:model:refine:r01/sampling": {"bytes": 92, "sha256": "2a36044e5c117fc288123a5937c6e3cb5845f040b4de69f9c2440f623956c381"},+ "chat:model:refine:r01/system": {"bytes": 5516, "sha256": "4f39c82bc5c139cb7564823120ed18ae1a9ed94b84bdf99563292d0860394e3f"},+ "chat:planner:planner-brief/messages": {"bytes": 170, "sha256": "c59acfe245bb7cf2ca7111a65960824587e06cd8914a4d7ca9c8eba234fe6393"},+ "chat:planner:planner-brief/sampling": {"bytes": 4774, "sha256": "ac0bb868a0ed6551f5374840bf146b6e0b4fbb014f10a856fd306ec44357226a"},+ "chat:planner:planner-brief/system": {"bytes": 3133, "sha256": "a66f0fe3b4610d21d0969a732e8d15f208a1147fe6a0ec6ce97606e400142580"},+ "chat:planner:planner/messages": {"bytes": 1354, "sha256": "5b1a589e27562a3668649aed4be4857a34804a2acdc140eb8fb3630d970f71a6"},+ "chat:planner:planner/sampling": {"bytes": 6272, "sha256": "04dbfbbd42d8b93a12571a1908beacc7eb471e6f2c0fc077371aa86e2a99fb40"},+ "chat:planner:planner/system": {"bytes": 18298, "sha256": "0483e07168e1b18aeb18cda38887e719a4c3993161c600c61da469ff2fccd4f4"},+ "judge:static_object_v1:runs/run/artifacts/renders/r00/input": {"bytes": 9125, "sha256": "cb85607f665756a289d7f4070a59cd5febf398ef289ec123c6060a3313d9c011"},+ "judge:static_object_v1:runs/run/artifacts/renders/r00/messages": {"bytes": 6699, "sha256": "6e3964ce3478de892b3c5dde9eb3154e9a54c2a669315a8e6f4b808c15dd930c"},+ "judge:static_object_v1:runs/run/artifacts/renders/r00/sampling": {"bytes": 11368, "sha256": "d689cdebe9d63a438597fd51e16228f8d5fed5d5693c736223ce782f62a12242"},+ "judge:static_object_v1:runs/run/artifacts/renders/r00/system": {"bytes": 15181, "sha256": "3575c0106dc2f760c7b997e75932b9e37662f45394bba5516c5feebac72fe1bc"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/input": {"bytes": 10338, "sha256": "a5ee63d3b5d902e5e111abce6463ff9a3fe1a1af21a3c6a9d284b76137b64b49"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/messages": {"bytes": 7124, "sha256": "0e3a5d3ed25799eec213d2d7fd92ae5009e4d88d5a818eeaf0aef3de8d47b932"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/sampling": {"bytes": 11368, "sha256": "d689cdebe9d63a438597fd51e16228f8d5fed5d5693c736223ce782f62a12242"},+ "judge:static_object_v1:runs/run/artifacts/renders/r01/system": {"bytes": 15181, "sha256": "3575c0106dc2f760c7b997e75932b9e37662f45394bba5516c5feebac72fe1bc"},+ "skills:runs/run:baseline@r00/routed": {"bytes": 148, "sha256": "67ba73ea33f42a757e533e24b318438e321943eeb47470a930fbcfda97e72e93"},+ "skills:runs/run:refine@r01/routed": {"bytes": 148, "sha256": "67ba73ea33f42a757e533e24b318438e321943eeb47470a930fbcfda97e72e93"}+ },+ "stage_keys": {+ "runs/run:plan": "31ab234e1554",+ "runs/run:skeleton": "58657cfb09d9"+ }+ }+ }+}diff --git a/harness/tests/prompts/manifest.py b/harness/tests/prompts/manifest.pyindex 2c9f9db3..ca504d45 100644--- a/harness/tests/prompts/manifest.py+++ b/harness/tests/prompts/manifest.py@@ -450,6 +450,10 @@ SCENARIOS: dict[str, tuple[Track, Language, dict[str, Any], Callable[[Rig], None_two_runs(1, 2)),"scene.scene_blender.single_shot.fresh": (SC, Language.SCENE_BLENDER, {"plan": small_scene(Language.SCENE_BLENDER), "broken_assets": frozenset({"Bollard"})},lambda r: r.run(rounds=1, single_shot=True)),+ # raw mode (D113): the argon_raw overlay and its `scene_lib = false` knob — every bpy brief, planner and+ # skill bundle a session reads without one word of the harness library+ "scene.scene_blender.agent.variant_argon_raw": (SC, Language.SCENE_BLENDER, {"plan": small_scene(Language.SCENE_BLENDER)},+ _switched("C3D_VARIANT", "argon_raw", 1)),"graphics.glsl_shader.agent.fresh": (G, Language.GLSL_SHADER, {}, _two_runs(1, 2)),"graphics.glsl_shader.agent.best_of_2": (G, Language.GLSL_SHADER, {}, lambda r: r.run(rounds=0, candidates=2)),"graphics.glsl_shader.agent.rebuild": (G, Language.GLSL_SHADER, {"fail": REBUILD}, lambda r: r.run(rounds=1)),diff --git a/harness/tests/prompts/test_snippets_run.py b/harness/tests/prompts/test_snippets_run.pyindex 3506d565..23218fc8 100644--- a/harness/tests/prompts/test_snippets_run.py+++ b/harness/tests/prompts/test_snippets_run.py@@ -190,12 +190,15 @@ console.log('ENV_OK');# --------------------------------------------------------------------- scene_blender-def _bpy_workspace(tmp_path):+def _bpy_workspace(tmp_path, *, lib: bool = True):"""The scratch workspace the scene_blender snippets run in: the skeleton of the bpy worked example- (its two module assets build first → ``ctx.assets``), through the real runtime."""+ (its two module assets build first → ``ctx.assets``), through the real runtime — in raw mode+ (D113, ``lib`` False) a runtime whose settings ship no library."""+ from codeverse3d.config import Settingsfrom codeverse3d.contracts.common import Language, Trackfrom codeverse3d.contracts.plan import ScenePlanfrom codeverse3d.languages import get_runtime+ from codeverse3d.languages.scene_blender import SceneBlenderRuntimefrom codeverse3d.tracks.planner import plan_examplefrom codeverse3d.workspace import Workspace@@ -203,7 +206,7 @@ def _bpy_workspace(tmp_path):pytest.skip("no Blender binary configured")plan = ScenePlan.model_validate(plan_example(Track.SCENE, Language.SCENE_BLENDER))ws = Workspace(tmp_path / "ws")- rt = get_runtime(Language.SCENE_BLENDER)+ rt = get_runtime(Language.SCENE_BLENDER) if lib else SceneBlenderRuntime(settings=Settings(scene_lib=False))rt.skeleton(ws, plan)return ws, rt, plan@@ -258,6 +261,38 @@ def test_scene_blender_contract_examples_build_through_the_runtime(tmp_path) ->assert all(rows[f"Bollard_{i}"]["supported"] for i in range(6)), {k: v for k, v in rows.items() if k.startswith("Bollard")}+def test_the_argon_raw_contract_examples_build_through_the_runtime_in_raw_mode(tmp_path) -> None:+ """The ``argon_raw`` overlay's contract (D113) keeps the same two labelled files rewritten in raw bpy+ / bmesh: in a raw workspace (no ``src/lib``) they lint clean under the raw lint, assemble, build with+ the probe passing (a world, a lamp, a ground, an atmosphere) and seat what they place — the same+ checks as the library-mode examples above."""+ from codeverse3d.contracts.artifacts import Severity+ from tests.scene_runtime.conftest import browser_available++ rel = "variants/argon_raw/scene_blender/contract.md"+ assert len(blocks(rel, "python")) == len(labelled_files(rel, tag="python"))+ if not browser_available():+ pytest.skip("puppeteer/chrome required for the census probe")+ ws, rt, plan = _bpy_workspace(tmp_path, lib=False)+ assert not (ws.src / "lib").exists()+ files = labelled_files(rel, tag="python")+ assert set(files) == {"src/env.py", "src/zones/quay.py"}+ for path, body in files.items():+ assert "lib." not in body and "from lib" not in body, path+ (ws.root / path).write_text(body)+ rep = rt.lint(ws)+ assert not [f for f in rep.findings if f.severity is not Severity.INFO], [(f.target, f.message) for f in rep.findings]+ asm = rt.assemble(ws, plan)+ assert "quay" in asm.zones_included and not asm.zones_failed and asm.env_ok, asm+ res = rt.build(ws)+ assert res.ok, res.stdout_tail+ rows = {r["name"]: r for r in res.census["placement"]["assets"]}+ assert rows["QuayDeck"]["supported"] and not rows["QuayDeck"]["floating"]+ assert all(rows[f"Bollard_{i}"]["supported"] for i in range(6)), {k: v for k, v in rows.items() if k.startswith("Bollard")}++# --------------------------------------------------------------------- glsl_shaderdef test_glsl_shader_contract_example_builds_and_moves(tmp_ws) -> None:"""The contract's ONE complete ``mainImage`` (the block that defines it) is ``src/shader.frag``diff --git a/harness/tests/scene_blender/test_raw_mode.py b/harness/tests/scene_blender/test_raw_mode.pynew file mode 100644index 00000000..7daab705--- /dev/null+++ b/harness/tests/scene_blender/test_raw_mode.py@@ -0,0 +1,344 @@+"""scene_blender raw mode (D113, ``Settings.scene_lib`` off, the ``argon_raw`` variant): no harness bpy+library ships, so every mesh, material, light, world and motion of the scene is the model's.++Pinned here: the raw skeleton (no ``src/lib``, no stub that imports or names it, the plan-less+example refused), the lint (a ``lib`` import is an ERROR in raw mode only), the runtime reading the+knob at call time, the ``argon_raw`` overlay (it resolves, its knob reaches the settings a run uses,+no file of it names the library, every overlaid stage template renders with the scene track's+context) and — in real Blender — the raw placeholder env and an empty zone building through the+wrapper. The default (library) mode is pinned byte-identical by the prompt manifest and the+existing scene_blender tests."""++from __future__ import annotations++import ast+import re+from pathlib import Path++import pytest++from codeverse3d.config import Settings, get_settings+from codeverse3d.contracts.common import Language, Track+from codeverse3d.contracts.plan import ScenePlan+from codeverse3d.languages.scene_blender import (+ SceneBlenderRuntime,+ lint,+ lint_scene_source,+ write_skeleton,+)+from codeverse3d.prompts import render+from codeverse3d.prompts.variants import (+ VARIANTS_DIR,+ activate,+ knobs_applied,+ run_knob,+ variant_info,+)+from codeverse3d.skills import variant_dir+from codeverse3d.tracks.planner import build_system_prompt, plan_example+from codeverse3d.workspace import Workspace++BPY = Language.SCENE_BLENDER+RAW = "argon_raw"+#: what names the harness library in text a model reads: the workspace path, a dotted helper call+#: (``lib.place.seat``), an import of the package, a module file (``lib/vegetation.py``)+LIB_MENTION = re.compile(r"src/lib|\blib\.[a-z_]+|\bfrom lib\b|\bimport lib\b|\blib/[a-z_]+\.py")+#: the stage templates the overlay shadows (the planner's included)+OVERLAID_TEMPLATES = ("tracks/scene_env_bpy.j2", "tracks/scene_zone_bpy.j2", "tracks/scene_refine_bpy.j2",+ "tracks/scene_asset_bpy.j2", "tracks/plan_scene_bpy.j2")+++def _plan() -> ScenePlan:+ return ScenePlan.model_validate(plan_example(Track.SCENE, BPY))+++def _lib_imports(source: str) -> list[str]:+ tree = ast.parse(source)+ out = [a.name for n in ast.walk(tree) if isinstance(n, ast.Import) for a in n.names if a.name.split(".")[0] == "lib"]+ return out + [str(n.module) for n in ast.walk(tree) if isinstance(n, ast.ImportFrom) and (n.module or "").split(".")[0] == "lib"]+++# --------------------------------------------------------------------------- the skeleton+def test_the_raw_skeleton_ships_no_library_and_no_stub_imports_or_names_it(tmp_ws) -> None:+ plan = _plan()+ written = {p.relative_to(tmp_ws.root).as_posix() for p in write_skeleton(tmp_ws, plan, lib=False)}+ assert not (tmp_ws.src / "lib").exists() and not any(rel.startswith("src/lib/") for rel in written), sorted(written)+ assert {"src/env.py", "src/scene.py", "src/zones/quay.py", "src/assets/bollard.py"} <= written+ for p in sorted(tmp_ws.src.rglob("*.py")):+ text = p.read_text()+ assert not _lib_imports(text), (p.name, _lib_imports(text))+ assert not LIB_MENTION.search(text), (p.name, LIB_MENTION.search(text))+ assert "toolbox" not in text, p.name+ env = (tmp_ws.src / "env.py").read_text()+ assert "def height_at(x, y):" in env and "def build_env(ctx):" in env and '"Ground"' in env+ assert "worlds.new" not in env and "lights.new" not in env, "the placeholder builds ONE plate and nothing else"+ rep = lint(tmp_ws, lib=False)+ assert rep.passed and not [f for f in rep.findings if f.severity.value != "info"], [(f.target, f.message) for f in rep.findings]+ # the interior placeholder too: the plan's data, no library helper named+ inside = Workspace(tmp_ws.root.parent / "inside")+ write_skeleton(inside, plan.model_copy(update={"interior": True, "glazed": True}), lib=False)+ env = (inside.src / "env.py").read_text()+ assert "INTERIOR = True" in env and "GLAZED = True" in env and not LIB_MENTION.search(env) and "room_shell" not in env+++def test_the_plan_less_example_is_refused_in_raw_mode(tmp_ws) -> None:+ """The example scene is built on the library: a raw run starts from a plan's stubs or not at all."""+ with pytest.raises(ValueError, match="raw mode"):+ write_skeleton(tmp_ws, None, lib=False)+ assert not tmp_ws.src.exists() or not any(tmp_ws.src.rglob("*.py"))+++def test_the_runtime_reads_the_knob_at_call_time(tmp_ws, monkeypatch) -> None:+ """The run's knob is the ACTIVE variant's (``run_knob``, per thread): a runtime built before or inside+ the run follows it, and the default comes back after."""+ monkeypatch.delenv("C3D_SCENE_LIB", raising=False)+ settings = Settings()+ rt = SceneBlenderRuntime(settings=settings)+ assert rt.ships_lib is True+ with activate(RAW), knobs_applied(settings, variant_info(RAW)) as applied:+ assert applied == {"scene_lib": False} and rt.ships_lib is False+ assert settings.scene_lib is True, "a per-run knob is never written onto the shared settings"+ rt.skeleton(tmp_ws, _plan())+ assert not (tmp_ws.src / "lib").exists() and rt.lib_interface(tmp_ws) == ""+ (tmp_ws.src / "zones" / "quay.py").write_text("from lib.materials import material\n\n\ndef build(ctx):\n return ctx.collection\n")+ assert not rt.lint(tmp_ws).passed+ assert rt.ships_lib is True and rt.lint(tmp_ws).passed, "library mode: the import is allowed again"+++# --------------------------------------------------------------------------- the lint+def test_a_lib_import_is_an_error_in_raw_mode_and_not_in_library_mode() -> None:+ source = "from lib.materials import material\nimport bpy\n\n\ndef build(ctx):\n return ctx.collection\n"+ raw = [f for f in lint_scene_source(source, target="src/zones/quay.py", role="zone", lib=False) if "lib" in f.message]+ assert len(raw) == 1 and raw[0].severity.value == "error" and raw[0].data["kind"] == "bad_import", raw+ assert "no harness library ships in raw mode" in raw[0].message and "src/env.py" in raw[0].fix_hint+ assert raw[0].target == "src/zones/quay.py:1"+ assert not [f for f in lint_scene_source(source, target="src/zones/quay.py", role="zone") if f.severity.value != "info"]+ for spelling in ("import lib.place\n", "from lib import place\n"):+ assert any(f.severity.value == "error" for f in lint_scene_source(spelling, target="src/env.py", role="helper", lib=False)), spelling+ # the shared code of a raw scene lives in env.py: importing it stays allowed+ assert not lint_scene_source("from env import linked\n", target="src/zones/quay.py", role="helper", lib=False)+++# --------------------------------------------------------------------------- the variant+def test_the_argon_raw_variant_resolves_and_its_knob_is_a_default_a_statement_beats(monkeypatch) -> None:+ info = variant_info(RAW)+ assert info.version == 1 and info.generators == ("agy:gemini-4-argon",) and info.knobs == {"scene_lib": False}+ monkeypatch.delenv("C3D_SCENE_LIB", raising=False)+ s = Settings()+ with activate(RAW), knobs_applied(s, info) as applied:+ assert applied == {"scene_lib": False} and run_knob("scene_lib", s) is False+ assert s.scene_lib is True and "scene_lib" not in s.model_fields_set and run_knob("scene_lib", s) is True+ with activate(""):+ assert run_knob("scene_lib", s) is True, "the base run: the field's default"+ monkeypatch.setenv("C3D_SCENE_LIB", "1") # the user's own statement wins over the knob+ s = Settings()+ with activate(RAW), knobs_applied(s, info) as applied:+ assert applied == {} and run_knob("scene_lib", s) is True+ monkeypatch.setenv("C3D_SCENE_LIB", "0") # ... and so does raw mode stated without the variant+ with activate(""):+ assert run_knob("scene_lib", Settings()) is False+++def test_parallel_runs_of_one_process_never_flip_each_others_mode(tmp_path, monkeypatch) -> None:+ """The bench runs ``--parallel N`` runs as threads of ONE process sharing the settings singleton. A+ raw run ending while a library run is still going (and the reverse) changes neither's answer, and+ the process is left at its default (the D113 review's race: the knob used to be written onto the+ singleton and put back, unreferenced-counted, by whichever run ended)."""+ import threading++ monkeypatch.delenv("C3D_SCENE_LIB", raising=False)+ get_settings.cache_clear()+ rt, seen = SceneBlenderRuntime(), {"raw": [], "lib": []}+ raw_in, lib_in, raw_out = threading.Event(), threading.Event(), threading.Event()++ def run(name: str, variant: str, start: threading.Event, wait: threading.Event, done: threading.Event | None) -> None:+ with activate(variant), knobs_applied(get_settings(), variant_info(variant) if variant else None):+ start.set()+ seen[name].append(rt.ships_lib)+ wait.wait(5)+ seen[name].append(rt.ships_lib)+ if done is not None:+ done.set()++ try:+ a = threading.Thread(target=run, args=("raw", RAW, raw_in, lib_in, raw_out)) # starts first, ends first+ b = threading.Thread(target=run, args=("lib", "", lib_in, raw_out, None))+ a.start()+ raw_in.wait(5)+ b.start()+ a.join(10)+ b.join(10)+ assert seen == {"raw": [False, False], "lib": [True, True]}, seen+ assert get_settings().scene_lib is True and rt.ships_lib is True+ finally:+ get_settings.cache_clear()+++def test_a_run_context_with_the_real_runtime_decides_once(tmp_ws, tmp_path, monkeypatch) -> None:+ """The run's real ``SceneBlenderRuntime`` is the one answer: the track's ``ships_lib`` asks it, the+ skeleton stage's cache key carries raw mode (a resume that changed the mode writes the skeleton+ again — and removes the other mode's library), and the lint rejects ``lib`` — under the variant, in+ a fan-out worker thread like the zone sessions."""+ from codeverse3d.proc import fan_out+ from codeverse3d.tracks import scene_assets as SA+ from codeverse3d.tracks.lifecycle import SKELETON+ from tests.orchestrator_tracks.conftest import make_spec++ monkeypatch.delenv("C3D_SCENE_LIB", raising=False)+ settings = Settings(runs_dir=tmp_path / "runs", cache_dir=tmp_path / "cache")+ spec, plan = make_spec(Track.SCENE, BPY), _plan()+ ctx = _ctx_bpy(tmp_ws, settings, spec, plan)+ lib_key = SKELETON.key(ctx)+ assert "scene_lib" not in lib_key and SA.ships_lib(ctx) is True+ ctx.runtime.skeleton(tmp_ws, plan)+ assert (tmp_ws.src / "lib").is_dir()+ with activate(RAW):+ def worker(_: int) -> tuple[bool, dict]:+ return SA.ships_lib(ctx), SKELETON.key(ctx)++ (ships, key), = fan_out([0], worker, max_workers=1, label="t", item_name=str)+ assert ships is False and key == {**lib_key, "scene_lib": False}+ ctx.runtime.skeleton(tmp_ws, plan)+ assert not (tmp_ws.src / "lib").exists(), "the library run's src/lib does not outlive a switch to raw"+ (tmp_ws.src / "zones" / "quay.py").write_text("from lib.materials import material\n\n\ndef build(ctx):\n return ctx.collection\n")+ assert not ctx.runtime.lint(tmp_ws).passed+ # a rig's stated Settings(scene_lib=False) with the real runtime: the runtime still answers for both+ raw_ctx = _ctx_bpy(tmp_ws, Settings(scene_lib=False), spec, plan)+ assert SA.ships_lib(raw_ctx) is raw_ctx.runtime.ships_lib+++def _ctx_bpy(ws: Workspace, settings: Settings, spec, plan):+ from dataclasses import replace++ from tests.orchestrator_tracks.test_prompts_assets import _ctx++ return replace(_ctx(ws, settings, spec, plan, agent_id="fake:x"), runtime=SceneBlenderRuntime())+++def test_a_variant_toml_knob_scene_lib_is_type_checked(tmp_path, monkeypatch) -> None:+ from codeverse3d.prompts import variants as V++ (tmp_path / "tv").mkdir()+ (tmp_path / "tv" / "variant.toml").write_text('[variant]\nname = "tv"\n[knobs]\nscene_lib = 0\n')+ monkeypatch.setattr(V, "VARIANTS_DIR", tmp_path)+ with pytest.raises(ValueError, match="scene_lib must be a bool"):+ variant_info("tv")+++def test_no_file_of_the_overlay_names_the_library() -> None:+ """Prompts AND skills: every file a model can read under ``argon_raw`` (the READMEs, which no model+ reads, are left out) — no ``src/lib``, no ``lib.<module>`` call, no import of it, no module file."""+ files = {p.relative_to(root).as_posix(): p for root in (VARIANTS_DIR / RAW, variant_dir(RAW)) for p in sorted(root.rglob("*"))+ if p.is_file() and p.name != "README.md" and "__pycache__" not in p.parts}+ names = set(files)+ assert {"scene_blender/contract.md", "tracks/scene_env_bpy.j2", "c3d-bpy-scene-placement/SKILL.md"} <= names, sorted(names)+ for rel, p in files.items():+ hits = sorted({m.group(0) for m in LIB_MENTION.finditer(p.read_text(encoding="utf-8"))})+ assert not hits, (rel, hits)+++def test_every_overlaid_template_renders_with_the_scene_track_context(tmp_ws, tmp_path) -> None:+ """The env / zone / refine / asset briefs through the scene track's own context builders, and the+ planner's system prompt — under the variant, so the overlay's copies render (a jinja block the+ track does not feed would raise under StrictUndefined or drop a section)."""+ from codeverse3d.tracks import scene_assets as SA+ from codeverse3d.tracks.scene import SceneTrack, plan_bbox_line, scene_templates+ from codeverse3d.tracks.zone_layout import layout_block+ from tests.orchestrator_tracks.conftest import make_spec+ from tests.orchestrator_tracks.fakes import small_scene+ from tests.orchestrator_tracks.test_prompts_assets import _ctx++ plan = small_scene(BPY)+ spec = make_spec(Track.SCENE, BPY)+ settings = Settings(runs_dir=tmp_path / "runs", cache_dir=tmp_path / "cache")+ ctx = _ctx(tmp_ws, settings, spec, plan, agent_id="fake:x")+ with activate(RAW), knobs_applied(ctx.settings, variant_info(RAW)):+ ctx.extra["asset_api"] = SA.asset_api_summary(plan, {}, language=BPY, lib=SA.ships_lib(ctx))+ st = SceneTrack(services=ctx.services)+ t = scene_templates(BPY)+ quay = plan.zones[0]+ prompts = {+ "env": render(t.env, **st._ctx(ctx, lib_interface="", env_check_error="", env_previous="")),+ "zone": render(t.zone, **st._ctx(ctx, zone_name=quay.name, zone_description=quay.description,+ zone_bbox=plan_bbox_line(quay.bbox, BPY), zone_contents=quay.contents,+ zone_file="src/zones/quay.py", neighbours=[], layout=layout_block(+ {"zone": "Quay", "placements": [{"asset": "Bollard", "count": 2,+ "cluster": [3.0, -4.0], "spread_m": 0.5}]},+ language=BPY))),+ "refine": render(t.refine, **st._ctx(ctx, round_index=1, tasks=["t"], targets=["Quay"], files=["src/env.py"],+ edit_only_these=False, judge_summary="j", current_files={})),+ "asset": SA._asset_prompt(ctx, plan.assets[0], "src/assets/bollard.py", language=BPY),+ "plan": build_system_prompt(spec, ScenePlan),+ }+ for name, text in prompts.items():+ assert text.strip(), name+ assert not LIB_MENTION.search(text), (name, LIB_MENTION.search(text))+ assert "No harness library ships" in prompts["env"] and "No harness library ships" in prompts["zone"]+ assert "write `src/env.py`" in prompts["env"] and "def build(ctx)" in prompts["zone"]+ assert "NO LIBRARY" in prompts["plan"] and "SHIPPED BPY LIBRARY" not in prompts["plan"]+ assert "instance_type = 'COLLECTION'" in prompts["zone"], "the asset API names the Empty, not a library call"+ assert "Reference rows" not in prompts["asset"], "no catalog row reaches a raw asset sheet"+ assert {Path(r).name for r in OVERLAID_TEMPLATES} <= {p.name for p in (VARIANTS_DIR / RAW / "tracks").glob("*.j2")}+++def test_a_run_under_argon_raw_sees_the_overlay_and_the_knob(tmp_path) -> None:+ """The whole run, offline (the manifest's scenario): the knob reaches the settings the scene track+ reads (the asset API's raw wording), the planner and every session read the overlay, and the+ routed bpy bundles are the overlay's lib-free copies."""+ from tests.prompts.manifest import run_scenario++ payloads = run_scenario("scene.scene_blender.agent.variant_argon_raw", tmp_path).payloads+ readable = {k: v for k, v in payloads.items() if not k.endswith("/scope")} # scope: the read-only list, not text+ for key, text in readable.items():+ assert not LIB_MENTION.search(text), (key, LIB_MENTION.search(text))+ assert "No harness library ships" in payloads["job:env@r00/prompt"]+ assert "instance_type = 'COLLECTION'" in payloads["job:zones_quay_water@r00/prompt"]+ assert "NO LIBRARY" in payloads["chat:planner:planner/system"]+ assert "c3d-bpy-scene-placement" in payloads["skills:runs/run:zone@r00/routed"]+ assert get_settings().scene_lib is True, "the knob does not outlive the run"+++# --------------------------------------------------------------------------- in Blender+def test_the_raw_placeholder_env_and_an_empty_zone_build_in_blender(tmp_path) -> None:+ """The raw stubs as written build in Blender 5.2 through the wrapper: no env error, every zone ok,+ the placeholder's Ground in the census, and no world, lamp or fog until the author writes them."""+ from codeverse3d.conventions import to_pascal++ if not get_settings().resolve_blender():+ pytest.skip("no Blender binary configured")+ ws = Workspace(tmp_path / "ws")+ rt = SceneBlenderRuntime(settings=Settings(scene_lib=False))+ plan = _plan()+ rt.skeleton(ws, plan)+ assert not (ws.src / "lib").exists()+ zones = {rt.zone_file(z.name).rsplit("/", 1)[-1][:-3] for z in plan.zones}+ run = rt.run_wrapper(ws, ws.artifacts, zones={n: to_pascal(n) for n in zones}, blend=False, timeout_s=600)+ errors = [(e.get("stage"), e.get("name"), e.get("error_file"), e.get("error_line"), e.get("error_message"))+ for e in run.report.get("errors") or []]+ assert run.result.ok and not errors, (run.result.error_type, run.result.error_message, errors)+ assert sorted(run.report["zones_ok"]) == sorted(zones)+ assert run.facts.get("fog") is None and not run.facts.get("lights"), {k: run.facts.get(k) for k in ("fog", "lights")}+ assert run.facts.get("unique_tris", 0) > 0, "the placeholder plate and the asset blockouts are geometry"+++def test_the_mcp_server_applies_the_runs_variant_knobs_in_its_own_process(tmp_ws, monkeypatch) -> None:+ """The session's MCP server is a separate process: it reads the run's variant off ``spec.json`` (the+ frozen ``options.variant``) and applies its knobs at start, so its ``build`` lint is the round's."""+ from codeverse3d.spatial.mcp_server import apply_run_knobs, build_context+ from tests.orchestrator_tracks.conftest import make_spec++ monkeypatch.delenv("C3D_SCENE_LIB", raising=False)+ monkeypatch.delenv("C3D_VARIANT", raising=False)+ spec = make_spec(Track.SCENE, BPY)+ tmp_ws.write_json(tmp_ws.spec_path, spec.model_copy(update={"options": spec.options.model_copy(update={"variant": RAW})}))+ get_settings.cache_clear()+ try:+ ctx = build_context(tmp_ws.root)+ assert ctx.language == BPY.value and get_settings().scene_lib is True+ assert apply_run_knobs(ctx) == {"scene_lib": False} and get_settings().scene_lib is False+ tmp_ws.write_json(tmp_ws.spec_path, spec) # a base run applies nothing+ get_settings.cache_clear()+ assert apply_run_knobs(build_context(tmp_ws.root)) == {} and get_settings().scene_lib is True+ finally:+ get_settings.cache_clear()