deploy: update Space from deploy_preflight --push

.codeboarding/logs/wrapper-server.log

@@ -348,3 +348,144 @@ INFO:     127.0.0.1:44498 - "GET /health HTTP/1.1" 200 OK
 [stderr] 2026-06-14 08:27:24 INFO     [watchfiles.main:308] 1 change detected
 [stderr] 2026-06-14 08:27:24 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
 [stderr] 2026-06-14 08:27:24 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:38:21 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:38:21 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:38:21 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:38:51 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:38:52 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:38:52 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:39:24 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:39:25 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:39:25 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:39:37 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:39:37 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:39:37 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:39:43 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:39:44 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:39:44 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:40:08 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:40:08 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:40:08 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:42:15 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:42:15 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:42:15 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:42:17 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:42:17 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:42:17 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:42:27 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:42:27 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:42:27 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:42:32 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:42:33 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:42:33 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:42:37 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:42:37 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:42:38 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:42:38 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:42:41 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:42:42 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:42:42 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:42:49 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:42:49 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:42:49 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:42:52 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:42:52 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:42:53 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:42:53 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:42:58 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:42:58 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:42:58 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:43:12 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:43:13 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:43:13 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:43:21 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:43:22 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:43:22 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:43:25 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:43:31 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:43:34 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:43:34 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:43:34 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:43:50 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:43:50 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:43:50 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:43:52 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:43:52 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:43:52 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:44:05 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:44:05 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:44:05 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:44:14 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:44:14 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:44:14 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:44:20 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:44:20 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:44:20 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:47:55 INFO     [watchfiles.main:308] 2 changes detected
+[stderr] 2026-06-14 08:47:55 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:47:55 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:47:59 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:48:00 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:48:00 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:48:08 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:48:09 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:48:09 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:48:13 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:48:14 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:48:14 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:48:25 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:48:25 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:48:25 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:48:31 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:48:31 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:48:31 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:48:36 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:48:37 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:48:37 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:48:40 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:48:41 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:48:41 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:48:43 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:48:43 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:48:43 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:48:46 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:48:46 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:48:46 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:48:48 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:48:48 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:48:48 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:48:50 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:48:50 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:48:50 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:48:55 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:48:56 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:48:56 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:49:02 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:49:50 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:54:18 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:54:19 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:54:19 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:54:40 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:54:40 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:54:40 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:54:45 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:54:45 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:54:45 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:55:09 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:55:10 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:55:10 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:55:29 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:55:29 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:55:29 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:55:56 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:55:57 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:55:57 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:56:52 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:56:53 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:56:53 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:57:00 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:57:00 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:57:00 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report
+[stderr] 2026-06-14 08:57:08 INFO     [watchfiles.main:308] 1 change detected
+[stderr] 2026-06-14 08:57:09 WARNING  [codeboarding_pro.analysis_controller:506] Skipping incremental update: full analysis artifacts not ready yet
+[stderr] 2026-06-14 08:57:09 INFO     [codeboarding_pro.analysis_controller:314] No cached analysis results; skipping health report

app.py

@@ -18,7 +18,9 @@ from __future__ import annotations
 
 import os
 import random
+import time
 import uuid
+from pathlib import Path
 
 import gradio as gr
 
@@ -48,7 +50,7 @@ from core.models import Advice, BED_POSITIONS, Environment, Job, MATERIALS, Prin
 from core.nodes import render_node_cards
 from core.reflect import reflect_on_job
 from core.spine import SpineValidator
-from learn.loop import run_session
+from learn.loop import run_iteration, SessionResult
 from learn.policy import LearnedPolicy, cell_key
 from core.viewer import (
     GEO_READS,
@@ -174,7 +176,8 @@ def studio_log_html() -> str:
 
 def reset_learnings():
     """Reset the live ledger + learned policy to the curated baseline (seed + ingested),
-    clearing this session's accumulated runs. Wired to the persistent Reset on every tab."""
+    clearing this session's accumulated runs. Also clears the loaded part and hides the
+    result groups so the next run starts from a clean LOAD tab."""
     removed = LEDGER.reset_to_baseline()
     POLICY.reset()
     gr.Info(f"Reset to baseline — cleared {removed} runtime lesson(s) + the learned policy.")
@@ -188,6 +191,13 @@ def reset_learnings():
         gr.update(visible=False),                                        # print results_group (re-hide)
         "",                                                              # real_log_msg
         studio_log_html(),                                              # studio_log
+        {"geometry": None, "mesh": None, "label": None, "read": None}, # part state
+        gr.update(value=None, visible=False),                           # model3d
+        gr.update(visible=True),                                         # part_placeholder
+        "",                                                              # part_status
+        gr.update(visible=False),                                        # build_results
+        gr.update(visible=False),                                        # read_results
+        gr.Tabs(selected="studio"),                                      # tabs back to LOAD
     )
 
 
@@ -219,21 +229,31 @@ def _set_part(geometry: str, mesh, label: str, read: str | None = None):
 
 
 def build_start(part):
-    """Instant feedback when BUILD is clicked: jump to Build, show ONE consolidated
-    loader, hide the (stale) results until the model returns. No part → stay put."""
+    """Instant feedback when BUILD is clicked: jump to Build, reveal the slicer +
+    virtual print preview immediately, and show the read panel in a loading state
+    while the model runs. No part → stay put."""
     if not (part and part.get("geometry")):
         gr.Warning("Load a part on the BUILD tab first — quick-load Benchy, generate a primitive, or drop a mesh.")
-        return (gr.update(),) * 9
+        return (gr.update(),) * 13
+    mesh = part.get("mesh")
+    label = part.get("label") or "PART"
+    vp_html = virtual_printer_html(mesh, caption=f"{label} · virtual print preview")
+    layer_img = layer_image(mesh, 1)
     return (
         gr.Tabs(selected="build"),                    # tabs
-        loader("SLICING THE PART · reading precedent, proposing settings, running checks"),  # build_loader
-        gr.update(visible=False),                     # build_results (hide until ready)
+        gr.update(visible=True),                      # build_results (reveal)
+        gr.update(visible=True),                      # read_results (reveal, loading state)
+        loader("READING THE PLAN · O'Brien is checking precedent and proposing settings"),
+                                                      # read_loader
+        vp_html,                                      # vprint
+        gr.update(value=1),                           # vp_slider reset
+        layer_img,                                    # vp_layer
         gr.update(interactive=True),                  # to_print_btn (un-gate)
         gr.update(visible=False),                     # override_btn (hide)
-        "",                                           # second_opinion_panel (clear stale verdict)
+        "",                                           # second_opinion_panel (clear stale)
         gr.update(value="Engineer's Read"),           # read_toggle (reset to the read)
-        gr.update(visible=True),                       # eng_read_group
-        gr.update(visible=False),                      # second_op_group
+        gr.update(visible=True),                      # eng_read_group
+        gr.update(visible=False),                     # second_op_group
     )
 
 
@@ -271,16 +291,30 @@ def _status_html() -> str:
 
 
 def warm_up_pending() -> str:
-    return ("<div class='ce-sub' style='font-size:12px;'>MODEL · "
-            "warming up (first load can take ~30s on ZeroGPU)…</div>")
+    """Header icon stays; the warm-up intent is signaled by a toast."""
+    gr.Info("Warming up the model (first load can take ~30s on ZeroGPU)…")
+    return _model_icon()
 
 
 def warm_up_cb() -> str:
-    return f"<div class='ce-sub' style='font-size:12px;'>MODEL · {llm.warm_up()}</div>"
+    """After warm-up, keep the info icon in the header."""
+    return _model_icon()
+
+
+def _model_icon() -> str:
+    """Small info-icon callout for the header row. No text — the dropdown + warm-up
+    button already give enough context; the tooltip explains the backends."""
+    return (
+        "<span class='ce-callout' tabindex='0'>" + icon("info") + ""
+        "<span class='ce-tip'>The <b>LoRA v2/v3</b> adapters serve via ZeroGPU on the Space; "
+        "<b>Base</b> is the stock Gemma 4 E4B; <b>Modal API</b> is the remote endpoint. "
+        "Local users: pull the LoRA from HF Hub "
+        "(kylebrodeur/microfactory-node-lora-v2 / -v3-qat) or via ollama.</span></span>"
+    )
 
 
 def _model_callout() -> str:
-    """Hover callout next to the model switcher (replaces the full-width info block)."""
+    """Legacy full-width model callout (used when more explanatory text is wanted)."""
     return (
         "<span class='ce-callout' tabindex='0'>" + icon("info") + " MODEL INFO"
         "<span class='ce-tip'>The <b>LoRA v2/v3</b> adapters serve via ZeroGPU on the Space; "
@@ -291,16 +325,14 @@ def _model_callout() -> str:
 
 
 def select_model(choice: str) -> str:
-    """Model switcher (backend by learn/finetune via _apply_model_choice). Applies the
-    chosen backend, then reports the model actually serving. The LoRA v2/v3 adapters serve
-    through ZeroGPU on the Space (and fall back gracefully if the GPU/deps aren't present);
-    Base is the stock Gemma 4 E4B; Modal API is the remote endpoint."""
+    """Model switcher: apply the chosen backend, then return the info icon so the
+    header stays compact."""
     choice = choice or MODEL_OPTIONS[0]
     try:
         _apply_model_choice(choice)
     except Exception:
         pass
-    return f"<div class='ce-sub' style='font-size:12px;'>MODEL · {choice} · {llm.backend_status()}</div>"
+    return _model_icon()
 
 
 # ── simulated environment (this is a sim lab — conditions are generated, overridable) ──
@@ -357,7 +389,8 @@ def build_job(part, material, description, temp, humidity, bed_position, model_c
     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 BUILD
+    vp_html = virtual_printer_html(mesh, settings=spine.settings,
+                                     caption=f"{material} · {geometry_type}")  # init on BUILD
 
     precedent = precedent_eval_html(retrieved, env)
     if retrieved:
@@ -374,9 +407,11 @@ def build_job(part, material, description, temp, humidity, bed_position, model_c
     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.")
+    spine_notes_text = f"{spine_md}\n\n{approval_md}" if spine_md else approval_md
     session_id = uuid.uuid4().hex
     state = {"job": job.model_dump(), "env": env.model_dump(), "settings": spine.settings.model_dump(),
-             "advice": rec.advice.model_dump(), "label": part.get("label"), "session_id": session_id}
+             "advice": rec.advice.model_dump(), "label": part.get("label"), "session_id": session_id,
+             "spine_notes": spine_notes_text}
 
     # ── field log (Space only — gated on HF_TOKEN; local/offline no-ops) ──
     field_log.log_build(
@@ -401,22 +436,22 @@ def build_job(part, material, description, temp, humidity, bed_position, model_c
         f"**Chief Engineer O'Brien:** {rec.advice.reasoning}",         # reasoning
         risk_callouts_html(rec.advice.risks, hint) + placement_callout(material, bed_position),  # risks
         settings_panel_html(spine.settings, material),                 # settings (LCARS panel)
-        f"{spine_md}\n\n{approval_md}" if spine_md else approval_md,    # spine notes
+        spine_notes_text,                                                # spine notes
         gcode_panel_html(spine.settings, material),                    # g-code (LCARS panel)
         confirm_vis,                                                   # confirm visibility
         render_node_cards(env, working=True),                          # node cards
         state,                                                         # state
-        vp_html,                                                       # virtual print (animates once)
+        virtual_printer_html(mesh, settings=spine.settings,
+                              caption=f"{material} · {geometry_type}"),  # vprint (refined caption)
         gr.update(value=1),                                            # reset layer scrubber
         layer_image(mesh, 1),                                          # initial scrubbed layer
-        "",                                                            # build_loader (clear)
-        gr.update(visible=True),                                       # build_results (reveal)
+        "",                                                            # read_loader (clear)
     )
 
 
-def second_opinion(state):
-    """A SEPARATE Inspector persona critiques the plan before any print runs. A
-    'dispute' verdict GATES → PRINT until acknowledged; caution/concur are advisory."""
+def _compute_second_opinion(state):
+    """Run the Inspector (La Forge) critique once. Returns the raw tuple used by
+    the UI: (panel_html, to_print_update, override_update)."""
     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))
@@ -442,14 +477,42 @@ def second_opinion(state):
     return panel, gr.update(interactive=True), gr.update(visible=False)
 
 
+def second_opinion(state):
+    """Idempotent wrapper: if La Forge already weighed in on this build, return the
+    cached verdict; otherwise compute it once and store it in state."""
+    if state and state.get("second_opinion"):
+        return state["second_opinion"]
+    result = _compute_second_opinion(state)
+    if state:
+        state["second_opinion"] = result
+    return result
+
+
 def toggle_read(choice, state):
     """Segmented toggle on Build: flip between Engineer's Read and Second Opinion,
-    showing one panel at a time. The opinion is computed lazily on first reveal."""
+    showing one panel at a time. The opinion is computed lazily on first reveal and
+    then cached for the rest of the build. While it computes, the Second Opinion panel
+    shows a mini-loader so the user knows La Forge is reviewing the plan."""
     if str(choice).lower().startswith("engineer"):
-        return (gr.update(visible=True), gr.update(visible=False),
-                gr.update(), gr.update(), gr.update())
-    panel, to_print, override = second_opinion(state)
-    return (gr.update(visible=False), gr.update(visible=True), panel, to_print, override)
+        yield (gr.update(visible=True), gr.update(visible=False),
+               "", gr.update(), gr.update(), state)
+        return
+    cached = state.get("second_opinion") if state else None
+    if cached:
+        panel, to_print, override = cached
+        yield (gr.update(visible=False), gr.update(visible=True), panel, to_print, override, state)
+        return
+    # show in-place loader while the Inspector runs
+    yield (gr.update(visible=False), gr.update(visible=True),
+           loader("CONSULTING LA FORGE", stages=[
+               "reading the engineer's plan",
+               "checking precedent and risks",
+               "comparing settings to the safe envelope",
+               "drafting the pre-print verdict",
+           ]), gr.update(interactive=True), gr.update(visible=False), state)
+    panel, to_print, override = _compute_second_opinion(state)
+    state = (state or {}) | {"second_opinion": (panel, to_print, override)}
+    yield (gr.update(visible=False), gr.update(visible=True), panel, to_print, override, state)
 
 
 def ack_override(state):
@@ -475,6 +538,79 @@ def job_readout(state):
             f"{icon('printer')} {PRINTER}</div>")
 
 
+def plan_card_html(state):
+    """THE PLAN card: Spine-validated proposed settings + Spine notes for the current job."""
+    if not state or "settings" not in state:
+        return ("<div class='ce-sub'>No plan built yet. Go to <b>BUILD</b> → define a part → "
+                "<b>SLICE</b>, then return here to print it.</div>")
+    settings = PrintSettings(**state["settings"])
+    material = state["job"]["material"]
+    html = settings_panel_html(settings, material)
+    notes = state.get("spine_notes") or ""
+    if notes:
+        html += ("<div class='ce-sub' style='margin-top:6px;'>" +
+                 notes.replace("\n", "<br>") + "</div>")
+    return html
+
+
+def plan_verdict_html(state):
+    """La Forge's pre-print stance if already computed on the SLICE tab."""
+    if not state or "settings" not in state:
+        return ("<div class='ce-sub'>Build a job first to get La Forge's pre-print stance.</div>")
+    cached = state.get("second_opinion")
+    if cached:
+        return cached[0]
+    return ("<div class='ce-sub'>" + icon("search") +
+            " Run the Inspector (<b>Second Opinion</b>) on the SLICE tab for a pre-print stance.</div>")
+
+
+def _print_plan_values(state):
+    """Return the Engineer's proposed settings values (or safe defaults) for VARY sliders."""
+    defaults = {"nozzle_temp": 200, "bed_temp": 60, "fan_pct": 80, "retraction_mm": 4.5}
+    if not state or "settings" not in state:
+        return defaults
+    s = state["settings"]
+    return {k: s.get(k, defaults[k]) for k in defaults}
+
+
+def apply_overrides(state, nozzle, bed, fan, retract):
+    """Compare VARY slider values to the Engineer's plan. If anything changed, build an
+    override PrintSettings and log that the operator defied the plan. Returns the override
+    dict (or None when the plan is unchanged)."""
+    if not state or "settings" not in state:
+        return None
+    plan = PrintSettings(**state["settings"])
+    diffs = {}
+    if abs(float(nozzle) - plan.nozzle_temp) > 1e-6:
+        diffs["nozzle_temp"] = float(nozzle)
+    if abs(float(bed) - plan.bed_temp) > 1e-6:
+        diffs["bed_temp"] = float(bed)
+    if abs(float(fan) - plan.fan_pct) > 1e-6:
+        diffs["fan_pct"] = float(fan)
+    if abs(float(retract) - plan.retraction_mm) > 1e-6:
+        diffs["retraction_mm"] = float(retract)
+    if not diffs:
+        state.pop("print_overrides", None)
+        return None
+    overrides = plan.model_copy(update=diffs)
+    state["print_overrides"] = overrides.model_dump()
+    job = Job(**state["job"])
+    env = Environment(**state["env"])
+    field_log.log_event("print_override", {
+        "material": job.material, "geometry": job.geometry_type,
+        "env_temp": env.temp, "env_humidity": env.humidity,
+        "settings": overrides.model_dump(),
+    })
+    if state.get("session_id"):
+        deliberation_log.log_turns(state["session_id"], "preflight", [
+            {"agent": "Operator", "act": "override",
+             "content": (f"Overrode the Engineer: nozzle {overrides.nozzle_temp:.0f}°C, "
+                         f"bed {overrides.bed_temp:.0f}°C, fan {overrides.fan_pct:.0f}%, "
+                         f"retraction {overrides.retraction_mm:.1f}mm.")},
+        ], _delib_ctx(job, env))
+    return overrides.model_dump()
+
+
 def _simulated_result_panel(sess, run_summary, material, geometry_type, env, label) -> str:
     """Two-zone outcome — the dominant SIMULATED RESULT zone (the compact LOG A REAL
     PRINT zone is static UI below). Shows the final outcome, the climb, whether the
@@ -503,36 +639,63 @@ def _simulated_result_panel(sess, run_summary, material, geometry_type, env, lab
     )
 
 
-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. Slider 1 = a single
-    print. Results reveal only after the run (progressive reveal)."""
+def run_print(state, iterations, nozzle, bed, fan, retract, progress=gr.Progress()):
+    """PRINT: run THIS job (inherited from Build) through the closed loop.
+    Now a generator so the iteration log + quality chart + policy cell fill in
+    live as each iteration completes. Per-iteration timing is shown next to each row."""
     if not state or "job" not in state:
         gr.Warning("Build a job first (BUILD → SLICE), then print it here.")
-        return (gr.update(),) * 9
+        yield (gr.update(),) * 9
+        return
     job = Job(**state["job"])
     env = Environment(**state["env"])
     material, geometry_type = job.material, job.geometry_type
     key = cell_key(material, geometry_type, env)
     before_html = policy_cell_html(POLICY.cell_stats(material, geometry_type, env), key)
 
-    sess = run_session(job, env, int(iterations), POLICY, LEDGER)
+    overrides_dict = apply_overrides(state, nozzle, bed, fan, retract)
+    overrides = PrintSettings(**overrides_dict) if overrides_dict else None
+
+    records, verdicts, timings = [], [], []
+    n_iters = int(iterations)
+    start_iter = time.perf_counter()
+    for i in range(1, n_iters + 1):
+        progress(i / n_iters, desc=f"Iteration {i}/{n_iters}")
+        record = run_iteration(job, env, POLICY, LEDGER, i, overrides=overrides)
+        verdict = inspector.grade_iteration(geometry_type, record.result)
+        elapsed = time.perf_counter() - start_iter
+        start_iter = time.perf_counter()
+        records.append(record)
+        verdicts.append(verdict)
+        timings.append(elapsed)
+        yield (
+            gr.update(visible=True),                                 # results_group
+            "",                                                      # outcome_panel
+            "",                                                      # p_headline
+            quality_curve_html([r.result.quality for r in records]), # p_curve
+            iteration_log_html(records, verdicts, timings),          # p_log
+            policy_cell_html(POLICY.cell_stats(material, geometry_type, env), key),  # p_policy
+            gr.update(),                                             # ledger_panel
+            gr.update(),                                             # node_cards
+            "",                                                      # review_summary
+        )
+
     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)
