Weld before decimating so stalled meshes reach their budget; stop repeated ladder rungs

QA round 2 found decimation flooring far above target (4,893 faces in a
400-face page; ladder rungs 1000/250/60 all 1,141 faces). Asset files split
vertices at UV and normal seams, so edges aren't shared and the decimator
stalls. decimate now welds first and re-welds between passes while that
still helps. A split-seam test mesh that stalled at 3,840 now reaches 400.

The ladder labels rungs with their real face count and stops descending
when a rung doesn't reduce. Inline meshes in the page state faces, budget
and floor, so an over-budget mesh is visible instead of silent.

Also archives QA verification round 2.

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

SPEC.md

@@ -106,6 +106,9 @@ that exists but maps to the wrong thing shows up before submitting.
 
 Ladder rungs: original → 20k / 5k / 1k / 250 / 60 faces → convex hull → oriented
 box. Where the object stops reading as its word is judged in the discussion.
+Decimation welds split vertices (UV and normal seams) between passes. Rungs are
+labelled with the faces they actually have, and the ladder stops descending when
+a rung doesn't reduce, so a stalled mesh never shows as several identical rungs.
 
 ### Mini HTML
 
@@ -114,6 +117,8 @@ data object holding the sentence, the reading (word → commits), relations,
 unresolved questions, sun, ground, and each object's position, yaw and colour.
 Each object also has either inline low-poly geometry (≤400 faces in a scene,
 rungs ≤1000 faces in a ladder) or a primitive spec. Vertices are rounded to cm.
+Each inline mesh states `faces`, `budget` and `floor`: `floor: true` means the mesh
+wouldn't decimate down to the budget, so the page carries more than asked.
 The geometry is inline, so a saved page works after Gradio's temporary file URLs expire.
 
 **Geometry is for the handoff, not the loop.** Even at 400 faces a page costs

feedback/vli-qa-feedback-2026-10-30.md

