test+docs: repair edit_creature 4-tuple test; wiki for canvas + one-call tweak

A parallel commit landed the single-call edit_creature change (now returns
(genome, boxes, tweaks, status)) but left test_freeform_edit.py unpacking the
old 3-tuple, so the committed test failed. Update the unpack + assert the 4
returned tweaks. Full suite: 81 passed.

Wiki:
- voxel-rendering.md: "Lab canvas: pan + viewport-pooled live 3D" (live nodes
kept under the WebGL context cap by cullCanvasNodes; the setPointerCapture
click-swallow trap; cached pan offset + dot-grid shift; JS bench-x centering),
refreshed the context-cap failure mode, added the 0x0 size-guard fix (blank
Splice Bench) + culled-stage disposal, retired the obsolete inspect-modal note.
- deployment-strategy.md: "A bench tweak is ONE GPU call, not two" — edit_creature
returns geometry + 4 hints from a single completion (combined EDIT_SCHEMA),
removing the per-tweak suggest_tweaks GPU call (likely "Running on ZERO" stuck
cause), with the fallback top-up and revert path.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

tests/test_freeform_edit.py

@@ -38,8 +38,9 @@ def test_fake_runtime_edit_creature():
     from buddy_fusion.runtime import FakeBuddyRuntime
     rt = FakeBuddyRuntime()
     genome = {"name": "X", "archetype": "chick", "parts": []}
-    g, boxes, status = rt.edit_creature(genome, BASE, "add two horns")
+    g, boxes, tweaks, status = rt.edit_creature(genome, BASE, "add two horns")
     assert len(boxes) > len(BASE)
     assert status.used_fallback
     assert g["name"] == "X"
+    assert len(tweaks) == 4 and all(isinstance(t, str) and t for t in tweaks)
 

wiki/deployment-strategy.md

@@ -1,7 +1,7 @@
 ---
 title: Deployment Strategy
 tags: [deployment, hugging-face, llama-cpp, zerogpu, architecture]
-last_updated: 2026-06-14
+last_updated: 2026-06-15
 confidence: high
 sources:
   - src/buddy_fusion/runtime.py
@@ -57,6 +57,21 @@ background while the player reads the intro. It runs once per container
 These are recipe-level JSON, not prose, so the budgets are small — keeping a
 playthrough's GPU seconds lean so a judge's first splice isn't spent on the JIT.
 
+### A bench tweak is ONE GPU call, not two (2026-06-15)
+
+`edit_creature` returns `{name, boxes, tweaks[4]}` from a **single** completion
+(combined `EDIT_SCHEMA`): the model edits the geometry *and* proposes the next
+four hint bubbles in one shot. This removed the separate `suggest_tweaks` GPU
+call that fired after every tweak (the old `_side_hints` path) — each bubble tap
+or typed tweak previously held the GPU for two back-to-back ZeroGPU allocations,
+the likely cause of the "Running on ZERO" indicator sticking at 1 / never
+clearing. The fallback path (and any short hint list) tops up to four from the
+deterministic `suggest_tweaks_fallback` pool, so no second GPU call ever runs.
+Trade-off: the small model now does two tasks in one grammar-constrained JSON; if
+geometry or hint quality regresses, split `EDIT_SCHEMA` back into `BOX_SCHEMA` +
+`TWEAK_SCHEMA` and re-add the second call. `suggest_tweaks` is retained (tests,
+and as the standalone fallback source) but no longer called per tweak by the UI.
+
 ### Schema enforcement (response_format) — load-bearing
 
 `_blocking_completion` constrains output with

wiki/log.md

@@ -2,6 +2,23 @@
 
 ## 2026-06-15
 
