deploy: updated core + ingestion pipeline (1,304 refs, 25 lessons, 260 Lane C obs locally)

DEPLOYMENT.md

@@ -0,0 +1,241 @@
+# The Chief Engineer — HF Space Deployment Guide
+
+**Space:** `build-small-hackathon/microfactory-lab`  
+**Hardware:** zero-a10g (ZeroGPU)  
+**Status:** 🟢 LIVE — https://build-small-hackathon-microfactory-lab.hf.space
+
+---
+
+## Quick Summary
+
+The Gradio app was failing on HF Spaces due to three platform-specific issues:
+1. **SSR crash** — Gradio 6's Node.js SSR proxy crashes on zero-a10g
+2. **Missing `@spaces.GPU`** — ZeroGPU hardware requires at least one decorated function
+3. **Theme/CSS/head lost** — pySpaces calls `demo.launch()` without our custom args (Gradio 6 moved these from `Blocks()` to `launch()`)
+
+All fixed. The app runs on **ZeroGPU** with Gemma 4 E2B (2B params, Apache 2.0, not gated).
+
+---
+
+## Dual-Config Architecture
+
+The codebase supports **both** local development and Space deployment from a single `app.py`:
+
+| Environment | Launch Trigger | Theme Injection | ZeroGPU |
+|-------------|----------------|-----------------|---------|
+| **Local dev** | `if __name__ == "__main__": demo.launch(...)` | Explicit args + monkey-patch defaults | `@spaces.GPU` no-op |
+| **HF Space** | pySpaces imports module → calls `demo.launch()` | Monkey-patch `setdefault()` fills THEME/CSS/VP_HEAD/ssr_mode | `@spaces.GPU` wraps function |
+
+**Key mechanisms:**
+- `demo = build()` at module level — pySpaces finds it
+- `if __name__ == "__main__":` guarded — only runs locally
+- `@spaces.GPU` decorator no-ops when `Config.zero_gpu=False` (local)
+- `_patched_launch` uses `kwargs.setdefault()` — respects explicit local args, fills defaults on Space
+
+---
+
+## Space Variables (set via `hf spaces variables`)
+
+| Variable | Value | Purpose |
+|----------|-------|---------|
+| `GRADIO_SSR_MODE` | `False` | Disables SSR to prevent Node.js crash |
+| `CHIEF_ENGINEER_BACKEND` | `zerogpu` | Enables live inference path |
+| `CHIEF_ENGINEER_HF_MODEL` | `google/gemma-4-E2B-it` | Model for ZeroGPU inference |
+
+---
+
+## Requirements Strategy
+
+HF Spaces builds mount **only `requirements.txt`** to `/tmp/requirements.txt`. The `-r requirements-zerogpu.txt` pattern fails because the included file isn't mounted.
+
+**Solution:** ZeroGPU deps are **inlined** in `requirements.txt`:
+
+```txt
+# Core deps
+gradio>=6.17,<7
+ollama>=0.4
+pydantic>=2.7
+trimesh>=4.4
+shapely>=2.0
+
+# ZeroGPU deps (inlined — build mounts only requirements.txt)
+spaces>=0.30          # @spaces.GPU decorator
+torch>=2.4
+transformers>=4.49    # Gemma 3/4 family
+accelerate>=0.34
+```
+
+---
+
+## Code Changes in `app.py`
+
+### 1. Module-level `demo` for pySpaces
+```python
+def build() -> gr.Blocks:
+    with gr.Blocks(title="The Chief Engineer") as demo:
+        # ... build UI ...
+    return demo
+
+demo = build()  # Module level — pySpaces finds this
+```
+
+### 2. `@spaces.GPU` on inference function
+```python
+import spaces
+
+@spaces.GPU
+def get_recommendation(part, material, description, temp, humidity, bed_position):
+    # Heavy inference — GPU allocated on call via ZeroGPU
+    ...
+```
+
+`import spaces` is wrapped in a `try/except` shim in `app.py`: when the package
+is absent (local base env / offline), `@spaces.GPU` no-ops and returns the function
+unchanged. On the Space, HF provides `spaces` and the real decorator allocates the GPU.
+
+### 3. Monkey-patch `demo.launch` for theme/CSS/head
+```python
+# After demo = build()
+_original_launch = demo.launch
+
+def _patched_launch(**kwargs):
+    kwargs.setdefault("theme", THEME)
+    kwargs.setdefault("css", CSS)
+    kwargs.setdefault("head", VP_HEAD)
+    kwargs.setdefault("ssr_mode", False)
+    return _original_launch(**kwargs)
+
+demo.launch = _patched_launch
+```
+
+- **Local:** `__main__` calls `demo.launch(ssr_mode=False, server_name="0.0.0.0", ...)` → explicit args win
+- **Space:** pySpaces calls `demo.launch()` → `setdefault()` injects THEME/CSS/VP_HEAD/ssr_mode
+
+### 4. Guarded `__main__` for local dev only
+```python
+if __name__ == "__main__":
+    print(f"[chief-engineer] {llm.backend_status()} | seeded {_loaded} lessons this run")
+    demo.launch(ssr_mode=False, server_name="0.0.0.0", server_port=7860, share=False)
+```
+
+Runs locally; skipped on Space (pySpaces imports module, `__name__ != "__main__"`).
+
+---
+
+## Build & Deploy Commands
+
+```bash
+# From chief-engineer/
+hf upload build-small-hackathon/microfactory-lab ./app.py app.py --repo-type space
+hf upload build-small-hackathon/microfactory-lab ./requirements.txt requirements.txt --repo-type space
+
+# Set variables (triggers rebuild)
+hf spaces variables add build-small-hackathon/microfactory-lab \
+  -e GRADIO_SSR_MODE=False \
+  -e CHIEF_ENGINEER_BACKEND=zerogpu \
+  -e CHIEF_ENGINEER_HF_MODEL=google/gemma-4-E2B-it
+
+# Factory reboot if needed
+hf spaces restart build-small-hackathon/microfactory-lab --factory-reboot
+```
+
+---
+
+## Local Development
+
+```bash
+# In chief-engineer/
+make setup      # uv sync + generate assets
+ollama serve &  # For live Gemma (optional; fallback works offline)
+make run        # uv run python app.py → http://localhost:7860
+```
+
+- Full Astrometrics theme applied via monkey-patch defaults
+- Falls back to deterministic advisor if Ollama unavailable
+- All core tests pass offline: `uv run python test_core.py`
+
+---
+
+## Pre-flight / Verification
+
+```bash
+# Core tests (offline, fast)
+uv run python test_core.py
+
+# Preflight (needs Ollama for live path)
+uv run python -m scripts.preflight
+
+# Space logs
+hf spaces logs build-small-hackathon/microfactory-lab --tail 30
+hf spaces logs build-small-hackathon/microfactory-lab --build --tail 30
+```
+
+---
+
+## Troubleshooting
+
+| Symptom | Cause | Fix |
+|---------|-------|-----|
+| `RUNTIME_ERROR` + "No @spaces.GPU function detected" | Missing GPU decorator on zero-a10g | Add `@spaces.GPU` to at least one function |
+| SSR crash ("Stopping Node.js server...") | Gradio 6 SSR incompatible | Set `GRADIO_SSR_MODE=False` + `ssr_mode=False` |
+| Theme/CSS missing on Space | pySpaces calls `launch()` without args | Monkey-patch `demo.launch` with `setdefault()` |
+| Build fails: "No such file: requirements-zerogpu.txt" | `-r` not mounted | Inline deps in `requirements.txt` |
+| 503 on zero-a10g, works on cpu-basic | Hardware-specific SSR/GPU issue | Apply SSR fix + `@spaces.GPU` |
+| "ModuleNotFoundError: spaces" locally | ZeroGPU package not installed | None needed — `app.py` shims `spaces` to a no-op when absent. Install the real path only to test ZeroGPU locally: `uv sync --extra zerogpu`. |
+
+---
+
+## Model Details
+
+- **Model:** `google/gemma-4-E2B-it` (Gemma 4, Efficient 2B, instruction-tuned)
+- **Parameters:** ~2 billion (E2B = Efficient 2B)
+- **License:** Apache 2.0 — **not gated**, no `HF_TOKEN` needed
+- **Architecture:** Dense, multimodal (text + image), 128K context
+- **Endpoint:** Loaded on first `analyze` call via ZeroGPU
+
+---
+
+## File Tree (Space Root)
+
+```
+build-small-hackathon/microfactory-lab/
+├── app.py                    # Entry point (demo = build())
+├── README.md                 # Space metadata (sdk: gradio, sdk_version: 6.17.3)
+├── requirements.txt          # All deps inlined
+├── assets/                   # .glb meshes (benchy, bridge, cube, overhang, vase)
+├── core/                     # Core library (llm, ledger, spine, widgets, viewer, etc.)
+├── learn/                    # Policy learning loop
+├── ingest/                   # Config distillation (Klipper/Prusa/Marlin)
+├── sim/                      # Virtual printer + outcome simulator
+├── scripts/                  # Helpers (preflight, bench, demo, capture)
+├── data/                     # seed_lessons.jsonl (gitignored: lessons.jsonl, policy.json)
+└── test_core.py              # Offline core tests
+```
+
+---
+
+## Key Files for Future Maintenance
+
+| File | Purpose |
+|------|---------|
+| `app.py` | Space entry point + local launch |
+| `core/llm.py` | Backend abstraction (Ollama / ZeroGPU / fallback) |
+| `core/llm_zerogpu.py` | ZeroGPU transformers path |
+| `core/chief_engineer.py` | Brain: precedent eval + settings proposal |
+| `core/spine.py` | Deterministic veto (material bounds) |
+| `learn/policy.py` | Learned parametric policy (env-bucketed) |
+| `core/theme.py` | Astrometrics THEME + CSS + VP_HEAD |
+| `scripts/preflight.py` | GO/NO-GO gate for releases |
+
+---
+
+## Next Steps / Frontiers
+
+- [ ] Weight-level fine-tuning on accumulated ledger (named "Well-Tuned" — currently not built)
+- [ ] Real distributed multi-node execution (currently single Space)
+- [ ] Physical interfaces: g-code streaming, env sensors, camera defect CV
+- [ ] Larger Gemma variants (E4B, 26B A4B, 31B) on larger GPUs
+
+---
+
+*Last updated: 2026-06-11 — Space live on zero-a10g with ZeroGPU Gemma 4 E2B*

README.md

@@ -52,9 +52,9 @@ outcome comes from outside the model. The honest signal is what makes the compou
 prior jobs the LLM reasons over) and a **learned parametric policy** (`learn/policy.py`) that stores
 setting offsets per (material, geometry, *environment-bucket*) and updates from each outcome. Because
 cells are bucketed, a lesson from one humid PETG bridge **generalizes** to the next, not-identical
-one. The **Learning Loop** tab runs the closed loop live: pick a hard job and watch print quality
-climb from failure to clean over a handful of iterations. The one simulated boundary (print
-outcomes) is spelled out in *What's real vs frontier* below.
+one. The **Print** workspace runs the closed loop live on the job you built: watch print quality
+climb from failure to clean over a handful of iterations while a separate QA Inspector grades each
+run. The one simulated boundary (print outcomes) is spelled out in *What's real vs frontier* below.
 
 ## Run it (fully local, no cloud, no API key)
 