@@ -105,4 +105,22 @@ Seed-0 baseline reproduced bit-identically from the first session: uid `4459b90d
 5. `reject n1` (primitive tier) → `Error: no usable generation asset for 'cat' (generation tier is not wired up yet)` ⚠️ *(documented gap, now confirmed end-to-end)*
 6. `check_words "the cat sat and the lamp glowed"` → `ok: true`, lamp `available_in {simready: 1, objaverse: 79}`, `maps_to: "desk_lamp"` ✅
 
-**Suggested follow-ups for the agent's own QA:** `simplify_item` end-to-end (ladder rungs + `LADDER_MAX_FACES` skip), NC/ND license skip recording with a live `decision.skipped` entry, `use` back-swap idempotence after a skip shifted indices, and `check_words` on a low-memory/fallback build to observe dictionary drift.
+**Suggested follow-ups for the agent's own QA:** `simplify_item` end-to-end (ladder rungs + `LADDER_MAX_FACES` skip), NC/ND license skip recording with a live `decision.skipped` entry, `use` back-swap idempotence after a skip shifted indices, and `check_words` on a low-memory/fallback build to observe dictionary drift.
+---
+
+## 5. Verification round 2 (2026-10-30, after commits 447d1d2 / f9a8763) — deployed Space, live MCP
+
+| Fix | Result |
+|---|---|
+| P0-0 html modes | ✓ default `url` = file link + empty text (verified on `translate_to_scene` and `refine_scene`); `inline` returns the page text. Iterate-loop cost dropped from ~60k to ~2-3k tokens/call — measured on this session itself. `skip` code-verified, not yet exercised live |
+| P0-0 rounding | ✓ pages show 1 cm (2-decimal) coords |
+| P1-1 reroll | ✓ walks the pool by next-alternative rotation; bonus: exercised the license-skip path live — `1f32bc` skipped `by-nc` and recorded in `decision.skipped`, landed on `138377` (`by-sa`), old choice parked at pool end, q0 labels refreshed |
+| P1-2 uid labels | ✓ `cat [4459b9]`, `cat [138377]`, … |
+| P1-3 primitive reject | ✓ clean pre-empted error: `'cat' has no tier left after primitive: generation is not wired up yet. Use shape or height_m instead, or rephrase.` |
+| P1-4 example sentence | ✓ `the cat sat and the lamp glowed` runs with no primitives; lamp via the **SimReady tier working live for the first time** (ForgeCAD/simready-assets `desk_lamp`, metric height 0.472 m from asset, CC-BY-4.0). Note: the SimReady index now builds from `ForgeCAD/…`, not `nvidia/…` — P2-7 drift applies to it |
+| P2-5 face budget | **✗ partially — decimation floors, it doesn't fail.** Ladder proved it: 135,934 → 19,999 → 5,000 → **1,141**, then 250/60 rungs return 1,141 (identical GLBs). Quadric decimation stalls per-mesh when it runs out of weldable structure (`watertight: false`, ~1.1 verts/tri in the stalled output); 4459b9's floor is 4,893, so the page still ships 4,893 despite budget 400 |
+
+**Round-3 items:**
+1. **Decimate floor:** weld between passes — `out.merge_vertices()` then re-run `simplify_quadric_decimation` in a loop until the target or no further progress (Objaverse GLBs split vertices; the decimator starves on unshared edges). If a floor persists, surface it in the page (`"faces": n, "budget": 400, "floor": true`) instead of silently exceeding.
+2. **Ladder duplicate rungs:** the rung guard compares against the requested level, so a stalled decimation still appends lower rungs (1000/250/60 all rendered as the same 1,141-face mesh). Stop descending when a rung fails to actually reduce.
+3. Still open: `use` back-swap after a skip shifts indices; live `skip`-mode; the UI visual click-test (mode radio + preview-from-file — code verified, needs eyes).

vli/html.py

@@ -28,8 +28,9 @@ def _sky_hex(sun):
 
 
 def _geometry(mesh, budget):
+    """Inline mesh; "floor" marks a mesh that wouldn't decimate down to the budget."""
     m = decimate(mesh, budget) if len(mesh.faces) > budget else mesh
-    return {"faces": int(len(m.faces)),
+    return {"faces": int(len(m.faces)), "budget": budget, "floor": bool(len(m.faces) > budget),
             "p": np.round(m.vertices, 2).ravel().tolist(),  # cm: plenty at low poly, fewer tokens
             "i": m.faces.ravel().astype(int).tolist()}
 

vli/simplify.py

@@ -22,12 +22,31 @@ def base_color(mesh):
     return np.array([180, 180, 180, 255], dtype=np.uint8)
 
 
+def _welded(mesh):
+    """Geometry only, with coincident vertices merged, in fresh writable arrays.
+
+    Asset files split vertices at UV and normal seams; the decimator can't collapse
+    edges that aren't shared, so an unwelded mesh stalls far above its target.
+    fast-simplification also rejects read-only arrays (cached views), hence the copies.
+    """
+    m = trimesh.Trimesh(np.array(mesh.vertices, dtype=np.float64), np.array(mesh.faces, dtype=np.int64))
+    return trimesh.Trimesh(np.array(m.vertices, dtype=np.float64), np.array(m.faces, dtype=np.int64),
+                           process=False)
+
+
 def decimate(mesh, faces):
+    """Reduce toward `faces`, re-welding between passes while that still helps.
+
+    The result can stay above `faces` when the mesh has no more structure to collapse
+    (many disconnected parts): callers compare len(result.faces) with what they asked.
+    """
     color = base_color(mesh)
-    # 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 = _welded(mesh)
+    while len(out.faces) > faces:
+        nxt = _welded(out.simplify_quadric_decimation(face_count=faces))
+        if len(nxt.faces) > 0.95 * len(out.faces):
+            break
+        out = nxt
     out.visual = trimesh.visual.ColorVisuals(out, face_colors=np.tile(color, (len(out.faces), 1)))
     return out
 
@@ -41,8 +60,13 @@ def ladder(mesh):
     color = base_color(mesh)
     rungs = [("original", mesh)]
     for n in FACE_LEVELS:
-        if n < 0.8 * len(rungs[-1][1].faces):
-            rungs.append((f"{n} faces", decimate(mesh, n)))
+        prev = len(rungs[-1][1].faces)
+        if n >= 0.8 * prev:
+            continue
+        rung = decimate(mesh, n)
+        if len(rung.faces) > 0.8 * prev:
+            break  # decimation stalled: lower levels would repeat this mesh
+        rungs.append((f"{len(rung.faces)} faces", rung))
     rungs.append(("convex hull", _recolor(mesh.convex_hull, color)))
     box = mesh.bounding_box_oriented
     rungs.append(("bounding box", _recolor(trimesh.Trimesh(box.vertices, box.faces), color)))