+### voxel-rendering + deployment-strategy: Figma canvas (pan + pooled live 3D) and one-call bench tweak
+
+- `voxel-rendering.md`: added "Lab canvas: pan + viewport-pooled live 3D" — tree
+  nodes are live rotating 3D (not thumbnails), kept under the WebGL context cap by
+  `cullCanvasNodes()` (boot on-view / teardown off-view; verified dispose→reboot).
+  Documented the `setPointerCapture`-swallows-clicks trap (use window move/up +
+  `__buddyPanned`), the cached pan offset + dot-grid background-position shift, and
+  JS bench-× centering. Updated the context-cap failure mode (Compendium = shared
+  thumbnail renderer; Lab = pooled live), added the 0×0 size-guard fix (blank
+  Splice Bench root) and the culled-stage disposal path, and retired the obsolete
+  inspect-modal "purple chicken" bullet (modal removed; nodes are live now).
+- `deployment-strategy.md`: added "A bench tweak is ONE GPU call, not two" —
+  `edit_creature` now returns `{name, boxes, tweaks[4]}` from a single completion
+  (combined `EDIT_SCHEMA`), removing the per-tweak `suggest_tweaks` GPU call (the
+  likely "Running on ZERO" stuck-indicator cause). Notes the fallback top-up and
+  the revert path.
+
 ### voice-input-asr: documented the English-only exception for fallback.py CJK match tables
 
 - `voice-input-asr.md`: added "English-only exception: keep the CJK match tables

wiki/voxel-rendering.md

@@ -122,14 +122,15 @@ system does; the AI only sets the composition.**
   Detection: watch a tall/long archetype (horse, hippo, dog) through a full
   turn; if it swings toward an edge at some angles instead of rotating in place,
   the pivot is at the origin, not the center.
-- **WebGL context cap (~16) — thumbnails must share one renderer.** Each live
-  stage holds a `WebGLRenderer`/context; the family tree grows one node per
-  creature, so a live context per thumbnail would blow the browser cap and blank
-  the oldest stages. Thumbnails (`voxel_html(thumb=True)`) render through one
-  shared offscreen renderer (`window.__voxelThumbRenderer`,
-  `preserveDrawingBuffer:true`) and snapshot to an `<img>` — flat context count
-  regardless of tree size. Only the two ancestor stages + the child stage keep a
-  live context. See [gradio-embed-integration](gradio-embed-integration.md).
+- **WebGL context cap (~16).** Each live stage holds a `WebGLRenderer`/context;
+  the browser drops the oldest when you exceed ~16 (and the mounted bench/reveal
+  stages eat into that), blanking it with a "Too many active WebGL contexts"
+  warning. Two strategies coexist: the **Compendium grid** still uses static
+  thumbnails (`voxel_html(thumb=True)` → one shared offscreen
+  `window.__voxelThumbRenderer`, `preserveDrawingBuffer:true`, snapshot to `<img>`)
+  so its 50+ cards cost one context total; the **Lab pedigree canvas** uses live
+  3D nodes that are viewport-pooled (see "Lab canvas" below). See
+  [gradio-embed-integration](gradio-embed-integration.md).
 - **Coincident cubes Z-fight (fixed 2026-06-14).** `voxelsFromGenome` layers
   body + archetype features + genome parts by pushing cubes, and several land on
   the *same* cell — e.g. the `earsnout` snout writes a cube at `(0, hyB, frontZ)`
@@ -140,20 +141,55 @@ system does; the AI only sets the composition.**
   layer over features) — coincident geometry is removed, not merely offset. Do
   not "fix" this with polygonOffset (one shared InstancedMesh material → no
   per-instance offset) or position jitter (leaves overlapping edges).