+    run_summary = inspector.summarize_run(records, material=material, geometry=geometry_type)
 
-    traj = sess.trajectory
-    first = sess.first_success
+    traj = [r.result.quality for r in records]
+    first = next((r.n for r in records if r.result.outcome == "success"), None)
     field_log.log_event("print_run", {"material": material, "geometry": geometry_type,
                                        "env_temp": env.temp, "env_humidity": env.humidity,
-                                       "iterations": len(sess.records), "q_start": round(traj[0], 3),
+                                       "iterations": len(records), "q_start": round(traj[0], 3),
                                        "q_end": round(traj[-1], 3), "first_clean": first,
-                                       "inspector_stance": run_summary.stance})
+                                       "inspector_stance": run_summary.stance,
+                                       "used_override": overrides is not None,
+                                       "override_settings": overrides.model_dump() if overrides else None})
     # ── deliberation log: World simulates -> La Forge grades, per iteration; then verdict ──
     ctx = _delib_ctx(job, env)
     loop_turns = []
-    for r, g in zip(sess.records, verdicts):
+    for r, g in zip(records, verdicts):
         clamp = " (Spine clamped a setting)" if r.clamped else ""
         loop_turns.append({"agent": "World", "act": "simulate", "stance": r.result.outcome,
                            "content": f"Iteration {r.n}: {r.result.detail}.{clamp} Policy: {r.learned}."})
@@ -545,7 +708,7 @@ def run_print(state, iterations):
     ], ctx)
     headline = (
         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"started at quality **{traj[0]:.2f}** ({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 Engineer proposed; a separate simulated world reported the outcome; the **Inspector** "
@@ -553,16 +716,18 @@ def run_print(state, iterations):
     )
     policy_html = (f"{before_html}<div style='text-align:center;color:var(--ao-orange);font-size:11px;"
                    f"letter-spacing:2px;'>{icon('arrow')} LEARNED</div>{policy_cell_html(after, key)}")
-    outcome = _simulated_result_panel(sess, run_summary, material, geometry_type, env, state.get("label"))
-    return (
-        gr.update(visible=True),                                  # results_group (reveal)
-        headline,                                                # p_headline
-        quality_curve_html(traj),                                # p_curve
-        iteration_log_html(sess.records, verdicts),              # p_log (with inspector grades)
-        policy_html,                                             # p_policy
-        outcome,                                                 # outcome_panel (SIMULATED RESULT zone)
-        ledger_html(),                                           # ledger_panel
-        render_node_cards(env, working=False),                   # node_cards
+    outcome = _simulated_result_panel(
+        SessionResult(job=job, env=env, records=records),
+        run_summary, material, geometry_type, env, state.get("label"))
+    yield (
+        gr.update(visible=True),                                  # results_group
+        outcome,                                                  # outcome_panel
+        headline,                                                 # p_headline
+        quality_curve_html(traj),                                 # p_curve
+        iteration_log_html(records, verdicts, timings),           # p_log
+        policy_html,                                              # p_policy
+        ledger_html(),                                            # ledger_panel
+        render_node_cards(env, working=False),                    # node_cards
         inspector_panel(run_summary, label="LA FORGE · RUN VERDICT"),  # review_summary
     )
 
@@ -591,35 +756,57 @@ def launch(**kw):
 
 
 def _action_bar(reset_btn_label="RESET", primary_label=None, primary_variant="primary",
-                primary_id=None):
+                primary_id=None, primary_arrow=True):
     """Build the consistent top-right action bar (small primary + persistent Reset).
-    Both buttons are scale=0 so they DON'T stretch full-width."""
+    Both buttons are scale=0 so they DON'T stretch full-width. Primary buttons get
+    a right-side arrow icon by default to signal "proceed to next stage"."""
     with gr.Row(elem_classes=["ce-actionbar"]):
         reset = gr.Button(reset_btn_label, elem_classes=["ce-pillbtn", "ce-act"], scale=0)
         primary = None
         if primary_label:
+            primary_classes = ["ce-act"]
+            if primary_arrow:
+                primary_classes.append("ce-icon-arrow-after")
             primary = gr.Button(primary_label, variant=primary_variant,
-                                elem_classes=["ce-act"], elem_id=primary_id, scale=0)
+                                elem_classes=primary_classes, elem_id=primary_id, scale=0)
     return reset, primary
 
 
+def refresh_print_tab(state):
+    """Refresh the PRINT tab's plan + verdict readouts whenever the tab is visited."""
+    return job_readout(state), plan_card_html(state), plan_verdict_html(state)
+
+
+def open_vary_panel(state):
+    """Open the VARY override panel and seed the sliders with the Engineer's plan."""
+    vals = _print_plan_values(state)
+    return (gr.update(visible=True),
+            gr.update(value=vals["nozzle_temp"]),
+            gr.update(value=vals["bed_temp"]),
+            gr.update(value=vals["fan_pct"]),
+            gr.update(value=vals["retraction_mm"]))
+
+
 # outputs touched by Reset (shared by the persistent Reset on every tab)
 def _reset_outputs(ledger_panel, node_cards, review_summary, p_curve, p_policy, p_log,
-                   p_headline, outcome_panel, results_group, real_log_msg, studio_log):
+                   p_headline, outcome_panel, results_group, real_log_msg, studio_log,
+                   part, model3d, part_placeholder, part_status, build_results,
+                   read_results, tabs):
     return [ledger_panel, node_cards, review_summary, p_curve, p_policy, p_log,
-            p_headline, outcome_panel, results_group, real_log_msg, studio_log]
+            p_headline, outcome_panel, results_group, real_log_msg, studio_log,
+            part, model3d, part_placeholder, part_status, build_results, read_results, tabs]
 
 
 def build() -> gr.Blocks:
     with gr.Blocks(title="Microfactory Node: 3D Printer") as demo:
         gr.HTML(command_bar(llm.backend_status()))
