List both sides of every papercraft joint; archive QA round 5

QA round 5 read the top cap's empty glues_to as a missing joint. Tabs sit on
one side only and the top cap's are on band 7, so the joint was there but the
report listed only outgoing tabs. Each piece now has glues_to and
receives_from, with labels resolved to piece names (a split band "band 2"
-> 2a, 2b; "band 1a start" -> band 1a). Tab labels are kept in the data even
when too short to print. Apple 8x16: 22 pieces, none unconnected.

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

SPEC.md

@@ -143,7 +143,9 @@ that would curl past ~120° on paper overlaps itself, so it is split into parts
 Every joint has glue tabs on one side only, labelled with the piece they meet (band top
 edge → next band or top cap, seam end → own start or next part, bottom cap rim → band 1).
 Caps under 4 mm are dropped and the band closes to a point; tabs under 2 mm are dropped.
-Cut solid lines, fold dashed lines.
+Cut solid lines, fold dashed lines. The report lists, per piece, `glues_to` (the tabs it
+carries) and `receives_from` (pieces whose tabs land on it), so a tabless piece such as
+the top cap still shows its joint.
 
 Output is A4 pages (190 × 277 mm inside 10 mm margins). Each piece is turned to its
 narrowest orientation and shelf-packed; strips longer than a page are split like curled

app.py

@@ -283,8 +283,7 @@ def papercraft_rings(ledger_json: str, item_id: str, rings: str = "8", samples:
                   "model_height_cm": round((profile[-1]["y"] - profile[0]["y"]) * scale / 10, 1),
                   "real_height_cm": round(real_cm, 1), "max_height_cm_for_a4": round(a4_cm, 1),
                   "fits_a4": bool(h is None or h <= a4_cm), "pages": page_report,
-                  "pieces": [{"name": pc["name"], "glues_to": sorted({t["label"] for t in pc["tabs"] if t["label"]})}
-                             for pc in pieces]}
+                  "pieces": [{"name": name, **j} for name, j in papercraft.joins(pieces).items()]}
         return json.dumps(report, indent=1), files
     except Exception as e:
         _fail(e)

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

@@ -158,3 +158,27 @@ Ladder shape note: for this cat the descent ends at 1,000 faces — the 250 requ
 **Still open (from the apple demo, unchanged by this push — confirmed by re-render):** grey SimReady objects (average the already-downloaded 256px thumbnail into `base_color`), dark no-sun scenes (`sun: null` → near-black render; suggest default daylight or a "what light?" question), cross-tier hint in questions (`q3 "which table?"` shows `alternatives: []` while 101 Objaverse tables sit one reject away), thumbnails as URLs so variants can be chosen by look (the 9 `food_produce_apple_*` variants are the real path to "a green apple"). Plus the minor `use`-back-swap check and the UI visual click-test.
 
 > Note (agent, 2026-10-30): the four apple-demo items above were addressed in 98ca16a, pushed after this round was written.