-- **Inspect modal must pass `boxes` through, or freeform creatures render as a
-  chick (fixed 2026-06-15).** `buildModalStage` (the 🔍 zoom overlay) built its
-  voxel config from the genome dict only. `setupVoxel` picks the geometry with
-  `(cfg.boxes && cfg.boxes.length) ? voxelsFromBoxes : voxelsFromGenome`, so with
-  no `boxes` key a freeform creature fell through to the **archetype** voxelizer
-  and rendered as a generic palette-coloured chick (the "purple chicken" bug) —
-  even though its tree thumbnail (which does pass `boxes`) was correct. Fix: pass
-  `boxes: (genome && genome.boxes) || null` in the modal cfg. Any new render
-  entry point must thread `boxes` the same way (`voxel_html` already does via
-  `eff_boxes`).
-- **Detached live stages leak a context if not disposed.** The animation loop
-  guards on `root.isConnected`; when a stage leaves the DOM it calls
-  `renderer.dispose()` + `forceContextLoss()` and stops the RAF. Skipping this
+- **Any new render entry point must thread `boxes`.** `setupVoxel` picks geometry
+  with `(cfg.boxes && cfg.boxes.length) ? voxelsFromBoxes : voxelsFromGenome`, so a
+  freeform creature whose cfg omits `boxes` falls through to the **archetype**
+  voxelizer and renders as a generic palette-coloured chick (the historical "purple
+  chicken" bug, when the old inspect modal built its cfg from the genome dict
+  alone). `voxel_html` threads it via `eff_boxes`; replicate that in any hand-built
+  cfg. (The inspect modal itself was removed once tree nodes became live 3D.)
+- **Detached / culled live stages must dispose, or they leak a context.** The RAF
+  loop stops + disposes (`renderer.dispose()` + `forceContextLoss()`, remove the
+  canvas, clear `voxelInit`) when `!root.isConnected` OR when
+  `root.dataset.voxelTeardown === "1"` (set by the canvas pool). Skipping disposal
   leaks a context per re-render and eventually trips the cap above.
+- **Boot only after the stage has layout (fixed 2026-06-15 — blank Splice Bench).**
+  `setupVoxel` used to mark `voxelInit=1` immediately then fall back to a 320×300
+  size. On the Space, Gradio reveals a hidden column and writes its HTML in the
+  same tick, so the stage is 0×0 for a frame; booting then locked the renderer to
+  the fallback size and the bench rendered blank until a manual refresh. Fix: bail
+  **without** marking inited when `stage.clientWidth/Height` is 0, so the 400ms
+  poll retries once layout settles.
+
+## Lab canvas: pan + viewport-pooled live 3D
+
+The Lab pedigree is a Figma / Google-Stitch-style canvas (`lineage_html` →
+`.buddy-canvas` clipping viewport → `.buddy-canvas-pan` transformed layer →
+`.buddy-tree`). Tree nodes are **live rotating 3D** (`voxel_html(build=False)`),
+not thumbnails.
+
+- **Viewport pooling keeps live nodes under the context cap.** A 400ms poll (and
+  the pan `pointermove`) runs `cullCanvasNodes()`: a node whose stage rect is
+  within a margin of the `.buddy-canvas` rect gets `setupVoxel`; one panned outside
+  gets `root.dataset.voxelTeardown="1"` and its RAF loop disposes the context.
+  Verified: pan the only nodes off-canvas → live canvas count drops to 0; pan back
+  → they re-boot. So "everything visible is live 3D" without ever exceeding ~16
+  contexts as the tree grows. `scanAndSetupVoxels` and the MutationObserver
+  **skip** any root inside `.buddy-canvas` (`r.closest('.buddy-canvas')`) so only
+  the pool manages those.
+- **Left-drag pan — do NOT `setPointerCapture`.** Capturing the pointer on the
+  canvas swallows the node's `click`, so tapping a creature never selects it. Use
+  `pointerdown` on the canvas + `pointermove`/`pointerup` on `window`, and a
+  movement-threshold flag `window.__buddyPanned` that suppresses the node-select
+  click only when an actual drag happened (a clean tap selects). The pan offset is
+  cached on `window.__buddyCanvasOff` so a tree re-render (which replaces the
+  canvas HTML) restores the player's position instead of snapping to centre. The
+  dot grid is a tiled `background-image` on `.buddy-canvas` whose
+  `background-position` is shifted by the same offset → reads as an infinite canvas.
+- **Bench × centering is JS, not a magic margin.** `centerBenchX()` (in the poll)
+  measures the scene rect and nudges `.buddy-bench-x` `margin-top` so its centre
+  matches the scene's — self-correcting across font/scene-size changes (the old
+  fixed `margin-top` drifted when the root font size changed).
 
 ## Offline export & the landing backdrop