@@ -71,10 +71,14 @@ Local dev uses [uv](https://docs.astral.sh/uv); the HF Space installs via `requi
 and the simulator / learning-loop / ingestion packages in `sim/`, `learn/`, `ingest/`. See
 `docs/RUNBOOK.md` for the full run-and-test order of operations.
 
+**HF Space Deployment:** See [`DEPLOYMENT.md`](DEPLOYMENT.md) for the complete guide covering
+Space variables, dual-config architecture (local + Space), build strategy, troubleshooting, and
+the key code changes (`@spaces.GPU`, monkey-patched `demo.launch`, module-level `demo`).
+
 Falls back to a deterministic advisor if Ollama is unreachable, so the demo never crashes; the
 UI always shows which model ran. Set `CHIEF_ENGINEER_MODEL=gemma4:e2b` if CPU latency is high.
 
-**Resetting demo state.** The Learning Loop and the 🧪 *Simulate outcome* button accumulate runtime
+**Resetting demo state.** The Print loop and the 🧪 *Simulate one print* button accumulate runtime
 state — earned/sim lessons in `data/lessons.jsonl` and the learned cells in `data/policy.json` (both
 gitignored). For a clean slate between demos:
 
@@ -82,18 +86,26 @@ gitignored). For a clean slate between demos:
 rm -f data/lessons.jsonl data/policy.json   # seed corpus reloads automatically on next launch
 ```
 
-## Workspaces
-
-1. **Studio** — define the job: pick a reference part type, quick-load 3DBenchy, generate a
-   primitive, or upload a mesh; choose material; set run conditions. Live 3D preview + a
-   layer-by-layer *virtual print* of the actual part.
-2. **Analysis** — the load-bearing moment, on its own page: the model's precedent evaluation and
-   reasoning, predicted failure regions, the Spine-validated settings + G-code as instrument
-   readouts, then close the loop (🧪 *Simulate outcome* or record a real one).
-3. **Learning Loop** — the compounding made literal: run the closed simulated loop and watch the
-   quality curve climb while the learned policy cell fills in.
-4. **Knowledge + Mesh** — the node mesh (one node executes, others as context) and the live ledger
-   where lessons accumulate (seed → earned → sim).
+## Workspaces — the real print workflow
+
+1. **Studio** — define + preview the job: quick-load 3DBenchy, generate a primitive, or drop a
+   mesh (the engineer *infers* the part class itself — you don't pick it); choose material; the
+   simulated **environment** (temp/humidity/plate position on a Creality Ender 3 V2) populates.
+2. **Build** — the pre-flight check, **before it prints**: the slicer / layer-by-layer virtual
+   print, the engineer's precedent read + reasoning + predicted failure regions, the Spine-validated
+   settings + G-code (terminal readout), and a **second opinion** from a separate QA Inspector.
+3. **Print** — run *this* job through the closed loop and watch quality compound fail→clean: the
+   Engineer proposes → the Spine vetoes → a simulated world prints → the **Inspector grades each
+   run** → policy + ledger learn. Simulate one print, or record a real outcome.
+4. **Review** — the compounding made visible: the live ledger (seed → earned → sim), the capability
+   mesh, and the Inspector's verdict on the whole run.
+
+**The hybrid evaluator (honest by design).** The Engineer never grades its own work. The
+deterministic world (`sim/outcome.py`) produces the ground-truth pass/fail; a *separate* **QA
+Inspector** persona (`core/inspector.py`) reads what the Engineer claimed vs what actually
+happened and writes the verdict — a second opinion in **Build**, a per-print grade in **Print**,
+a run verdict in **Review**. Physics + a skeptical second voice — never the proposer marking its
+own homework.
 
 ## Badges
 

app.py

@@ -16,33 +16,43 @@ from __future__ import annotations
 import random
 
 import gradio as gr
-import spaces
 
+try:
+    import spaces  # ZeroGPU @spaces.GPU decorator — HF-provided on the Space.
+except ImportError:  # not installed locally (base env / offline); decorator no-ops.
+    class _SpacesShim:
+        @staticmethod
+        def GPU(fn=None, **_kw):
+            return fn if fn is not None else (lambda f: f)
+
+    spaces = _SpacesShim()  # type: ignore
+
+from core import inspector
 from core import llm
 from core import seed_lessons
-from core.theme import THEME, CSS, rule, command_bar, footer_bar
+from core.theme import THEME, CSS, rule, command_bar, footer_bar, inspector_panel
 from core.widgets import virtual_printer_html, layer_image, SCRUB_LAYERS, VP_HEAD
 from core.chief_engineer import advise
 from core.ledger import LedgerManager
-from core.models import BED_POSITIONS, Environment, GEOMETRY_TYPES, Job, MATERIALS, PrintSettings
+from core.models import Advice, BED_POSITIONS, Environment, Job, MATERIALS, PrintSettings
 from core.nodes import render_node_cards
 from core.reflect import reflect_on_job
 from core.spine import SpineValidator
-from learn.loop import run_iteration, run_session
+from learn.loop import run_session
 from learn.policy import LearnedPolicy, cell_key
 from sim.outcome import simulate
 from core.viewer import (
-    PART_LABEL,
+    GEO_READS,
     benchy_mesh,
     gcode_panel_html,
     generate_primitive,
+    infer_geometry,
     iteration_log_html,
     placement_callout,
     policy_cell_html,
     precedent_eval_html,
     quality_curve_html,
     risk_callouts_html,
-    sample_mesh,
     settings_panel_html,
     steepest_overhang_hint,
 )
@@ -84,46 +94,46 @@ def ledger_html() -> str:
     return head + "".join(rows)
 
 
-_DEFAULT_PART = {"geometry": "overhang", "mesh": sample_mesh("overhang"), "label": "OVERHANG TEST"}
-
-
-def _set_part(geometry: str, mesh, label: str):
-    """Shared STUDIO preview update → (part_state, model3d, status). The virtual
-    print is NOT rendered here — it initializes on ANALYZE (see get_recommendation),
-    so it doesn't loop perpetually on the Studio preview."""
+def _set_part(geometry: str, mesh, label: str, read: str | None = None):
+    """Shared STUDIO preview update → (part_state, model3d, status). The user never
+    picks the class — the engineer infers it from the mesh (see infer_geometry).
+    The virtual print is NOT rendered here; it initializes on BUILD."""
+    read = read or GEO_READS.get(geometry, geometry)
     return (
-        {"geometry": geometry, "mesh": mesh, "label": label},
+        {"geometry": geometry, "mesh": mesh, "label": label, "read": read},
         gr.update(value=mesh),
-        f"▣ ACTIVE PART · **{label}** · class `{geometry}`",
+        f"▣ ACTIVE PART · **{label}** · the engineer reads this as *{read}* → reasons about `{geometry}`",
     )
 
 
-def analyze_start(part):
-    """Immediate feedback the instant ANALYZE is clicked: jump to the Analysis tab
-    and show spinners while the model runs (e4b warm ~15-20s on CPU). The heavy
-    get_recommendation runs right after via .then(). No part selected → stay put."""
+def build_start(part):
+    """Immediate feedback the instant BUILD is clicked: jump to the Build tab and
+    show spinners while the model runs (e4b warm ~15-20s on CPU). The heavy
+    build_job runs right after via .then(). No part loaded → stay put."""
     if not (part and part.get("geometry")):
-        gr.Warning("Select a part in Studio first — pick a type, load Benchy, generate, or upload.")
-        return (gr.update(),) * 7
+        gr.Warning("Load a part in Studio first — quick-load Benchy, generate a primitive, or drop a mesh.")
+        return (gr.update(),) * 10
     return (
-        gr.Tabs(selected="analysis"),
-        "⏳ **Analyzing the job** — evaluating precedent and proposing settings…",   # reasoning
+        gr.Tabs(selected="build"),
+        "⏳ **Building the job** — evaluating precedent and proposing settings…",      # reasoning
         "<div class='ce-sub'>⏳ retrieving precedent…</div>",                          # precedent
         "",                                                                           # risks
         "",                                                                           # settings_html
         "",                                                                           # gcode_html
         "<div class='ce-sub'>⏳ slicing the part…</div>",                             # vprint
+        "",                                                                           # second_opinion_panel (clear stale verdict)
+        gr.update(interactive=True),                                                  # to_print_btn (un-gate)
+        gr.update(visible=False),                                                     # override_btn (hide)
     )
 
 
-def select_type(geo):                       # reference part-type pill chosen
-    return _set_part(geo, sample_mesh(geo), PART_LABEL.get(geo, geo.upper()))
-
-
 def load_benchy():
     mesh = benchy_mesh()
-    label = "3DBENCHY (CC0)" if mesh else "BENCHY MISSING — add assets/benchy.glb"
-    return _set_part("overhang", mesh, label)
+    if not mesh:
+        return ({"geometry": None, "mesh": None, "label": None, "read": None},
+                gr.update(value=None), "▣ **BENCHY MISSING** — add assets/benchy.glb")
+    geo, read = infer_geometry(mesh)
+    return _set_part(geo, mesh, "3DBENCHY (CC0)", read)
 
 
 def generate_part(kind, size):
@@ -133,9 +143,10 @@ def generate_part(kind, size):
 
 def upload_part(f):
     if not f:
-        return (gr.update(), gr.update(), gr.update(), gr.update())
+        return (gr.update(), gr.update(), gr.update())
     from pathlib import Path as _P
-    return _set_part("overhang", f.name, f"UPLOAD · {_P(f.name).name[:26]}")
+    geo, read = infer_geometry(f.name)
+    return _set_part(geo, f.name, f"UPLOAD · {_P(f.name).name[:26]}", read)
 
 
 def scrub_layer(idx, part):
@@ -144,15 +155,28 @@ def scrub_layer(idx, part):
     return layer_image(mesh, idx)
 
 
-# ── simulated sensors (this is a sim lab — conditions are generated, overridable) ──
+# ── simulated environment (this is a sim lab — conditions are generated, overridable) ──
+PRINTER = "Creality Ender 3 V2"
+
+
 def _sensor_readout(t, h, pos) -> str:
-    return ("<div class='ce-sub' style='font-size:13px;'>SIMULATED SENSORS · "
+    return ("<div class='ce-sub' style='font-size:13px;'>ENVIRONMENT (SIMULATED) · "
             f"🌡 <b style='color:var(--ao-blue);'>{float(t):.0f}°C</b> · "
             f"💧 <b style='color:var(--ao-blue);'>{float(h):.0f}%RH</b> · "
-            f"⌖ <b style='color:var(--ao-blue);'>{pos}</b> "
+            f"⌖ <b style='color:var(--ao-blue);'>{pos}</b> · "
+            f"🖨 <b style='color:var(--ao-outline);'>{PRINTER}</b> "
             "<span style='opacity:.6;'>(🎲 re-roll or ⚙ override)</span></div>")
 
 
+def status_footer(part, material, t, h, pos):
+    """Live job context for the sticky footer strip."""
+    p = part or {}
+    label = p.get("label") or "no part"
+    geo = p.get("geometry") or "—"
+    return footer_bar(job=f"{label} · {material} · {geo}",
+                      env=f"{float(t):.0f}°C / {float(h):.0f}%RH · {pos} · {PRINTER}")
+
+
 def randomize_sensors():
     """Roll a plausible ambient + plate position — the lab's simulated sensor feed."""
     t = random.choice([18, 20, 22, 24, 26, 28, 30, 32])
@@ -166,14 +190,14 @@ def sync_readout(t, h, pos):
 
 
 @spaces.GPU
-def get_recommendation(part, material, description, temp, humidity, bed_position):
+def build_job(part, material, description, temp, humidity, bed_position):
     if not (part and part.get("geometry")):   # guard: empty start, no part chosen
-        return ("", "", "⚠ **Select a part in Studio** (pick a type, load Benchy, generate, "
-                "or upload) before analyzing.", "", "", "", "", gr.update(visible=False),
+        return ("", "", "⚠ **Load a part in Studio** (quick-load Benchy, generate, "
+                "or drop a mesh) before building.", "", "", "", "", gr.update(visible=False),
                 gr.update(), {}, "", gr.update(), gr.update())
     geometry_type, mesh = part["geometry"], part.get("mesh")
     job = Job(geometry_type=geometry_type, material=material, description=description or "",
-              bed_position=bed_position or "center")
+              bed_position=bed_position or "center", mesh_path=mesh)
     env = Environment(temp=float(temp), humidity=float(humidity))
 
     retrieved = LEDGER.retrieve(material, geometry_type, env.temp, env.humidity)
@@ -182,7 +206,7 @@ def get_recommendation(part, material, description, temp, humidity, bed_position
     rec = advise(job, env, retrieved, references, policy_note)
     spine = SPINE.check(rec.advice.settings, material)
     hint = steepest_overhang_hint(mesh) if geometry_type in ("overhang", "bridge") else None
-    vp_html = virtual_printer_html(mesh, f"{material} · {geometry_type}")  # init on ANALYZE
+    vp_html = virtual_printer_html(mesh, f"{material} · {geometry_type}")  # init on BUILD
 
     precedent = precedent_eval_html(retrieved, env)
     if retrieved:
@@ -199,7 +223,8 @@ def get_recommendation(part, material, description, temp, humidity, bed_position
     confirm_vis = gr.update(visible=spine.requires_approval)
     approval_md = ("⏸ **HITL gate:** the Spine clamped a boundary setting — review, then **Confirm & Print**."
                    if spine.requires_approval else "✅ within safe envelope — ready when you are.")
-    state = {"job": job.model_dump(), "env": env.model_dump(), "settings": spine.settings.model_dump()}
+    state = {"job": job.model_dump(), "env": env.model_dump(), "settings": spine.settings.model_dump(),
+             "advice": rec.advice.model_dump(), "label": part.get("label")}
 
     return (
         f"{rec.backend}{fb}",                                          # backend status
@@ -218,63 +243,134 @@ def get_recommendation(part, material, description, temp, humidity, bed_position
     )
 
 
-def run_learning(material, geometry_type, temp, humidity, iterations):
-    """Primary demo: run the closed simulated loop and watch quality compound."""
-    job = Job(geometry_type=geometry_type, material=material, description="")
-    env = Environment(temp=float(temp), humidity=float(humidity))
+def second_opinion(state):
+    """BUILD: a SEPARATE Inspector persona critiques the plan before any print runs.
+    A 'dispute' verdict GATES → PRINT until the objection is acknowledged; 'caution'
+    and 'concur' are advisory (Print stays open)."""
+    if not state or "advice" not in state:
+        return ("<div class='ce-sub'>Build a job first — then I'll give the plan a second look.</div>",
+                gr.update(interactive=True), gr.update(visible=False))
+    job = Job(**state["job"])
+    env = Environment(**state["env"])
+    settings = PrintSettings(**state["settings"])
+    advice = Advice(**state["advice"])
+    verdict = inspector.second_opinion(job, env, settings, advice)
+    panel = inspector_panel(verdict, label="QA INSPECTOR · SECOND OPINION (PRE-PRINT)")
+    if verdict.stance.lower() == "dispute":
+        panel += ("<div style='margin-top:6px;padding:6px 10px;border-left:3px solid var(--ao-red,#d9534f);"
+                  "background:var(--ao-surface);font-family:ui-monospace,monospace;font-size:12px;"
+                  "color:var(--ao-text);'>⛔ <b>The Inspector disputes this plan.</b> → PRINT is held. "
+                  "Review the objection, then acknowledge to proceed anyway.</div>")
+        return panel, gr.update(interactive=False), gr.update(visible=True)
+    return panel, gr.update(interactive=True), gr.update(visible=False)
+
+
+def ack_override():
+    """Human overrides the Inspector's dispute — re-open → PRINT (on the operator's call)."""
+    return gr.update(interactive=True), gr.update(visible=False)
+
+
+def job_readout(state):
+    """The job Print inherits from Studio/Build (no re-picking — it prints THIS job)."""
+    if not state or "job" not in state:
+        return ("<div class='ce-sub'>No job built yet. Go to <b>Studio</b> → define a part → "
+                "<b>Build</b>, then return here to print it.</div>")
+    j, e = state["job"], state["env"]
+    return (f"<div class='ce-sub' style='font-size:13px;'>PRINTING · "
+            f"<b style='color:var(--ao-orange);'>{state.get('label') or j['geometry_type']}</b> · "
+            f"{j['material']}/{j['geometry_type']} · ⌖ {j.get('bed_position','center')} · "
+            f"🌡 {e['temp']:.0f}°C / 💧 {e['humidity']:.0f}%RH · 🖨 {PRINTER}</div>")
+
+
+def run_print(state, iterations):
+    """PRINT: run THIS job (inherited from Build) through the closed loop. Each
+    iteration: policy proposes → Spine vetoes → the deterministic world prints →
+    the Inspector grades that outcome → policy + ledger learn. Quality compounds."""
+    if not state or "job" not in state:
+        gr.Warning("Build a job first (Studio → Build), then print it here.")
+        return (gr.update(),) * 7
+    job = Job(**state["job"])
+    env = Environment(**state["env"])
+    material, geometry_type = job.material, job.geometry_type
     key = cell_key(material, geometry_type, env)
-    before = POLICY.cell_stats(material, geometry_type, env)
-    before_html = policy_cell_html(before, key)
+    before_html = policy_cell_html(POLICY.cell_stats(material, geometry_type, env), key)
 
     sess = run_session(job, env, int(iterations), POLICY, LEDGER)
     after = POLICY.cell_stats(material, geometry_type, env)
+    verdicts = [inspector.grade_iteration(geometry_type, r.result) for r in sess.records]
+    run_summary = inspector.summarize_run(sess.records, material=material, geometry=geometry_type)
 
     traj = sess.trajectory
     first = sess.first_success
     headline = (
-        f"**{material}/{geometry_type} @ {env.temp:.0f}°C / {env.humidity:.0f}% RH** — "
+        f"**{state.get('label') or geometry_type} · {material} @ {env.temp:.0f}°C / {env.humidity:.0f}% RH** — "
         f"started at quality **{traj[0]:.2f}** ({sess.records[0].result.outcome}); "
         + (f"first clean print at **iteration {first}**, now **{traj[-1]:.2f}**."
            if first else f"still improving — best **{max(traj):.2f}** after {len(traj)} runs.")
-        + " The model proposed; a separate simulated world reported the outcome; "
-        "the policy and ledger learned from it. *(Simulated — see SIMULATION.md.)*"
+        + " The Engineer proposed; a separate simulated world reported the outcome; the **Inspector** "
+        "graded each run; the policy and ledger learned. *(Simulated — see SIMULATION.md.)*"
     )
     policy_html = (f"{before_html}<div style='text-align:center;color:var(--ao-orange);'>▼ learned ▼</div>"
                    f"{policy_cell_html(after, key)}")
     return (
-        headline,                                   # l_headline
-        quality_curve_html(traj),                   # l_curve
-        policy_html,                                # l_policy
-        iteration_log_html(sess.records),           # l_log
-        ledger_html(),                              # ledger_panel
-        render_node_cards(env, working=False),      # node_cards
+        headline,                                                # p_headline
+        quality_curve_html(traj),                                # p_curve
+        policy_html,                                             # p_policy
+        iteration_log_html(sess.records, verdicts),              # p_log (with inspector grades)
+        ledger_html(),                                           # ledger_panel
+        render_node_cards(env, working=False),                   # node_cards
+        inspector_panel(run_summary, label="QA INSPECTOR · RUN VERDICT"),  # review_summary
     )
 
 
 def simulate_outcome(state):
-    """Analysis: close the loop in the world (deterministic), then learn from it."""
-    if not state:
-        return "Run a recommendation first.", ledger_html()
+    """PRINT (single print): close the loop once in the deterministic world, present
+    the full outcome — what was simulated, what the model did, the physics pass/fail —
+    then the Inspector (hybrid evaluator) grades it. The model never grades itself."""
+    if not state or "job" not in state:
+        gr.Warning("Build a job first (Studio → Build), then print it here.")
+        return gr.update(), ledger_html(), render_node_cards(Environment(temp=22, humidity=45))
     job = Job(**state["job"])
     env = Environment(**state["env"])
     settings = PrintSettings(**state["settings"])
+    advice = Advice(**state["advice"]) if "advice" in state else Advice(
+        reasoning="(no engineer prediction on file)", settings=settings, risks=[])
     result = simulate(settings, job, env)
+    verdict = inspector.grade_outcome(job, env, settings, advice, result)
     learned = POLICY.update(job.material, job.geometry_type, env, result)
     POLICY.save()
-    # record the simulated outcome to the ledger as precedent
     from learn.loop import _record_lesson
     _record_lesson(job, env, settings, result, LEDGER)
-    icon = "✓" if result.outcome == "success" else "✗"
-    return (
-        f"🧪 **Simulated world** (stand-in for printer + sensors): {icon} **{result.detail}**.  \n"
-        f"↳ policy update: *{learned}*  \n*(The model never saw this outcome in advance — SIMULATION.md.)*",
-        ledger_html(),
+
+    passed = result.outcome == "success"
+    badge_col = "var(--ao-green)" if passed else "var(--ao-red)"
+    badge = "PASS" if passed else "FAIL"
+    s = settings
+    panel = (
+        "<div style='font-family:ui-monospace,monospace;background:var(--ao-void);"
+        "border:1px solid var(--ao-outline-dim);padding:10px 12px;'>"
+        f"<div style='color:var(--ao-orange);font-weight:700;letter-spacing:2px;font-size:11px;'>"
+        "🧪 PRINT OUTCOME <span style='color:var(--ao-outline);font-weight:400;'>"
+        "(deterministic world — stand-in for printer + sensors)</span></div>"
+        f"<div class='ce-sub' style='margin-top:6px;'>WHAT WAS SIMULATED · {job.material}/{job.geometry_type} "
+        f"· ⌖ {job.bed_position} · {env.temp:.0f}°C/{env.humidity:.0f}%RH · {PRINTER}</div>"
+        f"<div class='ce-sub'>WHAT THE MODEL DID · nozzle {s.nozzle_temp:.0f}°C, bed {s.bed_temp:.0f}°C, "
+        f"fan {s.fan_pct:.0f}%, retraction {s.retraction_mm:.1f}mm · "
+        f"flagged: {', '.join(r.risk for r in advice.risks) or 'none'}</div>"
+        f"<div style='margin-top:6px;font-size:15px;'>PRINT RESULT · "
+        f"<span style='color:{badge_col};font-weight:700;'>[{badge}] {result.detail}</span></div>"
+        "</div>"
     )
+    panel += inspector_panel(verdict, label="QA INSPECTOR · GRADE")
+    panel += (f"<div class='ce-sub' style='margin-top:6px;'>↳ policy update: <i>{learned}</i> · "
+              "lesson written to the ledger. <i>(The model never saw this outcome in advance.)</i></div>")
+    return panel, ledger_html(), render_node_cards(env, working=False)
 
 
 def record_outcome(outcome, state):
-    if not state:
-        return "Run a recommendation first.", ledger_html(), render_node_cards(Environment(temp=22, humidity=45))
+    if not state or "job" not in state:
+        gr.Warning("Build a job first (Studio → Build), then record an outcome here.")
+        return gr.update(), ledger_html(), render_node_cards(Environment(temp=22, humidity=45))
     job = Job(**state["job"])
     env = Environment(**state["env"])
     settings = PrintSettings(**state["settings"])
@@ -297,124 +393,123 @@ def build() -> gr.Blocks:
             "and tells you where a print fails <b>before</b> it runs · gemma4 · fully local</div>"
         )
         state = gr.State()
-        part = gr.State({"geometry": None, "mesh": None, "label": None})
+        part = gr.State({"geometry": None, "mesh": None, "label": None, "read": None})
 
         with gr.Tabs() as tabs:
-            # ─────────────────────────── STUDIO (define) ─��─────────────────────────
+            # ───────────────────────── STUDIO · define + preview ─────────────────────
             with gr.Tab("⬡ STUDIO", id="studio"):
-                gr.HTML("<div class='ce-sub'>DEFINE THE JOB · ① part → ② material → "
-                        "③ conditions → <b>ANALYZE</b></div>")
+                gr.HTML("<div class='ce-sub'>① ENVIRONMENT · ② MATERIAL · ③ PART → "
+                        "<b>BUILD</b> (slice + the engineer's pre-flight read)</div>")
+                run_btn = gr.Button("→ BUILD JOB", variant="primary", elem_id="ce-run")
+
+                gr.HTML(rule("① ENVIRONMENT (SIMULATED)"))
+                sensors_readout = gr.HTML()
                 with gr.Row():
-                    with gr.Column(scale=2, elem_classes=["ce-console"]):
-                        gr.HTML(rule("① SELECT PART"))
-                        gr.HTML("<div class='ce-sub'>REFERENCE PART TYPE — what the engineer reasons about</div>")
-                        type_radio = gr.Radio(GEOMETRY_TYPES, value=None, show_label=False,
-                                              elem_classes=["ce-pills"])
-                        gr.HTML("<div class='ce-sub' style='margin-top:6px;'>OR LOAD A MODEL</div>")
-                        with gr.Row():
-                            benchy_btn = gr.Button("⛴ QUICK-LOAD BENCHY", elem_classes=["ce-pillbtn"])
-                        with gr.Accordion("⚙ GENERATE A PRIMITIVE", open=False):
-                            gen_kind = gr.Radio(["box", "cylinder", "cone", "sphere"], value="box",
-                                                show_label=False, elem_classes=["ce-pills"])
-                            gen_size = gr.Number(value=30, label="SIZE (mm)", elem_classes=["ce-num"])
-                            gen_btn = gr.Button("GENERATE", elem_classes=["ce-pillbtn"])
-                        mesh_in = gr.File(file_types=[".stl", ".glb", ".obj"],
-                                          label="UPLOAD YOUR OWN MESH", elem_classes=["ce-drop"])
-                        part_status = gr.Markdown("▣ **no part selected** — pick a type, load Benchy, "
-                                                  "generate, or upload to begin")
+                    roll_btn = gr.Button("🎲 RANDOMIZE ENVIRONMENT", elem_classes=["ce-pillbtn"])
+                with gr.Accordion("⚙ OVERRIDE ENVIRONMENT", open=False):
+                    with gr.Row():
+                        temp = gr.Number(value=22, label="AMBIENT °C", elem_classes=["ce-num"])
+                        humidity = gr.Number(value=45, label="HUMIDITY %RH", elem_classes=["ce-num"])
+                    gr.HTML("<div class='ce-sub'>BUILD-PLATE POSITION — edges/corners run "
+                            "cooler → warp/adhesion risk</div>")
+                    bed_position = gr.Radio(BED_POSITIONS, value="center", show_label=False,
+                                            elem_classes=["ce-pills"])
+                    description = gr.Textbox(label="NOTES (OPTIONAL)",
+                                             placeholder="e.g. 45° bracket, 60mm tall")
 
+                with gr.Row():
+                    with gr.Column(scale=1, elem_classes=["ce-console"]):
                         gr.HTML(rule("② MATERIAL"))
                         material = gr.Radio(MATERIALS, value="PLA", show_label=False, elem_classes=["ce-pills"])
-
-                        gr.HTML(rule("③ SIMULATED SENSORS"))
-                        sensors_readout = gr.HTML()
-                        roll_btn = gr.Button("🎲 RANDOMIZE SENSORS", elem_classes=["ce-pillbtn"])
-                        with gr.Accordion("⚙ OVERRIDE SENSORS", open=False):
+                    with gr.Column(scale=3, elem_classes=["ce-console"]):
+                        gr.HTML(rule("③ PART"))
+                        part_status = gr.Markdown("▣ **no part loaded** — quick-load Benchy, generate a "
+                                                  "primitive, or drop a mesh. *The engineer infers the part "
+                                                  "class itself — you don't pick it.*")
+                        with gr.Row():
+                            benchy_btn = gr.Button("⛴ QUICK-LOAD BENCHY", elem_classes=["ce-pillbtn"])
+                            mesh_in = gr.File(file_types=[".stl", ".glb", ".obj"],
+                                              label="DROP / UPLOAD MESH", elem_classes=["ce-drop"])
+                        with gr.Accordion("⚙ GENERATE A PRIMITIVE", open=False):
                             with gr.Row():
-                                temp = gr.Number(value=22, label="AMBIENT °C", elem_classes=["ce-num"])
-                                humidity = gr.Number(value=45, label="HUMIDITY %RH", elem_classes=["ce-num"])
-                            gr.HTML("<div class='ce-sub'>BUILD-PLATE POSITION — edges/corners run "
-                                    "cooler → warp/adhesion risk</div>")
-                            bed_position = gr.Radio(BED_POSITIONS, value="center", show_label=False,
-                                                    elem_classes=["ce-pills"])
-                            description = gr.Textbox(label="NOTES (OPTIONAL)",
-                                                     placeholder="e.g. 45° bracket, 60mm tall")
-                        run_btn = gr.Button("▶ ANALYZE JOB", variant="primary")
-                    with gr.Column(scale=3):
-                        gr.HTML(rule("PART PREVIEW"))
-                        model3d = gr.Model3D(value=None, label="", height=320)
-                        gr.HTML("<div class='ce-sub'>Rotate/zoom the part. The layer-by-layer "
-                                "<b>virtual print</b> renders on the Analysis page when you ANALYZE.</div>")
+                                gen_kind = gr.Radio(["box", "cylinder", "cone", "sphere"], value="box",
+                                                    show_label=False, elem_classes=["ce-pills"])
+                                gen_size = gr.Number(value=30, label="SIZE (mm)", elem_classes=["ce-num"])
+                            gen_btn = gr.Button("GENERATE", elem_classes=["ce-pillbtn"])
+                        model3d = gr.Model3D(value=None, label="", height=340)
 
-            # ─────────────────────────── ANALYSIS (results) ────────────────────────
-            with gr.Tab("◇ ANALYSIS", id="analysis"):
+            # ───────────────── BUILD · slice + analyze + pre-flight check ─────────────
+            with gr.Tab("◇ BUILD", id="build"):
                 backend = gr.Markdown()
-                gr.HTML("<div class='ce-sub'>① the engineer's read → ② validated settings + "
-                        "g-code → ③ virtual print → ④ close the loop</div>")
+                gr.HTML("<div class='ce-sub'>SLICE + the engineer's read — the <b>pre-flight check, "
+                        "before it prints</b>. Confirm, get a second opinion, then → PRINT.</div>")
                 with gr.Row():
-                    with gr.Column():
-                        gr.HTML(rule("① PRECEDENT EVALUATION"))
+                    with gr.Column(scale=3):
+                        gr.HTML(rule("VIRTUAL PRINT / SLICER"))
+                        vprint = gr.HTML()
+                        gr.HTML("<div class='ce-sub'>Slide through the layers — each is a real "
+                                "cross-section of <i>this</i> part at full mesh fidelity.</div>")
+                        vp_slider = gr.Slider(1, SCRUB_LAYERS, value=1, step=1, label="LAYER")
+                        vp_layer = gr.Image(label="", height=360, show_label=False)
+                    with gr.Column(scale=2):
+                        gr.HTML(rule("THE ENGINEER'S READ"))
                         precedent = gr.HTML(elem_id="ce-precedent")
-                        gr.HTML(rule("ENGINEER'S REASONING"))
                         reasoning = gr.Markdown(elem_id="ce-reasoning")
-                        gr.HTML(rule("PREDICTED FAILURE REGIONS"))
                         risks = gr.HTML()
+                gr.HTML(rule("VALIDATION + G-CODE"))
+                with gr.Row(elem_classes=["ce-console"]):
                     with gr.Column():
-                        gr.HTML(rule("② VALIDATION + G-CODE"))
                         spine_notes = gr.Markdown()
                         settings_html = gr.HTML()
+                    with gr.Column():
                         gcode_html = gr.HTML()
-                        confirm_btn = gr.Button("✅ Confirm & Print", elem_id="ce-confirm", visible=False)
-                gr.HTML(rule("③ VIRTUAL PRINT"))
-                vprint = gr.HTML()
-                gr.HTML("<div class='ce-sub'>Slide through the layers — each is a real "
-                        "cross-section of <i>this</i> part at full mesh fidelity.</div>")
-                vp_slider = gr.Slider(1, SCRUB_LAYERS, value=1, step=1, label="LAYER")
-                vp_layer = gr.Image(label="", height=380, show_label=False)
-                gr.HTML(rule("④ CLOSE THE LOOP"))
-                gr.HTML("<div class='ce-sub'>Simulate the print (deterministic stand-in for printer + "
-                        "sensors), or record a real outcome. Either way the model never grades itself.</div>")
-                with gr.Row(elem_id="ce-sim"):
-                    sim_btn = gr.Button("🧪 Simulate outcome (deterministic world)")
-                with gr.Row(elem_id="ce-outcomes"):
-                    b_clean = gr.Button("✓ Printed clean")
-                    b_sag = gr.Button("✗ Sagged")
-                    b_string = gr.Button("✗ Stringing")
-                outcome_msg = gr.Markdown()
-
-            # ─────────────────────────── LEARNING LOOP ─────────────────────────────
-            with gr.Tab("◳ LEARNING LOOP", id="loop"):
-                gr.HTML(
-                    "<div class='ce-sub'>THE COMPOUNDING LOOP · the model proposes → a <b>simulated world</b> "
-                    "reports the outcome → the <b>learned policy</b> and <b>ledger</b> update → the next run is "
-                    "better. Pick a hard job and watch quality climb from failure to clean. "
-                    "<i>Simulated; physical interfaces framed in SIMULATION.md.</i></div>"
-                )
+                confirm_btn = gr.Button("✅ Confirm & Print", elem_id="ce-confirm", visible=False)
+                gr.HTML(rule("SECOND OPINION"))
+                gr.HTML("<div class='ce-sub'>A separate <b>QA Inspector</b> persona reviews the plan "
+                        "before it prints — the Engineer is an optimist; the Inspector is not.</div>")
+                second_opinion_btn = gr.Button("🔍 GET A SECOND OPINION", elem_classes=["ce-pillbtn"])
+                second_opinion_panel = gr.HTML()
+                override_btn = gr.Button("⚠ I've reviewed the objection — print anyway",
+                                         visible=False, elem_classes=["ce-pillbtn"])
+                to_print_btn = gr.Button("→ PRINT (run iterations)", variant="primary")
+
+            # ──────────────────── PRINT · run it, iterate, grade ─────────────────────
+            with gr.Tab("◳ PRINT", id="print"):
+                gr.HTML("<div class='ce-sub'>Print <b>this job</b> (inherited from Build). Each run: the "
+                        "Engineer proposes → the Spine vetoes → a <b>simulated world</b> prints → the "
+                        "<b>Inspector grades</b> → policy + ledger learn. Quality compounds fail→clean. "
+                        "<i>Simulated; physical interfaces framed in SIMULATION.md.</i></div>")
+                p_job = gr.HTML(job_readout(None))
                 with gr.Row():
                     with gr.Column(scale=2, elem_classes=["ce-console"]):
-                        gr.HTML(rule("① SIMULATION CONTROLS"))
-                        l_geometry = gr.Radio(GEOMETRY_TYPES, value="bridge", show_label=False,
-                                              elem_classes=["ce-pills"])
-                        l_material = gr.Radio(MATERIALS, value="PETG", show_label=False, elem_classes=["ce-pills"])
-                        with gr.Row():
-                            l_temp = gr.Number(value=29, label="AMBIENT °C", elem_classes=["ce-num"])
-                            l_humidity = gr.Number(value=62, label="HUMIDITY %RH", elem_classes=["ce-num"])
-                        l_iters = gr.Slider(1, 16, value=8, step=1, label="ITERATIONS")
-                        l_run = gr.Button("▶ RUN SIMULATED LEARNING", variant="primary")
-                        l_headline = gr.Markdown()
+                        gr.HTML(rule("① RUN"))
+                        p_iters = gr.Slider(1, 16, value=8, step=1, label="ITERATIONS")
+                        p_run = gr.Button("▶ PRINT (RUN ITERATIONS)", variant="primary")
+                        sim_btn = gr.Button("🧪 SIMULATE ONE PRINT", elem_classes=["ce-pillbtn"])
+                        gr.HTML("<div class='ce-sub'>…or record a REAL outcome:</div>")
+                        with gr.Row(elem_id="ce-outcomes"):
+                            b_clean = gr.Button("✓ Printed clean")
+                            b_sag = gr.Button("✗ Sagged")
+                            b_string = gr.Button("✗ Stringing")
+                        p_headline = gr.Markdown()
                     with gr.Column(scale=3):
                         gr.HTML(rule("② QUALITY PER ITERATION"))
-                        l_curve = gr.HTML()
+                        p_curve = gr.HTML()
                         gr.HTML(rule("③ LEARNED POLICY CELL"))
-                        l_policy = gr.HTML()
+                        p_policy = gr.HTML()
+                gr.HTML(rule("SINGLE-PRINT OUTCOME + INSPECTOR GRADE"))
+                outcome_panel = gr.HTML()
                 gr.HTML(rule("④ ITERATION LOG"))
-                l_log = gr.HTML()
-
-            # ─────────────────────────── KNOWLEDGE + MESH ──────────────────────────
-            with gr.Tab("▤ KNOWLEDGE + MESH", id="ledger"):
-                gr.HTML("<div class='ce-sub'>The capability mesh (one node executes, the others "
-                        "stand by as context) and the live ledger where knowledge compounds "
-                        "(seed → earned → sim).</div>")
+                p_log = gr.HTML()
+
+            # ───────────────── REVIEW · compounding + agent verdicts ─────────────────
+            with gr.Tab("▤ REVIEW", id="review"):
+                gr.HTML("<div class='ce-sub'>The compounding made visible — the live ledger "
+                        "(seed → earned → sim), the capability mesh, and the <b>Inspector's verdict</b> "
+                        "on the whole run.</div>")
+                gr.HTML(rule("QA INSPECTOR · RUN VERDICT"))
+                review_summary = gr.HTML("<div class='ce-sub'>Run the Print loop to get the Inspector's "
+                                         "verdict on the whole run.</div>")
                 with gr.Row():
                     with gr.Column():
                         gr.HTML(rule("CAPABILITY MESH"))
@@ -424,39 +519,48 @@ def build() -> gr.Blocks:
                         ledger_panel = gr.HTML(ledger_html())
                 refresh = gr.Button("⟳ REFRESH LEDGER", elem_classes=["ce-pillbtn"])
 
-        gr.HTML(footer_bar())
+        footer = gr.HTML(footer_bar())
 
         # ── wiring ──
         preview_outs = [part, model3d, part_status]
-        type_radio.change(select_type, [type_radio], preview_outs)
-        benchy_btn.click(load_benchy, None, preview_outs)
-        gen_btn.click(generate_part, [gen_kind, gen_size], preview_outs)
-        mesh_in.upload(upload_part, [mesh_in], preview_outs)
+        foot_in = [part, material, temp, humidity, bed_position]
+        benchy_btn.click(load_benchy, None, preview_outs).then(status_footer, foot_in, [footer])
+        gen_btn.click(generate_part, [gen_kind, gen_size], preview_outs).then(status_footer, foot_in, [footer])
+        mesh_in.upload(upload_part, [mesh_in], preview_outs).then(status_footer, foot_in, [footer])
+        material.change(status_footer, foot_in, [footer])
 
-        # Simulated sensors: roll on load, re-roll on demand, keep the readout in sync.
+        # Simulated environment: roll on load, re-roll on demand, keep the readout + footer in sync.
         sensor_outs = [temp, humidity, bed_position, sensors_readout]
-        demo.load(randomize_sensors, None, sensor_outs)
-        roll_btn.click(randomize_sensors, None, sensor_outs)
+        demo.load(randomize_sensors, None, sensor_outs).then(status_footer, foot_in, [footer])
+        roll_btn.click(randomize_sensors, None, sensor_outs).then(status_footer, foot_in, [footer])
         for c in (temp, humidity, bed_position):
-            c.change(sync_readout, [temp, humidity, bed_position], [sensors_readout])
-
-        # Two-step ANALYZE: instant tab-switch + spinners, then the heavy model call.
-        analyze_outs = [backend, precedent, reasoning, risks, settings_html, spine_notes,
-                        gcode_html, confirm_btn, node_cards, state, vprint, vp_slider, vp_layer]
-        run_btn.click(analyze_start, [part],
-                      [tabs, reasoning, precedent, risks, settings_html, gcode_html, vprint]).then(
-                      get_recommendation, [part, material, description, temp, humidity, bed_position],
-                      analyze_outs)
+            c.change(sync_readout, [temp, humidity, bed_position], [sensors_readout]).then(
+                status_footer, foot_in, [footer])
+
+        # Two-step BUILD: instant tab-switch + spinners, then the heavy model call, then
+        # refresh the inherited-job readout on the Print tab.
+        build_outs = [backend, precedent, reasoning, risks, settings_html, spine_notes,
+                      gcode_html, confirm_btn, node_cards, state, vprint, vp_slider, vp_layer]
+        run_btn.click(build_start, [part],
+                      [tabs, reasoning, precedent, risks, settings_html, gcode_html, vprint,
+                       second_opinion_panel, to_print_btn, override_btn]).then(
+                      build_job, [part, material, description, temp, humidity, bed_position],
+                      build_outs).then(job_readout, [state], [p_job])
         vp_slider.change(scrub_layer, [vp_slider, part], [vp_layer])
-
+        second_opinion_btn.click(second_opinion, [state],
+                                 [second_opinion_panel, to_print_btn, override_btn])
+        override_btn.click(ack_override, None, [to_print_btn, override_btn])
+        to_print_btn.click(lambda: gr.Tabs(selected="print"), None, [tabs])
+        tabs.select(job_readout, [state], [p_job])
+
+        # PRINT: run the loop on THIS job, or a single print, or record a real outcome.
+        p_run.click(run_print, [state, p_iters],
+                    [p_headline, p_curve, p_policy, p_log, ledger_panel, node_cards, review_summary])
+        sim_btn.click(simulate_outcome, [state], [outcome_panel, ledger_panel, node_cards])
         for btn, oc in [(b_clean, "success"), (b_sag, "failed_sag"), (b_string, "failed_stringing")]:
-            btn.click(record_outcome, [gr.State(oc), state], [outcome_msg, ledger_panel, node_cards])
-        sim_btn.click(simulate_outcome, [state], [outcome_msg, ledger_panel])
+            btn.click(record_outcome, [gr.State(oc), state], [outcome_panel, ledger_panel, node_cards])
         refresh.click(lambda: ledger_html(), outputs=[ledger_panel])
 
-        l_run.click(run_learning, [l_material, l_geometry, l_temp, l_humidity, l_iters],
-                    [l_headline, l_curve, l_policy, l_log, ledger_panel, node_cards])
-
     return demo
 
 

core/inspector.py

@@ -0,0 +1,194 @@
+"""The QA Inspector — a SEPARATE reviewer persona (the hybrid evaluator).
+
+Integrity, restated: the Chief Engineer never grades its own work. The
+deterministic simulated world (`sim/outcome.py`) produces the ground-truth
+pass/fail. The Inspector is a *distinct* voice — skeptical, conservative —
+that reads what the Engineer claimed and what actually happened and writes a
+verdict. The grade is therefore "hybrid": deterministic physics + a second LLM
+opinion, never the proposer marking its own homework.
+
+One persona, three sets of rules depending on where it stands in the workflow:
+  • second_opinion(...)  — BUILD: critique the PLAN before any print runs.
+  • grade_outcome(...)   — PRINT: grade one finished (simulated) print vs the
+                           Engineer's prediction — did the called risk hold?
+  • summarize_run(...)   — REVIEW: one verdict across a whole iteration run.
+
+LLM-backed via `llm.chat_json` with a distinct system prompt; each mode has a
+deterministic fallback so the verdict is always present offline.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from . import llm
+from .models import Advice, Environment, Job, PrintSettings
+from sim.outcome import SimResult
+
+PERSONA = """You are the QA Inspector: a skeptical, conservative print-shop \
+inspector. You did NOT propose these settings — the Chief Engineer did, and the \
+Engineer is an optimist. Your job is to second-guess, not to please. You are \
+terse and physical. You never flatter. You call out optimism, thin margins, and \
+unflagged risks, and you give credit only when the evidence earns it."""
+
+# predicted-risk vocabulary → simulated failure_mode it corresponds to
+_RISK_TO_MODE = {
+    "sag": "sag", "stringing": "stringing", "adhesion": "adhesion",
+    "warping": "warp", "warp": "warp", "delamination": "under_extrusion",
+}
+_MODE_HUMAN = {
+    "sag": "sagging", "stringing": "stringing", "adhesion": "first-layer adhesion",
+    "warp": "warping", "under_extrusion": "under-extrusion", "none": "no failure",
+}
+
+
+@dataclass
+class InspectorVerdict:
+    stance: str                 # short label, e.g. "concur" / "caution" / "held" / "missed"
+    headline: str               # one-line verdict
+    detail: str                 # 1-2 lines of rationale
+    agreement: bool | None = None   # outcome modes: did the Engineer's prediction match reality?
+
+    @property
+    def color(self) -> str:
+        s = self.stance.lower()
+        if s in ("dispute", "missed", "fail"):
+            return "var(--ao-red, #d9534f)"
+        if s in ("caution", "overcautious", "watch"):
+            return "var(--ao-amber, #e0a458)"
+        return "var(--ao-green)"
+
+
+def _predicted_modes(advice: Advice) -> set[str]:
+    out: set[str] = set()
+    for r in advice.risks:
+        key = (r.risk or "").strip().lower()
+        out.add(_RISK_TO_MODE.get(key, key))
+    return out
+
+
+def _settings_line(s: PrintSettings) -> str:
+    return (f"nozzle {s.nozzle_temp:.0f}°C, bed {s.bed_temp:.0f}°C, fan {s.fan_pct:.0f}%, "
+            f"first-layer fan {s.first_layer_fan_pct:.0f}%, retraction {s.retraction_mm:.1f}mm")
+
+
+# ── BUILD: a second opinion on the plan, before anything prints ───────────────
+def second_opinion(job: Job, env: Environment, settings: PrintSettings, advice: Advice) -> InspectorVerdict:
+    raw = llm.chat_json(
+        PERSONA + "\n\nRespond ONLY with JSON: "
+        '{"stance":"concur|caution|dispute","headline":"<one line>","detail":"<1-2 lines>"}',
+        "Review this PLAN before it prints — do not re-propose, just critique.\n"
+        f"JOB: {job.material}/{job.geometry_type}, bed position {job.bed_position}, "
+        f"room {env.temp:.0f}°C/{env.humidity:.0f}%RH on a {env.printer}.\n"
+        f"ENGINEER PROPOSED: {_settings_line(settings)}.\n"
+        f"ENGINEER REASONING: {advice.reasoning}\n"
+        f"ENGINEER FLAGGED RISKS: {[r.risk for r in advice.risks] or 'none'}.\n"
+        "Where is the Engineer being optimistic? What would you watch?",
+    )
+    if raw and {"stance", "headline", "detail"} <= set(raw):
+        return InspectorVerdict(str(raw["stance"]), str(raw["headline"]), str(raw["detail"]))
+    return _second_opinion_fallback(job, env, settings, advice)
+
+
+def _second_opinion_fallback(job: Job, env: Environment, settings: PrintSettings, advice: Advice) -> InspectorVerdict:
+    geo, mat = job.geometry_type, job.material.upper()
+    flags: list[str] = []
+    if geo in ("overhang", "bridge") and settings.fan_pct < 60:
+        flags.append(f"fan {settings.fan_pct:.0f}% is thin for a {geo} — sagging risk the Engineer may be underweighting")
+    if mat == "ABS" and job.bed_position in ("edge", "corner"):
+        flags.append(f"ABS off-center ({job.bed_position}) will pull at the edges — I'd second a warp watch and a brim")
+    if mat == "ABS" and settings.fan_pct > 40:
+        flags.append(f"fan {settings.fan_pct:.0f}% on ABS invites cracking/warp")
+    if env.humidity > 55 and mat in ("PETG", "TPU", "ABS") and settings.retraction_mm < 3:
+        flags.append(f"humid air ({env.humidity:.0f}%RH) + {settings.retraction_mm:.1f}mm retraction → expect stringing")
+    if not advice.risks:
+        flags.append("Engineer flagged NO failure regions — verify that's confidence, not optimism")
+
+    if not flags:
+        return InspectorVerdict("concur", "No red flags from a second look.",
+                                "Plan sits inside sane bounds for this material and room. Cleared to print.")
+    stance = "dispute" if len(flags) >= 2 else "caution"
+    return InspectorVerdict(stance, f"Second opinion: {flags[0]}.",
+                            " · ".join(flags[1:]) or "Print it, but watch that region.")
+
+
+# ── PRINT: grade one finished (simulated) print against the prediction ────────
+def grade_outcome(job: Job, env: Environment, settings: PrintSettings,
+                  advice: Advice, result: SimResult) -> InspectorVerdict:
+    predicted = _predicted_modes(advice)
+    raw = llm.chat_json(
+        PERSONA + "\n\nRespond ONLY with JSON: "
+        '{"stance":"held|missed|overcautious|confirmed","headline":"<one line>","detail":"<1-2 lines>"}',
+        "Grade this finished print. The outcome below came from the deterministic "
+        "world, not from the Engineer — you are checking the Engineer's CALL against it.\n"
+        f"JOB: {job.material}/{job.geometry_type} @ {env.temp:.0f}°C/{env.humidity:.0f}%RH.\n"
+        f"ENGINEER PREDICTED RISKS: {[r.risk for r in advice.risks] or 'none'}.\n"
+        f"ACTUAL OUTCOME: {result.outcome} — {result.detail} "
+        f"(failure mode: {result.failure_mode}).\n"
+        "Did the Engineer's prediction hold? Be blunt.",
+    )
+    agreement = _agreement(predicted, result)
+    if raw and {"stance", "headline", "detail"} <= set(raw):
+        return InspectorVerdict(str(raw["stance"]), str(raw["headline"]), str(raw["detail"]), agreement)
+    return _grade_fallback(predicted, result, agreement)
+
+
+def _agreement(predicted: set[str], result: SimResult) -> bool:
+    if result.failure_mode == "none":
+        return True            # clean print — nothing to have missed
+    return result.failure_mode in predicted
+
+
+def _grade_fallback(predicted: set[str], result: SimResult, agreement: bool) -> InspectorVerdict:
+    mode = _MODE_HUMAN.get(result.failure_mode, result.failure_mode)
+    if result.failure_mode == "none":
+        if predicted:
+            return InspectorVerdict("overcautious", f"Print held (q={result.quality:.2f}).",
+                                    f"Engineer flagged {', '.join(sorted(predicted))}; the settings covered it. "
+                                    "Credit the call — or it was conservative.", True)
+        return InspectorVerdict("held", f"Clean print (q={result.quality:.2f}).",
+                                "No failure flagged, none occurred. Plan and reality agree.", True)
+    if agreement:
+        return InspectorVerdict("confirmed", f"Failed on {mode} — exactly as called.",
+                                f"Quality {result.quality:.2f}. The Engineer's risk flag was right; "
+                                "the loop now has the lesson.", True)
+    return InspectorVerdict("missed", f"Failed on {mode} — and it wasn't flagged.",
+                            f"Quality {result.quality:.2f}. The Engineer didn't predict this mode. "
+                            "That gap is what the next iteration has to close.", False)
+
+
+# canonical failure mode each geometry is expected to risk (the loop's implicit
+# prediction — the deterministic policy loop carries no LLM Advice per iteration)
+_GEO_EXPECT = {"overhang": "sag", "bridge": "sag", "stringing": "stringing",
+               "adhesion": "adhesion", "vase": "warp"}
+
+
+def grade_iteration(geometry_type: str, result: SimResult) -> InspectorVerdict:
+    """Deterministic-only grade for one loop iteration (no LLM — the loop runs
+    many fast, reproducible iterations). Checks the outcome against the failure
+    mode this geometry is expected to risk."""
+    expected = {_GEO_EXPECT.get(geometry_type, "sag")}
+    return _grade_fallback(expected, result, _agreement(expected, result))
+
+
+# ── REVIEW: one verdict across a whole iteration run ──────────────────────────
+def summarize_run(records: list, *, material: str, geometry: str) -> InspectorVerdict:
+    if not records:
+        return InspectorVerdict("watch", "No run to review yet.", "Run the Print loop first.")
+    qualities = [r.result.quality for r in records]
+    first_clean = next((r.n for r in records if r.result.outcome == "success"), None)
+    start, end = qualities[0], qualities[-1]
+    climbed = end - start
+    if first_clean:
+        stance, head = "concur", f"Converged to clean by iteration {first_clean}."
+        detail = (f"{material}/{geometry} climbed {start:.2f} → {end:.2f}. The compounding is real: "
+                  "each simulated outcome tightened the policy and the next run was better-informed.")
+    elif climbed > 0.05:
+        stance, head = "caution", f"Improving but not yet clean (best {max(qualities):.2f})."
+        detail = (f"Quality rose {start:.2f} → {end:.2f} over {len(records)} runs but never crossed the "
+                  "bar. More iterations or a different lever needed — the loop is learning, slowly.")
+    else:
+        stance, head = "dispute", "No real progress this run."
+        detail = (f"Quality stuck around {start:.2f}. Either the job is mis-specified or the policy is "
+                  "saturated for these conditions — worth a human look before trusting the trend.")
+    return InspectorVerdict(stance, head, detail)

core/llm.py

@@ -17,7 +17,7 @@ MODEL = os.environ.get("CHIEF_ENGINEER_MODEL", "gemma4:e4b")
 
 # Backend select. Default "ollama" keeps local/recording behavior IDENTICAL.
 # Set CHIEF_ENGINEER_BACKEND=zerogpu ONLY on the published Space (see
-# llm_zerogpu.py + docs/plan/08-ZEROGPU-DEPLOY.md). Unknown/import-fail → ollama.
+# llm_zerogpu.py + docs/_archive/08-ZEROGPU-DEPLOY.md). Unknown/import-fail → ollama.
 BACKEND = os.environ.get("CHIEF_ENGINEER_BACKEND", "ollama").lower()
 
 try:

core/llm_zerogpu.py

@@ -18,14 +18,14 @@ Activation is opt-in and total:
 It preserves the Off-the-Grid story: the model CAN run fully local (proven in the
 video); ZeroGPU is just the hosted convenience so judges can try it live.
 
-Model ids RESOLVED 6/10 — see docs/plan/08-ZEROGPU-DEPLOY.md (primary:
+Model ids RESOLVED 6/10 — see docs/_archive/08-ZEROGPU-DEPLOY.md (primary:
 google/gemma-4-E2B-it, bf16 transformers-native). Original checklist:
   - Set `CHIEF_ENGINEER_HF_MODEL` to the QAT Gemma checkpoint you pick. Google's
     Gemma QAT int4 releases are the target. CONFIRM the exact repo id AND that it
     loads via `transformers` — some QAT releases ship **GGUF** (for llama.cpp);
     for those, use a llama-cpp-python path, not this transformers one.
   - Confirm the model is ≤32B (hackathon rule) and note its params for Tiny Titan.
-See `docs/plan/08-ZEROGPU-DEPLOY.md`.
+See `docs/_archive/08-ZEROGPU-DEPLOY.md`.
 """
 
 from __future__ import annotations

core/models.py

@@ -28,6 +28,7 @@ class Job(BaseModel):
 class Environment(BaseModel):
     temp: float = Field(description="Ambient temperature °C")
     humidity: float = Field(description="Ambient humidity %")
+    printer: str = "Creality Ender 3 V2"   # simulated machine (220×220×250 bed)
 
 
 class PrintSettings(BaseModel):

core/theme.py

@@ -246,15 +246,37 @@ def rule(label: str) -> str:
     return f"<div class='ce-rule'>{label}</div>"
 
 
-def footer_bar() -> str:
-    """Replaces the hidden Gradio footer with an Astrometrics status strip."""
+def footer_bar(job: str | None = None, env: str | None = None) -> str:
+    """Sticky Astrometrics status strip (replaces the hidden Gradio footer).
+    When a job/env is passed, the strip carries the live job context."""
+    left = f"JOB · {job}" if job else "ASTROMETRICS OS · CHIEF ENGINEER"
+    right = env if env else "FULLY LOCAL · GEMMA4"
     return (
-        "<div style='display:flex;justify-content:space-between;gap:16px;margin-top:14px;"
+        "<div id='ce-footer' style='position:sticky;bottom:0;z-index:30;"
+        "display:flex;justify-content:space-between;gap:16px;margin-top:14px;"
         "padding:6px 14px;border-top:2px solid var(--ao-orange);background:var(--ao-surface-hi);"
         "font-size:10px;letter-spacing:1px;text-transform:uppercase;color:var(--ao-outline);'>"
-        "<span>ASTROMETRICS OS · CHIEF ENGINEER</span>"
-        "<span>LLM PROPOSES · <b style='color:var(--ao-orange);'>SPINE DISPOSES</b> · HUMAN CONFIRMS</span>"
-        "<span>FULLY LOCAL · GEMMA4</span></div>"
+        f"<span style='color:var(--ao-orange);'>{left}</span>"
+        "<span>LLM PROPOSES · <b style='color:var(--ao-orange);'>SPINE DISPOSES</b> · INSPECTOR GRADES</span>"
+        f"<span>{right}</span></div>"
+    )
+
+
+def inspector_panel(verdict, *, label: str = "QA INSPECTOR · SECOND OPINION") -> str:
+    """Render an InspectorVerdict as a distinct reviewer card (separate voice)."""
+    col = verdict.color
+    agree = ""
+    if verdict.agreement is not None:
+        agree = ("<span style='float:right;font-size:10px;color:var(--ao-outline);'>"
+                 f"{'✓ prediction held' if verdict.agreement else '✗ prediction missed'}</span>")
+    return (
+        "<div style='font-family:ui-monospace,monospace;background:var(--ao-void);"
+        f"border:1px solid var(--ao-outline-dim);border-left:3px solid {col};padding:8px 12px;'>"
+        f"<div style='color:{col};font-weight:700;letter-spacing:2px;font-size:11px;'>"
+        f"🔍 {label} <span style='color:var(--ao-outline);font-weight:400;'>"
+        f"[{verdict.stance.upper()}]</span>{agree}</div>"
+        f"<div style='color:var(--ao-text);font-size:14px;font-weight:700;margin:4px 0;'>{verdict.headline}</div>"
+        f"<div class='ce-sub' style='font-size:12px;'>{verdict.detail}</div></div>"
     )
 
 

core/viewer.py

@@ -69,6 +69,55 @@ def generate_primitive(kind: str, size_mm: float = 30.0) -> tuple[str, str]:
     return str(out), _PRIM_GEO[kind]
 
 
+# one-line human read for each inferred class — surfaced read-only ("the engineer
+# reads this as …"), never a control the user sets.
+GEO_READS = {
+    "overhang": "overhang-dominant",
+    "bridge": "has unsupported spans (bridging)",
+    "vase": "tall thin-wall (vase-like)",
+    "adhesion": "wide flat base (adhesion-critical)",
+    "stringing": "many travel moves (stringing-prone)",
+}
+
+
+def infer_geometry(mesh_path: str | None) -> tuple[str, str]:
+    """Classify the failure-mode the engineer should reason about, straight from
+    the mesh — the user never picks it (the system figures it out). Returns
+    (geometry_type, one-line read). Falls back to 'overhang' (the most common
+    torture-test failure) when the mesh can't be read."""
+    if not mesh_path or not Path(mesh_path).exists():
+        return "overhang", GEO_READS["overhang"]
+    try:
+        import math
+
+        import trimesh
+
+        mesh = trimesh.load(mesh_path, force="mesh")
+        w, d, h = (float(x) for x in mesh.bounding_box.extents)
+        base = max(w, d, 1e-6)
+        footprint = max(1e-6, w * d)
+        downward = -mesh.face_normals[:, 2]            # +1 → horizontal ceiling (downward-facing)
+        steep = float(downward.max()) if len(downward) else 0.0
+        angle = math.degrees(math.asin(min(1.0, max(0.0, steep))))   # overhang angle from vertical
+        ceiling = float(mesh.area_faces[downward > 0.94].sum()) if len(downward) else 0.0
+        try:
+            solidity = float(mesh.volume) / max(1e-6, w * d * h)
+        except Exception:
+            solidity = 1.0
+
+        if h > 2.0 * base and solidity < 0.35:         # tall + mostly hollow → thin-wall shell
+            return "vase", GEO_READS["vase"]
+        if ceiling > 0.10 * footprint:                 # flat unsupported span → bridging
+            return "bridge", GEO_READS["bridge"]
+        if angle >= 45:                                # steep angled face → overhang
+            return "overhang", GEO_READS["overhang"]
+        if h < 0.5 * base:                             # wide + low → big bed contact
+            return "adhesion", GEO_READS["adhesion"]
+        return "stringing", GEO_READS["stringing"]
+    except Exception:
+        return "overhang", GEO_READS["overhang"]
+
+
 def settings_panel_html(settings: PrintSettings, material: str) -> str:
     """Render proposed settings as an LCARS instrument readout (not raw JSON)."""
     rows = [
@@ -278,11 +327,17 @@ def quality_curve_html(trajectory: list[float], threshold: float = 0.7) -> str:
     )
 
 
-def iteration_log_html(records) -> str:
+def iteration_log_html(records, verdicts=None) -> str:
+    """Per-iteration log. `verdicts` (optional, aligned to records) adds the QA
+    Inspector's terse grade on each run — the second voice in the loop."""
     rows = []
-    for r in records:
+    for i, r in enumerate(records):
         clean = r.result.outcome == "success"
         col = "var(--ao-green)" if clean else "var(--ao-red)"
+        insp = ""
+        if verdicts and i < len(verdicts) and verdicts[i] is not None:
+            v = verdicts[i]
+            insp = (f"<br><span style='color:{v.color};'>🔍 inspector [{v.stance}]: {v.headline}</span>")
         rows.append(
             f"<div style='font-family:ui-monospace,monospace;font-size:11px;border-left:3px solid {col};"
             f"background:var(--ao-surface);padding:5px 10px;margin:3px 0;color:var(--ao-text);'>"
@@ -290,7 +345,7 @@ def iteration_log_html(records) -> str:
             f"noz {r.settings.nozzle_temp:.0f}°C bed {r.settings.bed_temp:.0f}°C fan {r.settings.fan_pct:.0f}% "
             f"ret {r.settings.retraction_mm:.1f}mm"
             + (" · <span style='color:var(--ao-orange);'>spine-clamped</span>" if r.clamped else "")
-            + f"<br><span style='color:var(--ao-outline);'>↳ {r.learned}</span></div>"
+            + f"<br><span style='color:var(--ao-outline);'>↳ {r.learned}</span>{insp}</div>"
         )
     return "".join(rows)
 

ingest/samples/research_lessons.jsonl

@@ -1,3 +1,10 @@
 {"job_id": "ingest-001", "material": "ABS", "geometry_type": "warping", "env_temp": 20.0, "env_humidity": 40.0, "outcome": "failed_sag", "lesson": "ABS corners lifted in an open, cool room. ABS needs an enclosure and a 100-110C bed; without it, warping is near-certain regardless of settings.", "source": "ingested", "timestamp": "2026-05-22T09:00:00Z"}
 {"job_id": "ingest-002", "material": "ABS", "geometry_type": "adhesion", "env_temp": 24.0, "env_humidity": 45.0, "outcome": "success", "lesson": "ABS first layer held with bed at 105C, brim, and fan off for opening layers. Draught control matters more than glue for ABS adhesion.", "source": "ingested", "timestamp": "2026-05-22T09:05:00Z"}
 {"job_id": "ingest-003", "material": "TPU", "geometry_type": "stringing", "env_temp": 23.0, "env_humidity": 55.0, "outcome": "failed_stringing", "lesson": "TPU strung badly; it is highly hygroscopic. Dry the spool and print slow (~25mm/s) with minimal retraction — TPU clogs with aggressive retraction.", "source": "ingested", "timestamp": "2026-05-22T09:10:00Z"}
+{"job_id": "ingest-004", "material": "PETG", "geometry_type": "stringing", "env_temp": 26.0, "env_humidity": 65.0, "outcome": "failed_stringing", "lesson": "PETG strings heavily in humid conditions. Dry filament at 65C for 4+ hours, then lower nozzle temp 5-10C and increase retraction to 5-6mm. Wet PETG is the #1 cause of stringing.", "source": "ingested", "timestamp": "2026-06-12T12:00:00Z"}
+{"job_id": "ingest-005", "material": "PETG", "geometry_type": "bridge", "env_temp": 24.0, "env_humidity": 44.0, "outcome": "success", "lesson": "PETG bridges cleanly with fan at 80%, nozzle 240C, and retraction at 5mm. PETG likes more cooling than people think — just not on the first layer.", "source": "ingested", "timestamp": "2026-06-12T12:05:00Z"}
+{"job_id": "ingest-006", "material": "PLA", "geometry_type": "overhang", "env_temp": 31.0, "env_humidity": 40.0, "outcome": "failed_sag", "lesson": "PLA overhangs sag in a hot room (31C ambient). Max fan (100%) and lower nozzle to 200C rescued the next print. PLA needs aggressive cooling when ambient is above 28C.", "source": "ingested", "timestamp": "2026-06-12T12:10:00Z"}
+{"job_id": "ingest-007", "material": "PLA", "geometry_type": "vase", "env_temp": 21.0, "env_humidity": 40.0, "outcome": "success", "lesson": "PLA vase mode at 205C/60C bed with 100% fan produced a clean spiral. PLA is forgiving in cool, dry rooms — the baseline material for vase-mode prints.", "source": "ingested", "timestamp": "2026-06-12T12:15:00Z"}
+{"job_id": "ingest-008", "material": "ABS", "geometry_type": "overhang", "env_temp": 25.0, "env_humidity": 42.0, "outcome": "failed_sag", "lesson": "ABS overhangs curled upward at 80% fan — ABS hates part cooling. Keep fan at 0-20% for ABS, rely on enclosure ambient temp instead. Fan on ABS causes layer delamination.", "source": "ingested", "timestamp": "2026-06-12T12:20:00Z"}
+{"job_id": "ingest-009", "material": "TPU", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 35.0, "outcome": "success", "lesson": "TPU printed clean with 3mm retraction at 25mm/s in a dry room. TPU's flexibility means retraction must be slow and short — fast retraction stretches the filament instead of pulling it back.", "source": "ingested", "timestamp": "2026-06-12T12:25:00Z"}
+{"job_id": "ingest-010", "material": "PETG", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 50.0, "outcome": "success", "lesson": "PETG adhesion is strong on PEI at 80C bed — too strong on smooth PEI without release agent. Use textured PEI or glue stick as a release layer, not an adhesion aid, for PETG.", "source": "ingested", "timestamp": "2026-06-12T12:30:00Z"}

scripts/capture.py

@@ -36,12 +36,12 @@ def _pill(page, value):
 
 
 def _open_override(page):
-    """Sensors (temp/humidity/bed-position) live in the collapsed ⚙ OVERRIDE
-    accordion now — open it before setting them. Idempotent: only opens if the
+    """Temp/humidity/bed-position live in the collapsed ⚙ OVERRIDE ENVIRONMENT
+    accordion — open it before setting them. Idempotent: only opens if the
     bed-position pill isn't already visible (so chained beats don't toggle it shut)."""
     try:
         if not page.locator(".ce-pills label", has_text="corner").first.is_visible():
-            page.get_by_text("OVERRIDE SENSORS", exact=False).first.click()
+            page.get_by_text("OVERRIDE ENVIRONMENT", exact=False).first.click()
             time.sleep(0.3)
     except Exception:
         pass
@@ -58,12 +58,12 @@ def _set_sensors(page, t, h):
 
 
 def beat_studio(page, slow):
-    """Beat 3a — define the job in STUDIO (empty start → pick part + material;
-    set deterministic sensors for a repeatable, risk-relevant take)."""
+    """Beat 3a — define the job in STUDIO (empty start → quick-load a part +
+    material; set deterministic environment for a repeatable, risk-relevant take)."""
     page.get_by_role("tab", name="STUDIO").click(); time.sleep(slow)
-    _pill(page, "overhang"); time.sleep(slow)        # reference part type (DOM is lowercase)
-    _pill(page, "PLA"); time.sleep(slow)             # material
     _open_override(page); _set_sensors(page, 28, 60)  # warm + humid → precedent-rich
+    _pill(page, "PLA"); time.sleep(slow)              # material (engineer infers the part class)
+    page.get_by_role("button", name="QUICK-LOAD BENCHY").click()
     time.sleep(1.5)                                   # part preview (3D model) settles
 
 
@@ -74,14 +74,20 @@ def beat_benchy(page, slow):
     time.sleep(3.0)                                  # watch the hull slice live
 
 
-def beat_analyze(page, slow):
-    """Beat 3b — ANALYZE -> auto-switch to ANALYSIS, let the reasoning land."""
-    page.get_by_role("button", name="ANALYZE JOB").click()
+def beat_build(page, slow):
+    """Beat 3b — BUILD -> auto-switch to BUILD, let the engineer's read land."""
+    page.get_by_role("button", name="BUILD JOB").click()
     time.sleep(4.5)                                  # reasoning + settings readout appear
 
 
+def beat_second_opinion(page, slow):
+    """The QA Inspector's pre-print critique (the second voice) on the BUILD page."""
+    page.get_by_role("button", name="SECOND OPINION").first.click()
+    time.sleep(3.0)
+
+
 def beat_scrub(page, slow):
-    """Slide through the filled cross-section layers (on the Analysis page)."""
+    """Slide through the filled cross-section layers (on the Build page)."""
     sl = page.locator("input[type=range]").last
     for v in (8, 18, 30, 40):
         sl.fill(str(v)); sl.dispatch_event("input"); sl.dispatch_event("change")
@@ -91,44 +97,46 @@ def beat_scrub(page, slow):
 def beat_placement(page, slow):
     """Build-plate beat — ABS in the corner: warp predicted + 'center it' suggestion."""
     page.get_by_role("tab", name="STUDIO").click(); time.sleep(slow)
-    _pill(page, "adhesion")            # a flat part where bed adhesion/warp dominates
     _pill(page, "ABS")                 # high-shrink material
-    _open_override(page)               # bed-position now lives in the override panel
+    _open_override(page)               # bed-position lives in the override panel
     _pill(page, "corner")              # worst plate position
+    page.get_by_role("button", name="QUICK-LOAD BENCHY").click()
     time.sleep(slow)
-    page.get_by_role("button", name="ANALYZE JOB").click()
+    page.get_by_role("button", name="BUILD JOB").click()
     time.sleep(4.5)                    # PLACEMENT risk + suggested alignment appear
 
 
 def beat_close_loop(page, slow):
-    """Beat 4a — simulate the outcome (deterministic), ledger grows."""
-    page.get_by_role("button", name="Simulate outcome").first.click()
+    """Beat 4a — go to PRINT, simulate one print (deterministic) + inspector grade."""
+    page.get_by_role("tab", name="PRINT").click(); time.sleep(slow)
+    page.get_by_role("button", name="SIMULATE ONE PRINT").first.click()
     time.sleep(3.0)
 
 
 def beat_loop(page, slow):
-    """Beat 4b — the Learning Loop: quality climbs fail->clean."""
-    page.get_by_role("tab", name="LEARNING LOOP").click(); time.sleep(slow)
-    page.get_by_role("button", name="RUN SIMULATED LEARNING").click()
+    """Beat 4b — PRINT: run iterations, quality climbs fail->clean with inspector grades."""
+    page.get_by_role("tab", name="PRINT").click(); time.sleep(slow)
+    page.get_by_role("button", name="PRINT (RUN ITERATIONS)").click()
     time.sleep(5.0)                                  # the curve fills in
 
 
 def beat_ledger(page, slow):
-    """Beat 4c — Knowledge + Mesh: the ledger where lessons accumulate."""
-    page.get_by_role("tab", name="KNOWLEDGE + MESH").click()
+    """Beat 4c — Review: the ledger where lessons accumulate + the run verdict."""
+    page.get_by_role("tab", name="REVIEW").click()
     time.sleep(3.0)
 
 
 BEATS = {
     "studio": [beat_studio],
     "benchy": [beat_studio, beat_benchy],
-    "3": [beat_studio, beat_analyze],
-    "scrub": [beat_studio, beat_analyze, beat_scrub],
+    "3": [beat_studio, beat_build],
+    "scrub": [beat_studio, beat_build, beat_scrub],
+    "second": [beat_studio, beat_build, beat_second_opinion],   # the Inspector's pre-print read
     "placement": [beat_placement, beat_scrub],        # ABS-in-corner → warp + "center it"
     "4": [beat_close_loop, beat_loop, beat_ledger],
     "loop": [beat_loop],
     "ledger": [beat_ledger],
-    "all": [beat_studio, beat_analyze, beat_scrub, beat_close_loop,
+    "all": [beat_studio, beat_build, beat_second_opinion, beat_scrub, beat_close_loop,
             beat_placement, beat_loop, beat_ledger],
 }
 

sim/calibration/observations.modal.jsonl

@@ -0,0 +1,260 @@
+{"material": "PETG", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 100.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "bridge", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 76.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "vase", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 255.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 76.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 100.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 51.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "bridge", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 255.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 255.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 51.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "ABS", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 76.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "bridge", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 255.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "bridge", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 76.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 100.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "ABS", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 76.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 100.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "ABS", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "bridge", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 100.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "bridge", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 255.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "bridge", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 255.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "vase", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "ABS", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "vase", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "ABS", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 76.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 100.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 100.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 76.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "ABS", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "ABS", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "ABS", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 76.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 100.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "ABS", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 51.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "bridge", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 100.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "bridge", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 255.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "ABS", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 76.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "ABS", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 100.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "ABS", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "ABS", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 76.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 100.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "ABS", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 76.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 76.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 255.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "ABS", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "vase", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 100.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 100.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "vase", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "bridge", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 255.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "vase", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 76.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "bridge", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 76.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "vase", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 100.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 255.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "ABS", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "ABS", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "vase", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 100.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 76.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "ABS", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "ABS", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "vase", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 100.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "ABS", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 255.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "ABS", "geometry_type": "bridge", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 76.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "ABS", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 76.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 76.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "ABS", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "adhesion", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 100.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PETG", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 40.0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 6.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 1.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.85}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 6.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 1.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 6.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.75}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 6.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 6.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 6.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 6.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 6.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 1.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 220.0, "bed_temp": 60.0, "retraction_mm": 1.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 220.0, "bed_temp": 60.0, "retraction_mm": 1.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 220.0, "bed_temp": 60.0, "retraction_mm": 1.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.5}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.5}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.5}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.5}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.5}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.5}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.5}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.5}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.5}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.5}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.5}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.5}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.7}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 220.0, "bed_temp": 60.0, "retraction_mm": 2.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 220.0, "bed_temp": 60.0, "retraction_mm": 2.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 220.0, "bed_temp": 60.0, "retraction_mm": 2.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 220.0, "bed_temp": 60.0, "retraction_mm": 2.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 220.0, "bed_temp": 60.0, "retraction_mm": 2.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 220.0, "bed_temp": 60.0, "retraction_mm": 2.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 220.0, "bed_temp": 60.0, "retraction_mm": 2.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 220.0, "bed_temp": 60.0, "retraction_mm": 2.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 220.0, "bed_temp": 60.0, "retraction_mm": 2.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 220.0, "bed_temp": 60.0, "retraction_mm": 2.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 220.0, "bed_temp": 60.0, "retraction_mm": 2.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 220.0, "bed_temp": 60.0, "retraction_mm": 2.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 220.0, "bed_temp": 60.0, "retraction_mm": 2.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 220.0, "bed_temp": 60.0, "retraction_mm": 2.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.7}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.7}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.7}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.7}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.7}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.7}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.7}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.7}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.7}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_sag", "quality": 0.6}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 8.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 215.0, "bed_temp": 60.0, "retraction_mm": 8.5, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 0.82}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 0.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 0.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 0.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 0.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 0.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 0.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 0.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 0.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "overhang", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 5.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "success", "quality": 1.0}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 3.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 1.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 1.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 1.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 1.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 1.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 1.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}
+{"material": "PLA", "geometry_type": "stringing", "env_temp": 22.0, "env_humidity": 45.0, "nozzle_temp": 210.0, "bed_temp": 60.0, "retraction_mm": 1.0, "fan_pct": 0, "first_layer_fan_pct": 0, "outcome": "failed_stringing", "quality": 0.7}