Act on the 2026-10-30 QA pass: reroll walks the pool, clearer questions and errors

- Reroll takes the next alternative (old choice to the back) instead of a
seed-drawn slot, so repeated rerolls visit the whole pool and the seed
only picks the configuration.
- "which <word>?" options carry a short uid, so Objaverse candidates that
share a category are distinguishable.
- Rejecting a primitive raises a clear error before touching the ledger
(generation is not wired up yet); docs say so.
- Example sentence is now "the cat sat and the lamp glowed", which needs
no primitives.
- decimate hands fast-simplification writable copies and drops the old
positional fallback, which newer trimesh reads as a percentage.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

SPEC.md

@@ -123,7 +123,8 @@ and download without one. Optional env: `VLI_CACHE`.
 ## Known gaps / open questions
 
 - **Materialization** (papercraft from a low rung) is not built yet.
-- **Generation tier** is a stub: rejecting a primitive errors out.
+- **Generation tier** is a stub: rejecting a primitive returns a clear error before
+  changing the ledger (use `shape` or `height_m` instead).
 - SimReady names → words is a heuristic: the name after its category is indexed
   as a whole phrase plus its final part (`interiorPart_sun_visor_a01` → "sun visor",
   "visor"; never "sun" alone). `maps_to` makes the remaining misses visible.

app.py