+
+---
+
+## 8. Verification round 5 (2026-10-30, after the apple-demo push) — all four pass, and papercraft's first live run
+
+**"the green apple on the table", re-run:**
+
+| Item | Live result |
+|---|---|
+| Default daylight + shadows | ✓ `sun: {id: null, elevation 50.2°, azimuth 68.8°, shadows: true, daylight: true}` — blue sky, visible crate/table shadows, readable picture with no glowing verb |
+| `"what light?"` question | ✓ `q_light`, implied, `default_chosen: "daylight"`, alternatives `["rephrase: '<noun> shone' or '<noun> glowed'"]` |
+| Thumbnail colours | ✓ render: crate unmistakably green (`#326d3e`), table `#d6d4d5`, apple `#b27045` on the tabletop. Bonus: colour is now a per-object `color` field **in the ledger** — a chat model reads the colour without rendering |
+| Thumbnail URLs | ✓ `huggingface.co/datasets/.../resolve/...` links replace Space paths |
+| `on_reject` | ✓ `q4 "which table?" → {tier: "objaverse", candidates: 101, offered: 9}`; `q0 "which green?" → {tier: "primitive"}` (correct: green has 0 Objaverse candidates) |
+
+Note: apple `b01` is a reddish-brown (#b27045) — "a green apple" still means walking the `b01–j01` variants via `use:`/reroll and reading each `color` (one call per variant). V2 nicety: colour chips on alternative labels.
+
+**`papercraft_rings` first live run (apple, rings 8×16):** ✓ works end-to-end.
+- 6 A4 pages (210×297 mm), 22 pieces: 7 bands split where curl would exceed ~120° (`band 1a–1e, 2a–2b, 3a–3b, 4a–4c, 5a–5c, 6a–6b, 7a–7c`) + bottom cap + top cap.
+- Glue graph complete downwards: each part names its neighbours and the next band, last parts loop to `band … start`, bottom cap → band 1.
+- Sizing: real height 6.6 cm → blank `height_cm` gives the largest A4-fitting model (16.3 cm, `fits_a4: true`); pass 6.6 for true scale.
+- **Bug: `top cap` has `glues_to: []`** — its glue edge to band 7 is missing from the assembly graph (bottom cap correctly glues to band 1). Small fix in the glue-path builder; an assembler would otherwise hold an unlabeled lid.
+
+> Note (agent): not a missing edge — tabs sit on one side of each joint, and the top cap's are on band 7's top edge. The report listed only outgoing tabs; it now also lists `receives_from`, so the top cap shows band 7a–7c.

vli/papercraft.py

@@ -73,21 +73,19 @@ def _tab(p, q, inside, label):
     """A trapezoid glue tab on edge p-q, on the side away from `inside`.
 
     Edges under MIN_TAB_MM get no tab (too small to glue), and only edges of
-    LABEL_TAB_MM or more carry the label, so converging edges don't pile up text.
+    LABEL_TAB_MM or more print the label, so converging edges don't pile up text.
     """
     e = q - p
     L = np.linalg.norm(e)
     if L < MIN_TAB_MM:
         return None
-    if L < LABEL_TAB_MM:
-        label = ""
     n = np.array([-e[1], e[0]]) / L
     if np.dot(n, inside - p) > 0:
         n = -n
     w, inset = min(TAB_MM, 0.4 * L), min(TAB_MM, 0.25 * L)
     u = e / L
     return {"poly": [p, q, q + n * w - u * inset, p + n * w + u * inset], "label": label,
-            "at": (p + q) / 2 + n * w / 2}
+            "show": bool(L >= LABEL_TAB_MM), "at": (p + q) / 2 + n * w / 2}
 
 
 def _chunks(B, max_turn_deg=120, max_len=np.inf):
@@ -232,7 +230,7 @@ def svg(placed, title):
     for pc, off in placed:
         for t in pc["tabs"]:
             out.append(f'<polygon points="{pts(t["poly"], off)}" fill="#eee" stroke="#000" stroke-width="0.2"/>')
-            if not t["label"]:
+            if not t["show"]:
                 continue
             a = xy(t["at"], off)
             out.append(f'<text x="{a[0]:.1f}" y="{a[1]:.1f}" font-size="2" text-anchor="middle" '
@@ -249,5 +247,25 @@ def svg(placed, title):
     return "\n".join(out), (round(width), round(height))
 
 
+def joins(pieces):
+    """Both sides of every joint. Tabs sit on one side only (the last band carries the
+    tabs for the top cap), so a piece lists the tabs it carries and the pieces whose
+    tabs land on it. A label names a piece, a split band ("band 2" -> 2a, 2b) or a
+    seam start ("band 1a start")."""
+    names = [pc["name"] for pc in pieces]
+
+    def targets(label):
+        base = label[:-len(" start")] if label.endswith(" start") else label
+        return [n for n in names if n == base or (n != base and n.rstrip("abcdefghijklmnopqrstuvwxyz") == base)]
+
+    out = {n: {"glues_to": set(), "receives_from": set()} for n in names}
+    for pc in pieces:
+        for t in pc["tabs"]:
+            for n in targets(t["label"]):
+                out[pc["name"]]["glues_to"].add(n)
+                out[n]["receives_from"].add(pc["name"])
+    return {n: {k: sorted(v) for k, v in j.items()} for n, j in out.items()}
+
+
 def _esc(s):
     return s.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")