-        # header row: dropdown + warm button only (NO background tints, NO stretching)
+        # header row: dropdown + warm button + info icon only (NO background tints, NO stretching)
         with gr.Row(elem_id="ce-modelswitch"):
             model_select = gr.Dropdown(MODEL_OPTIONS, value=MODEL_OPTIONS[0],
                                        show_label=False, container=False,
                                        elem_classes=["ce-modeldd"], scale=0)
             warm_btn = gr.Button("WARM UP", elem_classes=["ce-pillbtn", "ce-icon-bolt"], scale=0)
-            model_status = gr.HTML(_status_html(), elem_classes=["ce-status-inline"])
+            model_status = gr.HTML(_model_icon(), elem_classes=["ce-status-inline"])
 
         state = gr.State()
         part = gr.State({"geometry": None, "mesh": None, "label": None, "read": None})
@@ -627,9 +814,22 @@ def build() -> gr.Blocks:
         with gr.Tabs() as tabs:
             # ───────────────────────── BUILD · define the job ────────────────────────
             with gr.Tab("LOAD", id="studio"):
-                # Top row: ENVIRONMENT readout (left) + RESET/SLICE (right) on the same line.
+                # Top row: ENVIRONMENT + POSITION + MATERIAL readouts on the left,
+                # RANDOMIZE / OVERRIDE / RESET / SLICE on the right.
                 with gr.Row(elem_classes=["ce-actionbar", "ce-envbar"]):
                     sensors_readout = gr.HTML(elem_classes=["ce-envbar-readout"])
+                    with gr.Column(elem_classes=["ce-inline-group"]):
+                        gr.HTML("<div class='ce-inline-label'>POSITION"
+                                "<span class='ce-callout' tabindex='0'>" + icon("info", size=10) +
+                                "<span class='ce-tip'>edges/corners run cooler → warp/adhesion risk</span>"
+                                "</span></div>")
+                        bed_position = gr.Radio(BED_POSITIONS, value="center", show_label=False,
+                                                elem_classes=["ce-pills"])
+                    with gr.Column(elem_classes=["ce-inline-group"]):
+                        gr.HTML("<div class='ce-inline-label'>MATERIAL</div>")
+                        material = gr.Radio(MATERIALS, value="PLA", show_label=False, elem_classes=["ce-pills"])
+                    # spacer pushes the action buttons to the right edge
+                    gr.HTML("<div style='flex:1;'></div>")
                     roll_btn = gr.Button("RANDOMIZE",
                                          elem_classes=["ce-pillbtn", "ce-icon-shuffle"], scale=0)
                     gr.HTML("<button class='ce-pillbtn ce-icon-sliders' "
@@ -639,26 +839,10 @@ def build() -> gr.Blocks:
                             "text-transform:uppercase;letter-spacing:.5px;font-size:12px;"
                             "font-weight:700;cursor:pointer;display:inline-flex;"
                             "align-items:center;gap:6px;'>OVERRIDE</button>")
-                    # spacer pushes the action buttons to the right edge
-                    gr.HTML("<div style='flex:1;'></div>")
                     reset_s = gr.Button("RESET", elem_classes=["ce-pillbtn", "ce-act"], scale=0)
                     run_btn = gr.Button("SLICE", variant="primary",
                                         elem_classes=["ce-act"], elem_id="ce-run", scale=0)
 
-                # 2-column setup: BUILD-PLATE POSITION | MATERIAL
-                # (NOTES moved into PART card; ENVIRONMENT moved into action bar above)
-                with gr.Row(equal_height=False, elem_classes=["ce-loadrow"]):
-                    with gr.Column(scale=2, min_width=320):
-                        gr.HTML(rule("BUILD-PLATE POSITION"))
-                        gr.HTML("<div class='ce-sub' style='margin:-2px 0 4px;'>"
-                                "edges/corners run cooler → warp/adhesion risk</div>")
-                        bed_position = gr.Radio(BED_POSITIONS, value="center", show_label=False,
-                                                elem_classes=["ce-pills"])
-                    with gr.Column(scale=1, min_width=220):
-                        gr.HTML(rule("MATERIAL"))
-                        material = gr.Radio(MATERIALS, value="PLA", show_label=False, elem_classes=["ce-pills"])
-                        gr.HTML(_model_callout())
-
                 # OVERRIDE ENVIRONMENT popup (hidden by default; toggled via JS)
                 gr.HTML("<div class='ce-popup-backdrop' data-popup-backdrop='override'></div>")
                 with gr.Group(elem_classes=["ce-popup"], elem_id="ce-popup-override"):
@@ -679,17 +863,13 @@ def build() -> gr.Blocks:
                         with gr.Column(scale=3, elem_classes=["ce-part-viewer-col"]):
                             part_placeholder = gr.HTML(_viewer_placeholder())
                             model3d = gr.Model3D(value=None, label="", height=360, visible=False)
-                            # NOTES moved here — lives next to the part view always
-                            description = gr.Textbox(label="NOTES (OPTIONAL)",
-                                                     placeholder="e.g. 45° bracket, 60mm tall",
-                                                     elem_classes=["ce-notes-inline"])
                             # intro + job log moved DOWN into the part area
                             gr.HTML(tab_intro("Load the part, set the material and the room, then "
                                               "<b>SLICE</b> to read the engineer's pre-flight check. "
                                               "You give it the part, the material, and the room; it "
                                               "infers what kind of part this is."))
                             studio_log = gr.HTML(studio_log_html())
-                        # RIGHT: dropzone TOP, then two matching-style mesh-source buttons
+                        # RIGHT: dropzone + mesh-source buttons + NOTES
                         with gr.Column(scale=1, elem_classes=["ce-part-actions-col"]):
                             mesh_in = gr.File(file_types=[".stl", ".glb", ".obj"],
                                               label="UPLOAD MESH", show_label=False,
@@ -704,49 +884,55 @@ def build() -> gr.Blocks:
                                                     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"], scale=0)
+                            description = gr.Textbox(label="NOTES (OPTIONAL)",
+                                                     placeholder="e.g. 45° bracket, 60mm tall",
+                                                     elem_classes=["ce-notes-inline"])
 
             # ───────────────── SLICE · slice + analyze + pre-flight check ─────────────
             with gr.Tab("SLICE", id="build"):
                 reset_b, to_print_btn = _action_bar(primary_label="PRINT (RUN ITERATIONS)")
                 gr.HTML(tab_intro("The pre-flight check, <b>before it prints</b>: slice the part, read "
                                   "precedent, flag failures, and get a second opinion. Then → PRINT."))
-                build_loader = gr.HTML()
                 with gr.Group(visible=False, elem_classes=["ce-part-card"]) as build_results:
                     # slice + motion preview side by side — grouped like LOAD's PART card
                     gr.HTML(rule("SLICE · CROSS-SECTION"))
                     with gr.Row(equal_height=False, elem_classes=["ce-part-row"]):
                         with gr.Column(scale=3):
                             vp_layer = gr.Image(label="", height=360, show_label=False)
-                        with gr.Column(scale=1, elem_classes=["ce-vslider"]):
-                            vp_slider = gr.Slider(1, SCRUB_LAYERS, value=1, step=1, label="LAYER")
-                        with gr.Column(scale=1, min_width=280):
+                        with gr.Column(scale=1, elem_classes=["ce-vp"]):
                             gr.HTML(rule("MOTION PREVIEW"))
                             vprint = gr.HTML()
-                    gr.HTML("<div class='ce-sub' style='padding:0 12px;'>Slide the LAYER control through real cross-sections of "
-                            "<i>this</i> part at full mesh fidelity; the preview animates the rise.</div>")
+                    with gr.Column(elem_classes=["ce-hslider"]):
+                        vp_slider = gr.Slider(1, SCRUB_LAYERS, value=1, step=1,
+                                               show_label=False, container=False)
+                    gr.HTML("<div class='ce-sub' style='padding:0 12px;'>Scrub through real cross-sections of "
+                            "<i>this</i> part at full mesh fidelity. The preview animates the layer rise "
+                            "while the read loads below.</div>")
 
                     # Engineer's Read ↔ Second Opinion (one panel at a time)
-                    backend = gr.Markdown()
-                    gr.HTML(rule("THE READ"))
-                    read_toggle = gr.Radio(["Engineer's Read", "Second Opinion"],
-                                           value="Engineer's Read", show_label=False,
-                                           elem_classes=["ce-seg"])
-                    with gr.Group(visible=True, elem_classes=["ce-card"]) as eng_read_group:
-                        precedent = gr.HTML(elem_id="ce-precedent")
-                        reasoning = gr.Markdown(elem_id="ce-reasoning")
-                        risks = gr.HTML()
-                        gr.HTML(rule("VALIDATION + G-CODE"))
-                        spine_notes = gr.Markdown()
-                        with gr.Row(equal_height=False):
-                            settings_html = gr.HTML()
-                            gcode_html = gr.HTML()
-                        confirm_btn = gr.Button("CONFIRM & PRINT", elem_id="ce-confirm", visible=False)
-                    with gr.Group(visible=False, elem_classes=["ce-card"]) as second_op_group:
-                        gr.HTML("<div class='ce-sub' style='padding:0 12px;'>A separate inspector — <b>La Forge</b> — reviews "
+                    with gr.Group(visible=False, elem_classes=["ce-card"]) as read_results:
+                        backend = gr.Markdown()
+                        gr.HTML(rule("THE READ"))
+                        read_loader = gr.HTML()
+                        read_toggle = gr.Radio(["Engineer's Read", "Second Opinion"],
+                                               value="Engineer's Read", show_label=False,
+                                               elem_classes=["ce-seg"])
+                        with gr.Group(visible=True, elem_classes=["ce-card"]) as eng_read_group:
+                            precedent = gr.HTML(elem_id="ce-precedent")
+                            reasoning = gr.Markdown(elem_id="ce-reasoning")
+                            risks = gr.HTML()
+                            gr.HTML(rule("VALIDATION + G-CODE"))
+                            spine_notes = gr.Markdown()
+                            with gr.Row(equal_height=False):
+                                settings_html = gr.HTML()
+                                gcode_html = gr.HTML()
+                            confirm_btn = gr.Button("CONFIRM & PRINT", elem_id="ce-confirm", visible=False)
+                        with gr.Group(visible=False, elem_classes=["ce-card"]) as second_op_group:
+                            gr.HTML("<div class='ce-sub' style='padding:0 12px;'>A separate inspector — <b>La Forge</b> — reviews "
                                     "the plan before it prints: O'Brien is an optimist, La Forge is not.</div>")
-                        second_opinion_panel = gr.HTML()
-                        override_btn = gr.Button("PRINT ANYWAY (I'VE REVIEWED THE OBJECTION)",
-                                                 visible=False, elem_classes=["ce-pillbtn"])
+                            second_opinion_panel = gr.HTML()
+                            override_btn = gr.Button("PRINT ANYWAY (I'VE REVIEWED THE OBJECTION)",
+                                                     visible=False, elem_classes=["ce-pillbtn"])
 
             # ──────────────────── PRINT · run it, iterate, grade ─────────────────────
             with gr.Tab("PRINT", id="print"):
@@ -754,27 +940,55 @@ def build() -> gr.Blocks:
                 gr.HTML(tab_intro("Print <b>this job</b> (inherited from Build). The Engineer proposes → "
                                   "the Spine vetoes → a <b>simulated world</b> prints → the <b>Inspector "
                                   "grades</b> → policy + ledger learn. Quality compounds fail→clean."))
-                p_job = gr.HTML(job_readout(None))
-                with gr.Group(elem_classes=["ce-card"]):
-                    gr.HTML(rule("RUN"))
-                    p_iters = gr.Slider(1, 16, value=8, step=1,
-                                        label="ITERATIONS  (1 = a single print)")
-                    gr.HTML("<div class='ce-sub'>Press <b>PRINT</b> (top right) to run. The Inspector "
-                            "grades each run as part of the iteration.</div>")
+
+                # ENVBAR: job readout | iteration chip | VARY
+                with gr.Row(elem_classes=["ce-actionbar", "ce-envbar"]):
+                    p_job = gr.HTML(job_readout(None), elem_classes=["ce-envbar-readout"])
+                    p_iter_readout = gr.HTML(
+                        "<div class='ce-sub' style='text-align:center;'><b>8</b> ITERATIONS</div>")
+                    gr.HTML("<div style='flex:1;'></div>")
+                    vary_btn = gr.Button("VARY", elem_classes=["ce-pillbtn"], scale=0)
+
+                # THE PLAN card
+                with gr.Group(elem_classes=["ce-card"]) as plan_card:
+                    gr.HTML(rule("THE PLAN"))
+                    plan_settings = gr.HTML()
+                    plan_verdict = gr.HTML()
+
+                # ITERATIONS hslider + explainer
+                with gr.Column(elem_classes=["ce-hslider"]):
+                    p_iters = gr.Slider(1, 16, value=8, step=1, show_label=False, container=False)
+                gr.HTML("<div class='ce-sub' style='margin:-8px 0 10px;'>"
+                        "1 = single print · 4 = quick convergence · 8 = balanced climb · 16 = full convergence run"
+                        "</div>")
+
+                # VARY override panel
+                with gr.Group(visible=False, elem_classes=["ce-card"]) as vary_group:
+                    gr.HTML(rule("OPERATOR OVERRIDE"))
+                    gr.HTML("<div class='ce-sub' style='border-left:3px solid var(--ao-red);padding:6px 10px;'>"
+                            + icon("alert") + " You are overriding the Engineer's plan. The run will use "
+                            "these settings instead of the Spine-validated proposal.</div>")
+                    with gr.Row():
+                        p_nozzle = gr.Slider(150, 300, value=200, step=1,
+                                             label="NOZZLE °C", elem_classes=["ce-num"])
+                        p_bed = gr.Slider(40, 120, value=60, step=1,
+                                          label="BED °C", elem_classes=["ce-num"])
+                        p_fan = gr.Slider(0, 100, value=80, step=1,
+                                          label="FAN %", elem_classes=["ce-num"])
+                        p_retract = gr.Slider(0, 10, value=4.5, step=0.1,
+                                              label="RETRACTION mm", elem_classes=["ce-num"])
+                    reset_plan_btn = gr.Button("RESET TO ENGINEER'S PLAN", elem_classes=["ce-pillbtn"])
 
                 with gr.Group(visible=False) as results_group:
+                    gr.HTML(rule("OUTCOME"))
+                    outcome_panel = gr.HTML()
                     p_headline = gr.Markdown()
-                    with gr.Row():
-                        with gr.Column(scale=3):
-                            gr.HTML(rule("QUALITY PER ITERATION"))
-                            p_curve = gr.HTML()
-                        with gr.Column(scale=2):
-                            gr.HTML(rule("ITERATION LOG"))
-                            p_log = gr.HTML()
+                    gr.HTML(rule("QUALITY PER ITERATION"))
+                    p_curve = gr.HTML()
+                    gr.HTML(rule("ITERATION LOG"))
+                    p_log = gr.HTML()
                     gr.HTML(rule("LEARNED POLICY CELL"))
                     p_policy = gr.HTML()
-                    gr.HTML(rule("OUTCOME"))
-                    outcome_panel = gr.HTML()
                     # compact secondary zone (~20%): log a REAL print back into the ledger
                     with gr.Row(elem_classes=["ce-card"]):
                         with gr.Column(scale=1):
@@ -810,7 +1024,8 @@ def build() -> gr.Blocks:
         # ── wiring ──
         reset_outs = _reset_outputs(ledger_panel, node_cards, review_summary, p_curve, p_policy,
                                     p_log, p_headline, outcome_panel, results_group, real_log_msg,
-                                    studio_log)
+                                    studio_log, part, model3d, part_placeholder, part_status,
+                                    build_results, read_results, tabs)
         preview_outs = [part, model3d, part_status, part_placeholder]
         foot_in = [part, material, temp, humidity, bed_position]
         benchy_btn.click(load_benchy, None, preview_outs).then(status_footer, foot_in, [footer])
@@ -836,11 +1051,12 @@ def build() -> gr.Blocks:
 
         # Two-step BUILD: instant loader + tab-switch, then the heavy model call (reveals
         # the results), then refresh the inherited-job readout on the Print tab.
-        build_start_outs = [tabs, build_loader, build_results, to_print_btn, override_btn,
-                            second_opinion_panel, read_toggle, eng_read_group, second_op_group]
+        build_start_outs = [tabs, build_results, read_results, read_loader, vprint, vp_slider,
+                            vp_layer, to_print_btn, override_btn, second_opinion_panel,
+                            read_toggle, eng_read_group, second_op_group]
         build_outs = [backend, precedent, reasoning, risks, settings_html, spine_notes,
                       gcode_html, confirm_btn, node_cards, state, vprint, vp_slider, vp_layer,
-                      build_loader, build_results]
+                      read_loader]
         run_btn.click(build_start, [part], build_start_outs).then(
             build_job, [part, material, description, temp, humidity, bed_position, model_select],
             build_outs).then(job_readout, [state], [p_job])