@@ -92,7 +92,7 @@ def translate_to_scene(sentence: str, primitives_json: str = "{}", seed: str = "
     with no asset must be mapped to a primitive in primitives_json (see check_words).
 
     Args:
-        sentence: A sentence using available words, e.g. "the cat sat and the sun shone".
+        sentence: A sentence using available words, e.g. "the cat sat and the lamp glowed".
         primitives_json: JSON object mapping missing words to shapes, e.g. {"sun": "sphere"}.
         seed: Picks one of the configurations that satisfy the ledger (positions, facing, sun).
 
@@ -112,24 +112,27 @@ def refine_scene(ledger_json: str, changes_json: str = "[]", seed: str = "0") ->
         {"id": "n1", "freeze": true}      lock an item (false unlocks)
         {"id": "n1", "use": 2}            swap in alternatives[2]; the old choice takes slot 2,
                                           so using 2 again swaps back (other slots don't move)
-        {"id": "n1", "reject": true}      reject the tier: simready -> objaverse -> primitive -> generation
+        {"id": "n1", "reject": true}      reject the tier: simready -> objaverse -> primitive
+                                          (generation is not wired up: a primitive can't be rejected)
         {"id": "n1", "height_m": 0.4}     set the object's height in metres
         {"id": "n1", "shape": "sphere"}   use a primitive (box, sphere, cylinder, cone, plane)
-        {"reroll": true}                  every unfrozen object takes a random alternative
+        {"reroll": true}                  every unfrozen object takes its next alternative;
+                                          repeated rerolls visit the whole pool, whatever the seed
     Frozen items cannot be changed. The configuration (placement, sun angle) is always
     re-chosen from `seed`: change the seed for another valid configuration.
 
     Args:
         ledger_json: Ledger JSON from translate_to_scene or a previous refine_scene.
         changes_json: JSON list of changes, as above.
-        seed: Picks the configuration, and the alternatives for a reroll.
+        seed: Picks the configuration (placement, sun). Placement scales with each
+            asset's size, so swapping an asset shifts offsets even at the same seed.
 
     Returns:
         (ledger JSON string, rendered PNG, GLB scene file, mini HTML page).
     """
     try:
         ledger = _json(ledger_json, "ledger_json")
-        pipeline.apply_changes(ledger, _json(changes_json, "changes_json", []), _seed(seed))
+        pipeline.apply_changes(ledger, _json(changes_json, "changes_json", []))
         return pipeline.outputs(ledger, _seed(seed))
     except Exception as e:
         _fail(e)
@@ -239,7 +242,7 @@ with gr.Blocks(title="VisualLearningIdea") as demo:
                 "verbs and prepositions are relations between meshes.")
     gr.Markdown(DATASETS_MD)
     with gr.Row():
-        sentence = gr.Textbox(label="Sentence", placeholder="the cat sat and the sun shone", scale=4)
+        sentence = gr.Textbox(label="Sentence", placeholder="the cat sat and the lamp glowed", scale=4)
         seed = gr.Textbox(label="Configuration seed", value="0", scale=1)
     status = gr.Markdown()
     suggest = gr.Radio(label="Suggestions", choices=[], interactive=True)

vli/grammar.py

@@ -125,7 +125,8 @@ def next_tier(decision, word):
             return {"tier": tier, "chosen": cands[0], "alternatives": cands[1:9]}
         if tier == "primitive":
             return {"tier": tier, "chosen": primitive_candidate(), "alternatives": []}
-        return {"tier": tier, "chosen": {"source": "generation", "prompt": word}, "alternatives": []}
+        raise ValueError(f"'{word}' has no tier left after {decision['tier']}: generation is not "
+                         f"wired up yet. Use shape or height_m instead, or rephrase.")
     raise ValueError(f"'{word}' has no tier left after {decision['tier']}")
 
 

vli/pipeline.py

@@ -7,8 +7,6 @@ import json
 import os
 import tempfile
 
-import numpy as np
-
 from . import assets, html, scene
 from .grammar import build_ledger, candidate_label, next_tier, parse_primitives, primitive_candidate
 
@@ -17,6 +15,12 @@ def _workdir():
     return tempfile.mkdtemp(prefix="vli_")
 
 
+def _option_label(cand):
+    """Objaverse candidates share a category name, so the uid tells them apart."""
+    label = candidate_label(cand)
+    return f"{label} [{cand['uid'][:6]}]" if cand.get("uid") else label
+
+
 def settle_all(ledger):
     """Load every object's mesh; unusable candidates are skipped and recorded."""
     meshes = {}
@@ -28,8 +32,8 @@ def settle_all(ledger):
     for q in ledger["unresolved"]:
         about = next((i for i in ledger["items"] if i["id"] == q.get("about")), None)
         if about and about["kind"] == "object":
-            q["default_chosen"] = about["decision"]["label"]
-            q["alternatives"] = [candidate_label(c) for c in about["decision"]["alternatives"]]
+            q["default_chosen"] = _option_label(about["decision"]["chosen"])
+            q["alternatives"] = [_option_label(c) for c in about["decision"]["alternatives"]]
     return meshes
 
 
@@ -47,24 +51,25 @@ def translate(sentence, primitives=None, seed=0):
     return outputs(build_ledger(sentence, primitives), seed)
 
 
-def apply_changes(ledger, changes, seed=0):
+def apply_changes(ledger, changes):
     """changes: list of
         {"id": ..., "freeze": true|false}
         {"id": ..., "use": <index into alternatives>}
         {"id": ..., "reject": true}          -> next tier
         {"id": ..., "height_m": 0.4}
         {"id": ..., "shape": "sphere"}       -> primitive tier with that shape
-        {"reroll": true}                     -> every unfrozen object takes a random alternative
+        {"reroll": true}                     -> every unfrozen object takes its next alternative
+    Reroll walks the pool (the old choice goes to the back), so repeated rerolls
+    visit every alternative before repeating, independent of the seed.
     """
     by_id = {i["id"]: i for i in ledger["items"]}
-    rng = np.random.default_rng(seed)
     for ch in changes:
         if ch.get("reroll"):
             for it in ledger["items"]:
                 dec = it.get("decision")
                 if it["kind"] == "object" and not it["frozen"] and dec["alternatives"]:
-                    k = int(rng.integers(len(dec["alternatives"])))
-                    dec["alternatives"][k], dec["chosen"] = dec["chosen"], dec["alternatives"][k]
+                    dec["alternatives"].append(dec["chosen"])
+                    dec["chosen"] = dec["alternatives"].pop(0)
             continue
         it = by_id.get(ch.get("id"))
         if it is None:
@@ -81,8 +86,9 @@ def apply_changes(ledger, changes, seed=0):
             k = int(ch["use"])
             dec["alternatives"][k], dec["chosen"] = dec["chosen"], dec["alternatives"][k]
         if ch.get("reject"):
+            nxt = next_tier(dec, it["word"])
             dec["rejected_tiers"].append(dec["tier"])
-            dec.update(next_tier(dec, it["word"]))
+            dec.update(nxt)
             if it["height_m"]["source"] != "user":
                 it["height_m"] = {"value": None, "source": "pending"}
         if "shape" in ch:

vli/simplify.py

@@ -24,10 +24,10 @@ def base_color(mesh):
 
 def decimate(mesh, faces):
     color = base_color(mesh)
-    try:
-        out = mesh.simplify_quadric_decimation(face_count=faces)
-    except TypeError:  # older trimesh signature
-        out = mesh.simplify_quadric_decimation(faces)
+    # fast-simplification rejects read-only arrays (cached views), so hand it fresh copies
+    src = trimesh.Trimesh(np.array(mesh.vertices, dtype=np.float64), np.array(mesh.faces, dtype=np.int64),
+                          process=False)
+    out = src.simplify_quadric_decimation(face_count=faces)
     out.visual = trimesh.visual.ColorVisuals(out, face_colors=np.tile(color, (len(out.faces), 1)))
     return out