@@ -848,17 +1064,22 @@ def build() -> gr.Blocks:
         vp_slider.change(scrub_layer, [vp_slider, part], [vp_layer])
         read_toggle.change(toggle_read, [read_toggle, state],
                            [eng_read_group, second_op_group, second_opinion_panel,
-                            to_print_btn, override_btn])
+                            to_print_btn, override_btn, state])
         override_btn.click(ack_override, state, [to_print_btn, override_btn])
         to_print_btn.click(lambda: gr.Tabs(selected="print"), None, [tabs]).then(
             None, None, None, js=_SCROLL_TOP)
-        tabs.select(job_readout, [state], [p_job])
+        tabs.select(refresh_print_tab, [state], [p_job, plan_settings, plan_verdict])
 
         # PRINT: run the loop on THIS job (slider 1 = single print), or log a real outcome.
-        print_outs = [results_group, p_headline, p_curve, p_log, p_policy, outcome_panel,
+        print_outs = [results_group, outcome_panel, p_headline, p_curve, p_log, p_policy,
                       ledger_panel, node_cards, review_summary]
-        p_run.click(run_print, [state, p_iters], print_outs).then(
+        p_run.click(lambda: gr.update(visible=False), None, [vary_group]).then(
+            run_print, [state, p_iters, p_nozzle, p_bed, p_fan, p_retract], print_outs).then(
             None, None, None, js=_SCROLL_TOP)
+        p_iters.change(lambda v: f"<div class='ce-sub' style='text-align:center;'><b>{int(v)}</b> ITERATIONS</div>",
+                       [p_iters], [p_iter_readout])
+        vary_btn.click(open_vary_panel, [state], [vary_group, p_nozzle, p_bed, p_fan, p_retract])
+        reset_plan_btn.click(open_vary_panel, [state], [vary_group, p_nozzle, p_bed, p_fan, p_retract])
         for btn, oc in [(b_clean, "success"), (b_sag, "failed_sag"), (b_string, "failed_stringing")]:
             btn.click(record_outcome, [gr.State(oc), state], [real_log_msg, ledger_panel, node_cards])
 

core/chief_engineer.py

@@ -16,10 +16,10 @@ from .prompts import build_system_prompt
 
 # Conservative per-material starting points for the offline/parse-fail fallback.
 _FALLBACK_SETTINGS: dict[str, dict[str, float]] = {
-    "PLA":  {"nozzle_temp": 205, "bed_temp": 60, "retraction_mm": 5, "fan_pct": 100, "first_layer_fan_pct": 0},
-    "PETG": {"nozzle_temp": 235, "bed_temp": 80, "retraction_mm": 4, "fan_pct": 40, "first_layer_fan_pct": 0},
-    "ABS":  {"nozzle_temp": 245, "bed_temp": 100, "retraction_mm": 4, "fan_pct": 20, "first_layer_fan_pct": 0},
-    "TPU":  {"nozzle_temp": 228, "bed_temp": 50, "retraction_mm": 2, "fan_pct": 40, "first_layer_fan_pct": 0},
+    "PLA":  {"nozzle_temp": 205, "bed_temp": 60, "retraction_mm": 5, "fan_pct": 100, "first_layer_fan_pct": 0, "layer_height": 0.20},
+    "PETG": {"nozzle_temp": 235, "bed_temp": 80, "retraction_mm": 4, "fan_pct": 40, "first_layer_fan_pct": 0, "layer_height": 0.20},
+    "ABS":  {"nozzle_temp": 245, "bed_temp": 100, "retraction_mm": 4, "fan_pct": 20, "first_layer_fan_pct": 0, "layer_height": 0.20},
+    "TPU":  {"nozzle_temp": 228, "bed_temp": 50, "retraction_mm": 2, "fan_pct": 40, "first_layer_fan_pct": 0, "layer_height": 0.24},
 }
 _GEOMETRY_RISK = {
     "overhang": ("underside of the overhang", "sag", "steep overhangs droop before the layer freezes", "overhang"),

core/models.py

@@ -37,6 +37,7 @@ class PrintSettings(BaseModel):
     retraction_mm: float
     fan_pct: float
     first_layer_fan_pct: float
+    layer_height: float = 0.2  # mm — drives virtual-print preview cross-sections
 
 
 class RiskRegion(BaseModel):

core/prompts.py

@@ -27,7 +27,7 @@ OUTPUT_CONTRACT = """Respond ONLY with valid JSON, no prose outside it, in exact
   "reasoning": "2-4 sentences. START with your evaluation of the prior jobs: what transfers, what doesn't, and why. Then the decision.",
   "settings": {
     "nozzle_temp": <C>, "bed_temp": <C>, "retraction_mm": <mm>,
-    "fan_pct": <0-100>, "first_layer_fan_pct": <0-100>
+    "fan_pct": <0-100>, "first_layer_fan_pct": <0-100>, "layer_height": <mm, e.g. 0.12-0.28>
   },
   "risks": [
     {"location": "where on the part", "risk": "sag|stringing|adhesion|warping|delamination",

core/spine.py

@@ -23,6 +23,7 @@ COMMON_BOUNDS: dict[str, tuple[float, float]] = {
     "retraction_mm": (0.5, 8.0),
     "fan_pct": (0.0, 100.0),
     "first_layer_fan_pct": (0.0, 30.0),
+    "layer_height": (0.08, 0.60),
 }
 
 

core/theme.py

@@ -202,31 +202,20 @@ textarea:focus, input:focus {{ border-color:var(--ao-orange) !important; box-sha
 .ce-icon-arrow::before {{ -webkit-mask-image:url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='black' stroke-width='2.4' stroke-linecap='round' stroke-linejoin='round'><path d='M5 12h14 M13 5l7 7-7 7'/></svg>"); mask-image:url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='black' stroke-width='2.4' stroke-linecap='round' stroke-linejoin='round'><path d='M5 12h14 M13 5l7 7-7 7'/></svg>"); }}
 
 /* Arrow AFTER text (right-side icon — indicates "next step"). For buttons whose
-   label means "proceed to next stage" (SLICE →, PRINT →, REFRESH →). */
-.ce-icon-arrow-after::after {{
-  content:""; display:inline-block; width:14px; height:14px;
-  margin-left:8px; vertical-align:-2px;
-  background:currentColor; -webkit-mask-size:contain; mask-size:contain;
-  -webkit-mask-repeat:no-repeat; mask-repeat:no-repeat;
-  -webkit-mask-position:center; mask-position:center;
-  -webkit-mask-image:url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='black' stroke-width='2.4' stroke-linecap='round' stroke-linejoin='round'><path d='M5 12h14 M13 5l7 7-7 7'/></svg>");
-  mask-image:url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='black' stroke-width='2.4' stroke-linecap='round' stroke-linejoin='round'><path d='M5 12h14 M13 5l7 7-7 7'/></svg>");
-}}
-/* Inside a Gradio button the label is nested in a <span> — attach to button so
-   the ::after lands at the end of the visible label, not after the wrapper. */
-.ce-icon-arrow-after button::after, button.ce-icon-arrow-after::after {{
-  content:""; display:inline-block; width:14px; height:14px;
-  margin-left:8px; vertical-align:-2px;
+   label means "proceed to next stage" (SLICE →, PRINT →, REFRESH →).
+   Gradio wraps each button in a .wrap; elem_classes lands on that wrapper, so we
+   target the label <span> inside the <button> and append the arrow as an SVG
+   mask-image pseudo-element. */
+.ce-icon-arrow-after button {{ display:inline-flex !important; align-items:center !important; gap:4px !important; }}
+.ce-icon-arrow-after button span::after {{
+  content:""; display:inline-block; width:14px; height:14px; flex:0 0 14px;
+  margin-left:4px; vertical-align:-2px;
   background:currentColor; -webkit-mask-size:contain; mask-size:contain;
   -webkit-mask-repeat:no-repeat; mask-repeat:no-repeat;
   -webkit-mask-position:center; mask-position:center;
   -webkit-mask-image:url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='black' stroke-width='2.4' stroke-linecap='round' stroke-linejoin='round'><path d='M5 12h14 M13 5l7 7-7 7'/></svg>");
   mask-image:url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='black' stroke-width='2.4' stroke-linecap='round' stroke-linejoin='round'><path d='M5 12h14 M13 5l7 7-7 7'/></svg>");
 }}
-/* But ALSO put one inside the inner span so it appears flush with the label text */
-.ce-icon-arrow-after button span::after {{
-  content:"\2192"; margin-left:6px; font-weight:900; opacity:.95;
-}}
 
 /* ── TAB ICONS (CSS-only via :nth-child on the four workflow tabs) ── */
 /* Tab bar order is fixed: LOAD · SLICE · PRINT · REVIEW. Each gets its own icon
@@ -585,6 +574,48 @@ CSS += """
 /* model switcher pills sit in the header row — KEEP concise, don't conflict with main rule */
 #ce-modelswitch .ce-seg label {{ font-size:11px !important; padding:5px 12px !important; }}
 
+/* compact inline pill groups inside the envbar (BUILD-PLATE POSITION + MATERIAL) */
+.ce-envbar .ce-inline-group { display:flex !important; flex-direction:column !important;
+  gap:3px !important; margin:0 10px !important; }
+.ce-envbar .ce-inline-label { color:var(--ao-orange); font-size:10px !important;
+  letter-spacing:1.5px; text-transform:uppercase; font-weight:700;
+  display:flex !important; align-items:center !important; gap:4px; }
+.ce-envbar .ce-inline-label .ce-callout { font-size:10px !important; }
+.ce-envbar .ce-inline-label .ce-tip { width:280px; top:120%; }
+/* inline pills are smaller than the full-width ones */
+.ce-envbar .ce-pills label { padding:4px 10px !important; font-size:11px !important; }
+.ce-envbar .ce-pills label span { display:inline-flex !important; align-items:center !important;
+  gap:5px !important; }
+/* pill icons by value (small, before the label text) */
+.ce-pills label:has(input[value="center"]) span::before,
+.ce-pills label:has(input[value="edge"]) span::before,
+.ce-pills label:has(input[value="corner"]) span::before,
+.ce-pills label:has(input[value="PLA"]) span::before,
+.ce-pills label:has(input[value="PETG"]) span::before,
+.ce-pills label:has(input[value="ABS"]) span::before,
+.ce-pills label:has(input[value="TPU"]) span::before {
+  content:""; display:inline-block; width:11px; height:11px; flex:0 0 11px;
+  background:currentColor; -webkit-mask-size:contain; mask-size:contain;
+  -webkit-mask-repeat:no-repeat; mask-repeat:no-repeat;
+  -webkit-mask-position:center; mask-position:center; }
+.ce-pills label:has(input[value="center"]) span::before {
+  -webkit-mask-image:url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='black' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'><path d='M12 2v3 M12 19v3 M2 12h3 M19 12h3 M12 7a5 5 0 100 10 5 5 0 000-10z'/></svg>");
+  mask-image:url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='black' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'><path d='M12 2v3 M12 19v3 M2 12h3 M19 12h3 M12 7a5 5 0 100 10 5 5 0 000-10z'/></svg>"); }
+.ce-pills label:has(input[value="edge"]) span::before {
+  -webkit-mask-image:url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='black' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'><path d='M4 4h16v16H4z M4 4v16'/></svg>");
+  mask-image:url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='black' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'><path d='M4 4h16v16H4z M4 4v16'/></svg>"); }
+.ce-pills label:has(input[value="corner"]) span::before {
+  -webkit-mask-image:url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='black' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'><path d='M4 4h16v16H4z M4 4v7 M4 4h7'/></svg>");
+  mask-image:url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='black' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'><path d='M4 4h16v16H4z M4 4v7 M4 4h7'/></svg>"); }
+.ce-pills label:has(input[value="PLA"]) span::before,
+.ce-pills label:has(input[value="PETG"]) span::before,
+.ce-pills label:has(input[value="ABS"]) span::before,
+.ce-pills label:has(input[value="TPU"]) span::before {
+  -webkit-mask-image:url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='black' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'><path d='M12 2.5C12 2.5 5 10 5 14a7 7 0 0014 0c0-4-7-11.5-7-11.5z'/></svg>");
+  mask-image:url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='black' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'><path d='M12 2.5C12 2.5 5 10 5 14a7 7 0 0014 0c0-4-7-11.5-7-11.5z'/></svg>"); }
+/* tighten space below the envbar so the PART card sits directly under it */
+.ce-envbar { margin-bottom:2px !important; }
+
 /* hover callout (info icon next to the model switcher) */
 .ce-callout { position:relative; display:inline-flex; align-items:center; gap:4px; cursor:help;
   color:var(--ao-orange); font-size:11px; letter-spacing:1px; text-transform:uppercase; }
@@ -716,6 +747,8 @@ _ICONS: dict[str, tuple[str, bool]] = {
     "thermo": ("M14 14V5a2 2 0 10-4 0v9a4 4 0 104 0z", False),
     "droplet": ("M12 2.5C12 2.5 5 10 5 14a7 7 0 0014 0c0-4-7-11.5-7-11.5z", False),
     "target": ("M12 2v3 M12 19v3 M2 12h3 M19 12h3 M12 7a5 5 0 100 10 5 5 0 000-10z", False),
+    "edge": ("M4 4h16v16H4z M4 4v16", False),
+    "corner": ("M4 4h16v16H4z M4 4v7 M4 4h7", False),
     "printer": ("M6 9V2h12v7 M6 18H4a2 2 0 01-2-2v-4a2 2 0 012-2h16a2 2 0 012 2v4a2 2 0 01-2 2h-2 "
                 "M6 14h12v8H6z", False),
     "play": ("M6 4l14 8-14 8V4z", True),

core/viewer.py

@@ -288,6 +288,7 @@ def gcode_readout(settings: PrintSettings, material: str) -> str:
     """Short snippet whose header lines come from the proposed settings."""
     return "\n".join([
         f"; Chief Engineer — start g-code for {material} (header tied to recommendation)",
+        f"; layer height {settings.layer_height:.2f} mm",
         f"M140 S{settings.bed_temp:.0f}      ; set bed",
         f"M104 S{settings.nozzle_temp:.0f}   ; set nozzle",
         f"M190 S{settings.bed_temp:.0f}      ; wait for bed",
@@ -328,9 +329,10 @@ def quality_curve_html(trajectory: list[float], threshold: float = 0.7) -> str:
     )
 
 
-def iteration_log_html(records, verdicts=None) -> str:
+def iteration_log_html(records, verdicts=None, timings=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."""
+    Inspector's terse grade on each run — the second voice in the loop.
+    `timings` (optional, aligned to records) adds per-iteration elapsed ms."""
     rows = []
     for i, r in enumerate(records):
         clean = r.result.outcome == "success"
@@ -339,6 +341,10 @@ def iteration_log_html(records, verdicts=None) -> str:
         if verdicts and i < len(verdicts) and verdicts[i] is not None:
             v = verdicts[i]
             insp = (f"<br><span style='color:{v.color};'>{icon('search')} inspector [{v.stance}]: {v.headline}</span>")
+        timing = ""
+        if timings and i < len(timings):
+            timing = (f"<span style='float:right;color:var(--ao-outline);'>"
+                      f"+{timings[i]*1000:.0f}ms</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);'>"
@@ -346,7 +352,7 @@ def iteration_log_html(records, verdicts=None) -> 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>{insp}</div>"
+            + f"{timing}<br><span style='color:var(--ao-outline);'>↳ {r.learned}</span>{insp}</div>"
         )
     return "".join(rows)
 

core/widgets.py

@@ -20,7 +20,7 @@ from pathlib import Path
 _ISO = 0.55  # oblique projection skew, matches sim/virtual_printer
 
 
-def _projected_layers(mesh_path: str | Path, layer_height_mm: float = 0.8,
+def _projected_layers(mesh_path: str | Path, layer_height_mm: float = 0.2,
                       max_layers: int = 44, max_segs_per_layer: int = 520) -> dict:
     """Slice the mesh and return projected 2D polylines per layer + bounds.
 
@@ -134,22 +134,30 @@ def layer_image(mesh_path: str | Path | None, idx: int, n: int = SCRUB_LAYERS,
     return np.asarray(img)
 
 
-def virtual_printer_html(mesh_path: str | Path | None, caption: str = "") -> str:
-    """A live virtual-printer canvas for the cockpit (animated by VP_JS)."""
+def virtual_printer_html(mesh_path: str | Path | None,
+                         settings: "PrintSettings | None" = None,
+                         caption: str = "") -> str:
+    """A live virtual-printer canvas for the cockpit (animated by VP_JS).
+
+    Uses the layer height from the proposed PrintSettings so the preview is tied
+    to the actual recommendation rather than a hard-coded default.
+    """
     if not mesh_path or not Path(str(mesh_path)).exists():
         return ("<div class='ce-rule'>VIRTUAL PRINT</div>"
                 "<div class='ce-sub'>run a recommendation to slice the part →</div>")
-    data = _projected_layers(mesh_path)
+    layer_height = settings.layer_height if settings else 0.2
+    data = _projected_layers(mesh_path, layer_height_mm=layer_height)
     if not data:
         return ("<div class='ce-rule'>VIRTUAL PRINT</div>"
                 "<div class='ce-sub'>mesh too thin to slice.</div>")
     payload = json.dumps(data).replace("'", "&#39;")
+    lh_note = f"{layer_height:.2f} mm layers"
     return (
         "<div class='ce-rule'>VIRTUAL PRINT</div>"
         "<div style='border:1px solid var(--ao-outline-dim);background:#0a0c14;'>"
         f"<canvas class='ce-vp' width='520' height='300' data-vp='{payload}' "
         "style='width:100%;height:auto;display:block;'></canvas></div>"
-        f"<div class='ce-sub' style='margin-top:2px;'>{caption} · real cross-sections of "
+        f"<div class='ce-sub' style='margin-top:2px;'>{caption} · {lh_note} · real cross-sections of "
         "this part, layer by layer (motion preview — not a slicer)</div>"
     )
 

dist/deliberation/deliberations.jsonl

@@ -1,29 +1,29 @@
-{"session_id": "abs-overhang-edge", "track": "preflight", "turn": 1, "agent": "O'Brien", "role": "Chief Engineer", "act": "propose", "stance": "", "content": "No close precedent exists, so I reason from ABS properties and the current environment. ABS is prone to warping and requires high thermal management; 26°C ambient is acceptable but not ideal. The overhang geometry demands careful temperature control to prevent sag or delamination. We must set temps aggressively to keep the plastic fluid enough for the overhang while minimizing residual stress.\nProposed: nozzle 255°C, bed 100°C, fan 30%, first-layer fan 0%, retraction 4.0mm.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:00:07+00:00"}
+{"session_id": "abs-overhang-edge", "track": "preflight", "turn": 1, "agent": "O'Brien", "role": "Chief Engineer", "act": "propose", "stance": "", "content": "No close precedent exists. ABS is high warp material, and overhangs amplify this risk significantly. The room temp (26°C) is moderate but requires active thermal management to prevent warping during cooling. We must maintain a stable thermal gradient from the bed up through the print area. I will use established ABS parameters for adhesion and minimize forced air.\nProposed: nozzle 255°C, bed 100°C, fan 30%, first-layer fan 0%, retraction 4.0mm.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:00:07+00:00"}
 {"session_id": "abs-overhang-edge", "track": "preflight", "turn": 2, "agent": "Spine", "role": "Safety Spine", "act": "veto", "stance": "clear", "content": "Within the safe envelope for this material — no clamp.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:00:14+00:00"}
-{"session_id": "abs-overhang-edge", "track": "preflight", "turn": 3, "agent": "La Forge", "role": "QA Inspector", "act": "second_opinion", "stance": "dispute", "content": "Temperatures are too aggressive and unvalidated. — The proposed high temps increase warping risk significantly, especially with unknown thermal chamber performance.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:00:21+00:00"}
-{"session_id": "abs-overhang-edge", "track": "preflight", "turn": 4, "agent": "Operator", "role": "Operator", "act": "override", "stance": "override", "content": "Acknowledged La Forge's objection. Proceeding to print on the operator's call.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:00:28+00:00"}
-{"session_id": "abs-overhang-edge", "track": "print-loop", "turn": 5, "agent": "World", "role": "Outcome Simulator", "act": "simulate", "stance": "failed_sag", "content": "Iteration 1: sag (quality 0.19, dominant cost: sag). Policy: ABS/overhang/mid/humid: sag (q=0.19) — learned: fan_pct +12, nozzle_temp -3.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:00:35+00:00"}
-{"session_id": "abs-overhang-edge", "track": "print-loop", "turn": 6, "agent": "La Forge", "role": "QA Inspector", "act": "grade", "stance": "confirmed", "content": "Failed on sagging — exactly as called. — Quality 0.19. The Engineer's risk flag was right; the loop now has the lesson.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:00:42+00:00"}
-{"session_id": "abs-overhang-edge", "track": "print-loop", "turn": 7, "agent": "World", "role": "Outcome Simulator", "act": "simulate", "stance": "failed_sag", "content": "Iteration 2: sag (quality 0.27, dominant cost: sag). Policy: ABS/overhang/mid/humid: sag (q=0.27) — learned: fan_pct +12, nozzle_temp -3.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:00:49+00:00"}
-{"session_id": "abs-overhang-edge", "track": "print-loop", "turn": 8, "agent": "La Forge", "role": "QA Inspector", "act": "grade", "stance": "confirmed", "content": "Failed on sagging — exactly as called. — Quality 0.27. The Engineer's risk flag was right; the loop now has the lesson.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:00:56+00:00"}
-{"session_id": "abs-overhang-edge", "track": "print-loop", "turn": 9, "agent": "World", "role": "Outcome Simulator", "act": "simulate", "stance": "failed_sag", "content": "Iteration 3: sag (quality 0.33, dominant cost: sag). Policy: ABS/overhang/mid/humid: sag (q=0.33) — learned: fan_pct +12, nozzle_temp -3.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:01:03+00:00"}
-{"session_id": "abs-overhang-edge", "track": "print-loop", "turn": 10, "agent": "La Forge", "role": "QA Inspector", "act": "grade", "stance": "confirmed", "content": "Failed on sagging — exactly as called. — Quality 0.33. The Engineer's risk flag was right; the loop now has the lesson.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:01:10+00:00"}
-{"session_id": "abs-overhang-edge", "track": "print-loop", "turn": 11, "agent": "World", "role": "Outcome Simulator", "act": "simulate", "stance": "failed_sag", "content": "Iteration 4: warp (quality 0.34, dominant cost: warp). Policy: ABS/overhang/mid/humid: warp (q=0.34) — learned: fan_pct -10.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:01:17+00:00"}
-{"session_id": "abs-overhang-edge", "track": "print-loop", "turn": 12, "agent": "La Forge", "role": "QA Inspector", "act": "grade", "stance": "missed", "content": "Failed on warping — and it wasn't flagged. — Quality 0.34. The Engineer didn't predict this mode. That gap is what the next iteration has to close.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:01:24+00:00"}
-{"session_id": "abs-overhang-edge", "track": "review", "turn": 13, "agent": "La Forge", "role": "QA Inspector", "act": "verdict", "stance": "caution", "content": "Improving but not yet clean (best 0.34). — Quality rose 0.19 → 0.34 over 4 runs but never crossed the bar. More iterations or a different lever needed — the loop is learning, slowly.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:01:31+00:00"}
-{"session_id": "petg-overhang-center", "track": "preflight", "turn": 1, "agent": "O'Brien", "role": "Chief Engineer", "act": "propose", "stance": "", "content": "The prior job [1] is the closest precedent, involving PETG and an overhang. The lesson learned—that PETG needs a cooling compromise—is critical here. I will maintain the fan settings from that job's failure analysis (60-70% over overhang) because it directly addresses the material/geometry interaction. Since the environment (24°C, 55% RH) is very close to the precedent's conditions, the core temperature and cooling strategy remains valid.\nProposed: nozzle 245°C, bed 85°C, fan 65%, first-layer fan 0%, retraction 5.0mm.", "material": "PETG", "geometry": "overhang", "bed_position": "center", "env_temp": 24.0, "env_humidity": 55.0, "ts": "2026-06-14T12:01:38+00:00"}
-{"session_id": "petg-overhang-center", "track": "preflight", "turn": 2, "agent": "Spine", "role": "Safety Spine", "act": "veto", "stance": "clear", "content": "Within the safe envelope for this material — no clamp.", "material": "PETG", "geometry": "overhang", "bed_position": "center", "env_temp": 24.0, "env_humidity": 55.0, "ts": "2026-06-14T12:01:45+00:00"}
-{"session_id": "petg-overhang-center", "track": "preflight", "turn": 3, "agent": "La Forge", "role": "QA Inspector", "act": "second_opinion", "stance": "caution", "content": "Cooling compromise ignores thermal gradient risk. — The 65% fan setting risks rapid cooling and warping on PETG overhangs, especially if local drafts exceed ambient control.", "material": "PETG", "geometry": "overhang", "bed_position": "center", "env_temp": 24.0, "env_humidity": 55.0, "ts": "2026-06-14T12:01:52+00:00"}
-{"session_id": "petg-overhang-center", "track": "print-loop", "turn": 4, "agent": "World", "role": "Outcome Simulator", "act": "simulate", "stance": "success", "content": "Iteration 1: clean print (quality 0.73). Policy: PETG/overhang/mid/mid: success (q=0.73) — holding policy.", "material": "PETG", "geometry": "overhang", "bed_position": "center", "env_temp": 24.0, "env_humidity": 55.0, "ts": "2026-06-14T12:01:59+00:00"}
-{"session_id": "petg-overhang-center", "track": "print-loop", "turn": 5, "agent": "La Forge", "role": "QA Inspector", "act": "grade", "stance": "overcautious", "content": "Print held (q=0.73). — Engineer flagged sag; the settings covered it. Credit the call — or it was conservative.", "material": "PETG", "geometry": "overhang", "bed_position": "center", "env_temp": 24.0, "env_humidity": 55.0, "ts": "2026-06-14T12:02:06+00:00"}
-{"session_id": "petg-overhang-center", "track": "print-loop", "turn": 6, "agent": "World", "role": "Outcome Simulator", "act": "simulate", "stance": "success", "content": "Iteration 2: clean print (quality 0.73). Policy: PETG/overhang/mid/mid: success (q=0.73) — holding policy.", "material": "PETG", "geometry": "overhang", "bed_position": "center", "env_temp": 24.0, "env_humidity": 55.0, "ts": "2026-06-14T12:02:13+00:00"}
-{"session_id": "petg-overhang-center", "track": "print-loop", "turn": 7, "agent": "La Forge", "role": "QA Inspector", "act": "grade", "stance": "overcautious", "content": "Print held (q=0.73). — Engineer flagged sag; the settings covered it. Credit the call — or it was conservative.", "material": "PETG", "geometry": "overhang", "bed_position": "center", "env_temp": 24.0, "env_humidity": 55.0, "ts": "2026-06-14T12:02:20+00:00"}
-{"session_id": "petg-overhang-center", "track": "print-loop", "turn": 8, "agent": "World", "role": "Outcome Simulator", "act": "simulate", "stance": "success", "content": "Iteration 3: clean print (quality 0.73). Policy: PETG/overhang/mid/mid: success (q=0.73) — holding policy.", "material": "PETG", "geometry": "overhang", "bed_position": "center", "env_temp": 24.0, "env_humidity": 55.0, "ts": "2026-06-14T12:02:27+00:00"}
-{"session_id": "petg-overhang-center", "track": "print-loop", "turn": 9, "agent": "La Forge", "role": "QA Inspector", "act": "grade", "stance": "overcautious", "content": "Print held (q=0.73). — Engineer flagged sag; the settings covered it. Credit the call — or it was conservative.", "material": "PETG", "geometry": "overhang", "bed_position": "center", "env_temp": 24.0, "env_humidity": 55.0, "ts": "2026-06-14T12:02:34+00:00"}
-{"session_id": "petg-overhang-center", "track": "review", "turn": 10, "agent": "La Forge", "role": "QA Inspector", "act": "verdict", "stance": "concur", "content": "Converged to clean by iteration 1. — PETG/overhang climbed 0.73 → 0.73. The compounding is real: each simulated outcome tightened the policy and the next run was better-informed.", "material": "PETG", "geometry": "overhang", "bed_position": "center", "env_temp": 24.0, "env_humidity": 55.0, "ts": "2026-06-14T12:02:41+00:00"}
-{"session_id": "pla-adhesion-center", "track": "preflight", "turn": 1, "agent": "O'Brien", "role": "Chief Engineer", "act": "propose", "stance": "", "content": "The closest precedent [1] shows that cold ambient temperature (19°C) severely compromised first-layer adhesion, requiring a significant bed bump and fan shutdown. Since the current room is 21°C, which is only slightly warmer than the failed job's environment, we must apply the core lesson: prioritize thermal energy transfer to the build plate. We will maintain the elevated bed temperature and disable cooling for initial layers to maximize bonding strength.\nProposed: nozzle 215°C, bed 60°C, fan 0%, first-layer fan 0%, retraction 5.0mm.", "material": "PLA", "geometry": "adhesion", "bed_position": "center", "env_temp": 21.0, "env_humidity": 45.0, "ts": "2026-06-14T12:02:48+00:00"}
+{"session_id": "abs-overhang-edge", "track": "preflight", "turn": 3, "agent": "La Forge", "role": "QA Inspector", "act": "second_opinion", "stance": "caution", "content": "Thermal management remains a guess, not a plan. — The reliance on ambient room temp and moderate bed temps doesn't guarantee stability. Warping risk is unflagged until it happens.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:00:21+00:00"}
+{"session_id": "abs-overhang-edge", "track": "print-loop", "turn": 4, "agent": "World", "role": "Outcome Simulator", "act": "simulate", "stance": "failed_sag", "content": "Iteration 1: sag (quality 0.19, dominant cost: sag). Policy: ABS/overhang/mid/humid: sag (q=0.19) — learned: fan_pct +12, nozzle_temp -3.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:00:28+00:00"}
+{"session_id": "abs-overhang-edge", "track": "print-loop", "turn": 5, "agent": "La Forge", "role": "QA Inspector", "act": "grade", "stance": "confirmed", "content": "Failed on sagging — exactly as called. — Quality 0.19. The Engineer's risk flag was right; the loop now has the lesson.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:00:35+00:00"}
+{"session_id": "abs-overhang-edge", "track": "print-loop", "turn": 6, "agent": "World", "role": "Outcome Simulator", "act": "simulate", "stance": "failed_sag", "content": "Iteration 2: sag (quality 0.27, dominant cost: sag). Policy: ABS/overhang/mid/humid: sag (q=0.27) — learned: fan_pct +12, nozzle_temp -3.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:00:42+00:00"}
+{"session_id": "abs-overhang-edge", "track": "print-loop", "turn": 7, "agent": "La Forge", "role": "QA Inspector", "act": "grade", "stance": "confirmed", "content": "Failed on sagging — exactly as called. — Quality 0.27. The Engineer's risk flag was right; the loop now has the lesson.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:00:49+00:00"}
+{"session_id": "abs-overhang-edge", "track": "print-loop", "turn": 8, "agent": "World", "role": "Outcome Simulator", "act": "simulate", "stance": "failed_sag", "content": "Iteration 3: sag (quality 0.33, dominant cost: sag). Policy: ABS/overhang/mid/humid: sag (q=0.33) — learned: fan_pct +12, nozzle_temp -3.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:00:56+00:00"}
+{"session_id": "abs-overhang-edge", "track": "print-loop", "turn": 9, "agent": "La Forge", "role": "QA Inspector", "act": "grade", "stance": "confirmed", "content": "Failed on sagging — exactly as called. — Quality 0.33. The Engineer's risk flag was right; the loop now has the lesson.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:01:03+00:00"}
+{"session_id": "abs-overhang-edge", "track": "print-loop", "turn": 10, "agent": "World", "role": "Outcome Simulator", "act": "simulate", "stance": "failed_sag", "content": "Iteration 4: warp (quality 0.34, dominant cost: warp). Policy: ABS/overhang/mid/humid: warp (q=0.34) — learned: fan_pct -10.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:01:10+00:00"}
+{"session_id": "abs-overhang-edge", "track": "print-loop", "turn": 11, "agent": "La Forge", "role": "QA Inspector", "act": "grade", "stance": "missed", "content": "Failed on warping — and it wasn't flagged. — Quality 0.34. The Engineer didn't predict this mode. That gap is what the next iteration has to close.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:01:17+00:00"}
+{"session_id": "abs-overhang-edge", "track": "review", "turn": 12, "agent": "La Forge", "role": "QA Inspector", "act": "verdict", "stance": "caution", "content": "Improving but not yet clean (best 0.34). — Quality rose 0.19 → 0.34 over 4 runs but never crossed the bar. More iterations or a different lever needed — the loop is learning, slowly.", "material": "ABS", "geometry": "overhang", "bed_position": "edge", "env_temp": 26.0, "env_humidity": 60.0, "ts": "2026-06-14T12:01:24+00:00"}
+{"session_id": "petg-overhang-center", "track": "preflight", "turn": 1, "agent": "O'Brien", "role": "Chief Engineer", "act": "propose", "stance": "", "content": "The prior job [1] is highly relevant, showing PETG overhang sag at 23°C. Since the current environment (24°C, 55% RH) is only slightly warmer and drier, the lesson about cooling compromise remains critical. I must maintain the fan setting high enough to stabilize the plastic but low enough not to induce thermal stress or excessive warping on PETG. The overhang geometry dictates careful management of cooling rates.\nProposed: nozzle 245°C, bed 85°C, fan 60%, first-layer fan 0%, retraction 5.0mm.", "material": "PETG", "geometry": "overhang", "bed_position": "center", "env_temp": 24.0, "env_humidity": 55.0, "ts": "2026-06-14T12:01:31+00:00"}
+{"session_id": "petg-overhang-center", "track": "preflight", "turn": 2, "agent": "Spine", "role": "Safety Spine", "act": "veto", "stance": "clear", "content": "Within the safe envelope for this material — no clamp.", "material": "PETG", "geometry": "overhang", "bed_position": "center", "env_temp": 24.0, "env_humidity": 55.0, "ts": "2026-06-14T12:01:38+00:00"}
+{"session_id": "petg-overhang-center", "track": "preflight", "turn": 3, "agent": "La Forge", "role": "QA Inspector", "act": "second_opinion", "stance": "dispute", "content": "Overhang sag and environment are not solved by minor temperature tweaks. — The proposed fan settings fail to account for PETG's inherent thermal instability. Adhesion risk remains high regardless of the slight environmental shift.", "material": "PETG", "geometry": "overhang", "bed_position": "center", "env_temp": 24.0, "env_humidity": 55.0, "ts": "2026-06-14T12:01:45+00:00"}
+{"session_id": "petg-overhang-center", "track": "preflight", "turn": 4, "agent": "Operator", "role": "Operator", "act": "override", "stance": "override", "content": "Acknowledged La Forge's objection. Proceeding to print on the operator's call.", "material": "PETG", "geometry": "overhang", "bed_position": "center", "env_temp": 24.0, "env_humidity": 55.0, "ts": "2026-06-14T12:01:52+00:00"}
+{"session_id": "petg-overhang-center", "track": "print-loop", "turn": 5, "agent": "World", "role": "Outcome Simulator", "act": "simulate", "stance": "success", "content": "Iteration 1: clean print (quality 0.73). Policy: PETG/overhang/mid/mid: success (q=0.73) — holding policy.", "material": "PETG", "geometry": "overhang", "bed_position": "center", "env_temp": 24.0, "env_humidity": 55.0, "ts": "2026-06-14T12:01:59+00:00"}
+{"session_id": "petg-overhang-center", "track": "print-loop", "turn": 6, "agent": "La Forge", "role": "QA Inspector", "act": "grade", "stance": "overcautious", "content": "Print held (q=0.73). — Engineer flagged sag; the settings covered it. Credit the call — or it was conservative.", "material": "PETG", "geometry": "overhang", "bed_position": "center", "env_temp": 24.0, "env_humidity": 55.0, "ts": "2026-06-14T12:02:06+00:00"}
+{"session_id": "petg-overhang-center", "track": "print-loop", "turn": 7, "agent": "World", "role": "Outcome Simulator", "act": "simulate", "stance": "success", "content": "Iteration 2: clean print (quality 0.73). Policy: PETG/overhang/mid/mid: success (q=0.73) — holding policy.", "material": "PETG", "geometry": "overhang", "bed_position": "center", "env_temp": 24.0, "env_humidity": 55.0, "ts": "2026-06-14T12:02:13+00:00"}
+{"session_id": "petg-overhang-center", "track": "print-loop", "turn": 8, "agent": "La Forge", "role": "QA Inspector", "act": "grade", "stance": "overcautious", "content": "Print held (q=0.73). — Engineer flagged sag; the settings covered it. Credit the call — or it was conservative.", "material": "PETG", "geometry": "overhang", "bed_position": "center", "env_temp": 24.0, "env_humidity": 55.0, "ts": "2026-06-14T12:02:20+00:00"}
+{"session_id": "petg-overhang-center", "track": "print-loop", "turn": 9, "agent": "World", "role": "Outcome Simulator", "act": "simulate", "stance": "success", "content": "Iteration 3: clean print (quality 0.73). Policy: PETG/overhang/mid/mid: success (q=0.73) — holding policy.", "material": "PETG", "geometry": "overhang", "bed_position": "center", "env_temp": 24.0, "env_humidity": 55.0, "ts": "2026-06-14T12:02:27+00:00"}
+{"session_id": "petg-overhang-center", "track": "print-loop", "turn": 10, "agent": "La Forge", "role": "QA Inspector", "act": "grade", "stance": "overcautious", "content": "Print held (q=0.73). — Engineer flagged sag; the settings covered it. Credit the call — or it was conservative.", "material": "PETG", "geometry": "overhang", "bed_position": "center", "env_temp": 24.0, "env_humidity": 55.0, "ts": "2026-06-14T12:02:34+00:00"}
+{"session_id": "petg-overhang-center", "track": "review", "turn": 11, "agent": "La Forge", "role": "QA Inspector", "act": "verdict", "stance": "concur", "content": "Converged to clean by iteration 1. — PETG/overhang climbed 0.73 → 0.73. The compounding is real: each simulated outcome tightened the policy and the next run was better-informed.", "material": "PETG", "geometry": "overhang", "bed_position": "center", "env_temp": 24.0, "env_humidity": 55.0, "ts": "2026-06-14T12:02:41+00:00"}
+{"session_id": "pla-adhesion-center", "track": "preflight", "turn": 1, "agent": "O'Brien", "role": "Chief Engineer", "act": "propose", "stance": "", "content": "The prior job [1] (PLA/adhesion @ 19°C, 38% RH) is highly relevant because the current ambient temperature (21°C) is still cool relative to optimal printing conditions, and adhesion failure was the primary issue. The lesson that cold ambient air compromises first-layer bonding remains valid. Therefore, we must maintain a high bed temp and minimize cooling effects on the first few layers.\nProposed: nozzle 215°C, bed 60°C, fan 30%, first-layer fan 0%, retraction 5.0mm.", "material": "PLA", "geometry": "adhesion", "bed_position": "center", "env_temp": 21.0, "env_humidity": 45.0, "ts": "2026-06-14T12:02:48+00:00"}
 {"session_id": "pla-adhesion-center", "track": "preflight", "turn": 2, "agent": "Spine", "role": "Safety Spine", "act": "veto", "stance": "clear", "content": "Within the safe envelope for this material — no clamp.", "material": "PLA", "geometry": "adhesion", "bed_position": "center", "env_temp": 21.0, "env_humidity": 45.0, "ts": "2026-06-14T12:02:55+00:00"}
-{"session_id": "pla-adhesion-center", "track": "preflight", "turn": 3, "agent": "La Forge", "role": "QA Inspector", "act": "second_opinion", "stance": "caution", "content": "Thermal gradient assumption is weak. — A slight ambient bump does not guarantee adhesion success. The print environment must be stable, not just marginally improved.", "material": "PLA", "geometry": "adhesion", "bed_position": "center", "env_temp": 21.0, "env_humidity": 45.0, "ts": "2026-06-14T12:03:02+00:00"}
+{"session_id": "pla-adhesion-center", "track": "preflight", "turn": 3, "agent": "La Forge", "role": "QA Inspector", "act": "second_opinion", "stance": "caution", "content": "The ambient conditions are not a guarantee. — Relying on past environmental data to predict adhesion success is thin. Watch for drafts or humidity spikes.", "material": "PLA", "geometry": "adhesion", "bed_position": "center", "env_temp": 21.0, "env_humidity": 45.0, "ts": "2026-06-14T12:03:02+00:00"}
 {"session_id": "pla-adhesion-center", "track": "print-loop", "turn": 4, "agent": "World", "role": "Outcome Simulator", "act": "simulate", "stance": "success", "content": "Iteration 1: clean print (quality 1.00). Policy: PLA/adhesion/mid/mid: success (q=1.00) — holding policy.", "material": "PLA", "geometry": "adhesion", "bed_position": "center", "env_temp": 21.0, "env_humidity": 45.0, "ts": "2026-06-14T12:03:09+00:00"}
 {"session_id": "pla-adhesion-center", "track": "print-loop", "turn": 5, "agent": "La Forge", "role": "QA Inspector", "act": "grade", "stance": "overcautious", "content": "Print held (q=1.00). — Engineer flagged adhesion; the settings covered it. Credit the call — or it was conservative.", "material": "PLA", "geometry": "adhesion", "bed_position": "center", "env_temp": 21.0, "env_humidity": 45.0, "ts": "2026-06-14T12:03:16+00:00"}
 {"session_id": "pla-adhesion-center", "track": "print-loop", "turn": 6, "agent": "World", "role": "Outcome Simulator", "act": "simulate", "stance": "success", "content": "Iteration 2: clean print (quality 1.00). Policy: PLA/adhesion/mid/mid: success (q=1.00) — holding policy.", "material": "PLA", "geometry": "adhesion", "bed_position": "center", "env_temp": 21.0, "env_humidity": 45.0, "ts": "2026-06-14T12:03:23+00:00"}
@@ -31,14 +31,13 @@
 {"session_id": "pla-adhesion-center", "track": "print-loop", "turn": 8, "agent": "World", "role": "Outcome Simulator", "act": "simulate", "stance": "success", "content": "Iteration 3: clean print (quality 1.00). Policy: PLA/adhesion/mid/mid: success (q=1.00) — holding policy.", "material": "PLA", "geometry": "adhesion", "bed_position": "center", "env_temp": 21.0, "env_humidity": 45.0, "ts": "2026-06-14T12:03:37+00:00"}
 {"session_id": "pla-adhesion-center", "track": "print-loop", "turn": 9, "agent": "La Forge", "role": "QA Inspector", "act": "grade", "stance": "overcautious", "content": "Print held (q=1.00). — Engineer flagged adhesion; the settings covered it. Credit the call — or it was conservative.", "material": "PLA", "geometry": "adhesion", "bed_position": "center", "env_temp": 21.0, "env_humidity": 45.0, "ts": "2026-06-14T12:03:44+00:00"}
 {"session_id": "pla-adhesion-center", "track": "review", "turn": 10, "agent": "La Forge", "role": "QA Inspector", "act": "verdict", "stance": "concur", "content": "Converged to clean by iteration 1. — PLA/adhesion climbed 1.00 → 1.00. The compounding is real: each simulated outcome tightened the policy and the next run was better-informed.", "material": "PLA", "geometry": "adhesion", "bed_position": "center", "env_temp": 21.0, "env_humidity": 45.0, "ts": "2026-06-14T12:03:51+00:00"}
-{"session_id": "tpu-stringing-edge", "track": "preflight", "turn": 1, "agent": "O'Brien", "role": "Chief Engineer", "act": "propose", "stance": "", "content": "No close precedent exists. TPU is flexible and prone to stringing because of its high elasticity and low melt strength, especially when ambient conditions are humid (65% RH). The goal is minimizing oozing without compromising print speed or layer adhesion. We need a balance: enough heat to flow the material but not so much that it overheats and degrades, and aggressive cooling where possible.\nProposed: nozzle 230°C, bed 45°C, fan 60%, first-layer fan 0%, retraction 1.5mm.", "material": "TPU", "geometry": "stringing", "bed_position": "edge", "env_temp": 23.0, "env_humidity": 65.0, "ts": "2026-06-14T12:03:58+00:00"}
+{"session_id": "tpu-stringing-edge", "track": "preflight", "turn": 1, "agent": "O'Brien", "role": "Chief Engineer", "act": "propose", "stance": "", "content": "No close precedent exists (TPU/stringing). TPU is flexible and prone to stringing due to its viscoelastic nature, especially when printed at ambient temperatures. The high humidity (65% RH) will exacerbate this by increasing surface tackiness. We must minimize the time the plastic spends in the air after extrusion while maintaining flow. I'll keep the nozzle temp low but stable, increase retraction slightly for better cleanup, and use a moderate fan to help cool the stringing areas quickly.\nProposed: nozzle 230°C, bed 45°C, fan 60%, first-layer fan 0%, retraction 3.0mm.", "material": "TPU", "geometry": "stringing", "bed_position": "edge", "env_temp": 23.0, "env_humidity": 65.0, "ts": "2026-06-14T12:03:58+00:00"}
 {"session_id": "tpu-stringing-edge", "track": "preflight", "turn": 2, "agent": "Spine", "role": "Safety Spine", "act": "veto", "stance": "clear", "content": "Within the safe envelope for this material — no clamp.", "material": "TPU", "geometry": "stringing", "bed_position": "edge", "env_temp": 23.0, "env_humidity": 65.0, "ts": "2026-06-14T12:04:05+00:00"}
-{"session_id": "tpu-stringing-edge", "track": "preflight", "turn": 3, "agent": "La Forge", "role": "QA Inspector", "act": "second_opinion", "stance": "dispute", "content": "High heat settings for TPU are risky overkill. — 230°C nozzle risks degradation and excessive ooze. Lower it and manage cooling/retraction better.", "material": "TPU", "geometry": "stringing", "bed_position": "edge", "env_temp": 23.0, "env_humidity": 65.0, "ts": "2026-06-14T12:04:12+00:00"}
-{"session_id": "tpu-stringing-edge", "track": "preflight", "turn": 4, "agent": "Operator", "role": "Operator", "act": "override", "stance": "override", "content": "Acknowledged La Forge's objection. Proceeding to print on the operator's call.", "material": "TPU", "geometry": "stringing", "bed_position": "edge", "env_temp": 23.0, "env_humidity": 65.0, "ts": "2026-06-14T12:04:19+00:00"}
-{"session_id": "tpu-stringing-edge", "track": "print-loop", "turn": 5, "agent": "World", "role": "Outcome Simulator", "act": "simulate", "stance": "success", "content": "Iteration 1: clean print (quality 0.86). Policy: TPU/stringing/mid/humid: success (q=0.86) — holding policy.", "material": "TPU", "geometry": "stringing", "bed_position": "edge", "env_temp": 23.0, "env_humidity": 65.0, "ts": "2026-06-14T12:04:26+00:00"}
-{"session_id": "tpu-stringing-edge", "track": "print-loop", "turn": 6, "agent": "La Forge", "role": "QA Inspector", "act": "grade", "stance": "overcautious", "content": "Print held (q=0.86). — Engineer flagged stringing; the settings covered it. Credit the call — or it was conservative.", "material": "TPU", "geometry": "stringing", "bed_position": "edge", "env_temp": 23.0, "env_humidity": 65.0, "ts": "2026-06-14T12:04:33+00:00"}
-{"session_id": "tpu-stringing-edge", "track": "print-loop", "turn": 7, "agent": "World", "role": "Outcome Simulator", "act": "simulate", "stance": "success", "content": "Iteration 2: clean print (quality 0.86). Policy: TPU/stringing/mid/humid: success (q=0.86) — holding policy.", "material": "TPU", "geometry": "stringing", "bed_position": "edge", "env_temp": 23.0, "env_humidity": 65.0, "ts": "2026-06-14T12:04:40+00:00"}
-{"session_id": "tpu-stringing-edge", "track": "print-loop", "turn": 8, "agent": "La Forge", "role": "QA Inspector", "act": "grade", "stance": "overcautious", "content": "Print held (q=0.86). — Engineer flagged stringing; the settings covered it. Credit the call — or it was conservative.", "material": "TPU", "geometry": "stringing", "bed_position": "edge", "env_temp": 23.0, "env_humidity": 65.0, "ts": "2026-06-14T12:04:47+00:00"}
-{"session_id": "tpu-stringing-edge", "track": "print-loop", "turn": 9, "agent": "World", "role": "Outcome Simulator", "act": "simulate", "stance": "success", "content": "Iteration 3: clean print (quality 0.86). Policy: TPU/stringing/mid/humid: success (q=0.86) — holding policy.", "material": "TPU", "geometry": "stringing", "bed_position": "edge", "env_temp": 23.0, "env_humidity": 65.0, "ts": "2026-06-14T12:04:54+00:00"}
-{"session_id": "tpu-stringing-edge", "track": "print-loop", "turn": 10, "agent": "La Forge", "role": "QA Inspector", "act": "grade", "stance": "overcautious", "content": "Print held (q=0.86). — Engineer flagged stringing; the settings covered it. Credit the call — or it was conservative.", "material": "TPU", "geometry": "stringing", "bed_position": "edge", "env_temp": 23.0, "env_humidity": 65.0, "ts": "2026-06-14T12:05:01+00:00"}
-{"session_id": "tpu-stringing-edge", "track": "review", "turn": 11, "agent": "La Forge", "role": "QA Inspector", "act": "verdict", "stance": "concur", "content": "Converged to clean by iteration 1. — TPU/stringing climbed 0.86 → 0.86. The compounding is real: each simulated outcome tightened the policy and the next run was better-informed.", "material": "TPU", "geometry": "stringing", "bed_position": "edge", "env_temp": 23.0, "env_humidity": 65.0, "ts": "2026-06-14T12:05:08+00:00"}
+{"session_id": "tpu-stringing-edge", "track": "preflight", "turn": 3, "agent": "La Forge", "role": "QA Inspector", "act": "second_opinion", "stance": "caution", "content": "Humidity risk outweighs temperature adjustments. — 65% RH and TPU are a poor pairing. Focus on enclosure or drying, not just retraction settings.", "material": "TPU", "geometry": "stringing", "bed_position": "edge", "env_temp": 23.0, "env_humidity": 65.0, "ts": "2026-06-14T12:04:12+00:00"}
+{"session_id": "tpu-stringing-edge", "track": "print-loop", "turn": 4, "agent": "World", "role": "Outcome Simulator", "act": "simulate", "stance": "success", "content": "Iteration 1: clean print (quality 0.86). Policy: TPU/stringing/mid/humid: success (q=0.86) — holding policy.", "material": "TPU", "geometry": "stringing", "bed_position": "edge", "env_temp": 23.0, "env_humidity": 65.0, "ts": "2026-06-14T12:04:19+00:00"}
+{"session_id": "tpu-stringing-edge", "track": "print-loop", "turn": 5, "agent": "La Forge", "role": "QA Inspector", "act": "grade", "stance": "overcautious", "content": "Print held (q=0.86). — Engineer flagged stringing; the settings covered it. Credit the call — or it was conservative.", "material": "TPU", "geometry": "stringing", "bed_position": "edge", "env_temp": 23.0, "env_humidity": 65.0, "ts": "2026-06-14T12:04:26+00:00"}
+{"session_id": "tpu-stringing-edge", "track": "print-loop", "turn": 6, "agent": "World", "role": "Outcome Simulator", "act": "simulate", "stance": "success", "content": "Iteration 2: clean print (quality 0.86). Policy: TPU/stringing/mid/humid: success (q=0.86) — holding policy.", "material": "TPU", "geometry": "stringing", "bed_position": "edge", "env_temp": 23.0, "env_humidity": 65.0, "ts": "2026-06-14T12:04:33+00:00"}
+{"session_id": "tpu-stringing-edge", "track": "print-loop", "turn": 7, "agent": "La Forge", "role": "QA Inspector", "act": "grade", "stance": "overcautious", "content": "Print held (q=0.86). — Engineer flagged stringing; the settings covered it. Credit the call — or it was conservative.", "material": "TPU", "geometry": "stringing", "bed_position": "edge", "env_temp": 23.0, "env_humidity": 65.0, "ts": "2026-06-14T12:04:40+00:00"}
+{"session_id": "tpu-stringing-edge", "track": "print-loop", "turn": 8, "agent": "World", "role": "Outcome Simulator", "act": "simulate", "stance": "success", "content": "Iteration 3: clean print (quality 0.86). Policy: TPU/stringing/mid/humid: success (q=0.86) — holding policy.", "material": "TPU", "geometry": "stringing", "bed_position": "edge", "env_temp": 23.0, "env_humidity": 65.0, "ts": "2026-06-14T12:04:47+00:00"}
+{"session_id": "tpu-stringing-edge", "track": "print-loop", "turn": 9, "agent": "La Forge", "role": "QA Inspector", "act": "grade", "stance": "overcautious", "content": "Print held (q=0.86). — Engineer flagged stringing; the settings covered it. Credit the call — or it was conservative.", "material": "TPU", "geometry": "stringing", "bed_position": "edge", "env_temp": 23.0, "env_humidity": 65.0, "ts": "2026-06-14T12:04:54+00:00"}
+{"session_id": "tpu-stringing-edge", "track": "review", "turn": 10, "agent": "La Forge", "role": "QA Inspector", "act": "verdict", "stance": "concur", "content": "Converged to clean by iteration 1. — TPU/stringing climbed 0.86 → 0.86. The compounding is real: each simulated outcome tightened the policy and the next run was better-informed.", "material": "TPU", "geometry": "stringing", "bed_position": "edge", "env_temp": 23.0, "env_humidity": 65.0, "ts": "2026-06-14T12:05:01+00:00"}

learn/loop.py

@@ -67,8 +67,8 @@ def _record_lesson(job: Job, env: Environment, s: PrintSettings, result: SimResu
 
 
 def run_iteration(job: Job, env: Environment, policy: LearnedPolicy, ledger: LedgerManager,
-                 n: int, record: bool = True) -> IterationRecord:
-    proposed = policy.propose(job.material, job.geometry_type, env)
+                 n: int, record: bool = True, overrides: PrintSettings | None = None) -> IterationRecord:
+    proposed = overrides if overrides is not None else policy.propose(job.material, job.geometry_type, env)
     checked = _SPINE.check(proposed, job.material)
     settings = checked.settings
     result = simulate(settings, job, env)

test_core.py

@@ -86,9 +86,27 @@ def test_gcode_readout_ties_to_settings():
     s = PrintSettings(nozzle_temp=205, bed_temp=60, retraction_mm=5, fan_pct=100, first_layer_fan_pct=0)
     g = gcode_readout(s, "PLA")
     assert "M104 S205" in g and "M140 S60" in g, g
+    assert "layer height 0.20 mm" in g, g
     print("✓ g-code header is populated from proposed settings")
 
 
+# GIF export button removed; keep motion preview tests via UI smoke if needed.
+
+
+def test_virtual_printer_html_ties_to_settings():
+    from core.widgets import virtual_printer_html
+    from core.viewer import generate_primitive
+    from core.models import PrintSettings
+    mesh, _geo = generate_primitive("box", 20)
+    default_html = virtual_printer_html(mesh)
+    assert "0.20 mm layers" in default_html, default_html
+    fine = PrintSettings(nozzle_temp=200, bed_temp=60, retraction_mm=4.5, fan_pct=80,
+                         first_layer_fan_pct=0, layer_height=0.12)
+    fine_html = virtual_printer_html(mesh, settings=fine)
+    assert "0.12 mm layers" in fine_html, fine_html
+    print("✓ virtual-print preview layer height follows PrintSettings")
+
+
 def test_ingest_distiller():
     from pathlib import Path as _P
     from ingest.distill import parse_prusa_ini, parse_klipper_cfg, parse_marlin_config
@@ -163,6 +181,7 @@ if __name__ == "__main__":
     test_reflect_appends()
     test_retrieval_orders_by_env_distance()
     test_gcode_readout_ties_to_settings()
+    test_virtual_printer_html_ties_to_settings()
     test_ingest_distiller()
     test_precedent_eval_narration()
     test_simulator_physical_and_deterministic()