Report each operation's outcome (last_result), retouch progress and recovery hints

app/jobs.py

@@ -147,6 +147,7 @@ class JobManager:
                                f"poll GET /api/jobs/{job.id} until it is done, then retry")
             self.pending += 1
         job.state, job.op, job.error, job.progress = "queued", op, None, {"step": "queued"}
+        job.result["last"] = {"operation": op}
         job.event(f"{op}: queued")
         self.pool.submit(self._run, job, op, fn)
 
@@ -351,6 +352,7 @@ class JobManager:
             names = [v.name for v in p.views if v.enabled and (views is None or v.name in views)
                      and (force or v.status not in ("generated", "imported"))]
             total = len(names)
+            outcomes = job.result.setdefault("last", {}).setdefault("views", {})
             for i, name in enumerate(names):
                 job.progress = {"step": "generating views", "view": name, "done": i, "total": total,
                                 "seconds_per_view_estimate": BACKENDS[job.params["backend"]]["seconds_per_view"]}
@@ -367,6 +369,10 @@ class JobManager:
                     job.event(f"waiting for an external image for {name}")
                     return
                 r = out["results"][0] if out["results"] else {"status": "skipped"}
+                outcomes[name] = {k: r.get(k) for k in ("status", "edge_agreement", "silhouette_iou", "attempts")
+                                  if r.get(k) is not None}
+                if isinstance(outcomes[name].get("attempts"), list):
+                    outcomes[name]["attempts"] = len(outcomes[name]["attempts"])
                 job.event(f"view {name}: {r['status']}", view=name, status=r["status"],
                           edge_agreement=r.get("edge_agreement"), silhouette_iou=r.get("silhouette_iou"))
             job.result.pop("remaining_views", None)
@@ -436,8 +442,15 @@ class JobManager:
         def op(j: Job):
             p = self._open(j)
             try:
+                j.progress = {"step": "planning and generating gap views"}
                 r = p.fill_gaps(max_views=max_views, generate=True, backend=self._backend(j))
-                j.result["fill_gaps"] = [{k: v for k, v in rd.items() if k != "generate"} for rd in r["rounds"]]
+                rounds = []
+                for rd in r["rounds"]:
+                    item = {k: v for k, v in rd.items() if k != "generate"}
+                    if rd.get("generate"):
+                        item["views"] = {x["view"]: x["status"] for x in rd["generate"]["results"]}
+                    rounds.append(item)
+                j.result["last"] = {"operation": "fill_gaps", "rounds": rounds}
                 self._finish(j, p)
             finally:
                 self._close(p)
@@ -469,9 +482,16 @@ class JobManager:
                     if args["render_camera"] not in cams:
                         raise JobError(f"unknown render camera; have {sorted(cams)}", 400)
                     kw["camera"] = cams[args["render_camera"]]
+                j.progress = {"step": "retouching: capture, generation and validation"}
                 r = p.retouch(backend=self._backend(j), **kw)
-                j.result["retouch"] = {k: r.get(k) for k in ("status", "layer", "outside_change", "edge_agreement",
-                                                            "attempts", "detail", "warning")}
+                res = {k: r.get(k) for k in ("status", "layer", "outside_change", "edge_agreement", "attempts",
+                                             "detail", "warning", "mask_pixels") if r.get(k) is not None}
+                ldir = j.root / "layers" / (r.get("layer") or kw.get("name") or "")
+                if r.get("layer") and ldir.exists():
+                    res["images"] = {n: f"layers/{r['layer']}/{n}.png" for n in ("compare", "before", "after", "raw",
+                                                                               "model_input", "mask")
+                                     if (ldir / f"{n}.png").exists()}
+                j.result["last"] = {"operation": "retouch", **res}
                 if r.get("status") == "applied":
                     self._finish(j, p)
             finally:
@@ -486,7 +506,7 @@ class JobManager:
         def op(j: Job):
             p = self._open(j)
             try:
-                j.result["undo"] = p.undo_retouch()
+                j.result["last"] = {"operation": "undo_retouch", **p.undo_retouch()}
                 self._finish(j, p)
             finally:
                 self._close(p)

app/llms.txt

@@ -45,9 +45,14 @@ Generation runs on ZeroGPU Spaces and spends the caller's daily GPU quota (about
 - backend: qwen-space (default) | fibo-space (most consistent views, best masked edits; CC BY-NC outputs) | mock |
   external.
 - texture_size 1024 | 2048 | 4096; view_size 512-1024.
-Time: ~(views x 30 s) + 1-2 min of CPU work. A balanced object job is about 6-8 minutes with qwen-space.
+Time: ~(views x 30 s) + 1-2 min of CPU work here. Measured on this Space: 4 views ~3 min (qwen-space and
+fibo-space); a balanced object job (7 views + up to 3 gap views) ~6-8 min. preset "minimal" is for quick tests:
+it leaves much of a complex mesh uncovered (e.g. ~40-50 % on the lantern); use balanced or dense for real work.
 
 ## Reading results
+- last_result: outcome of the latest operation. retouch: status (applied | empty_mask | rejected), images.compare
+  (before | model input | model output | after), validation attempts; regenerate/texture: per-view status;
+  fill_gaps: coverage before/after and views added. If a retouch was not applied, `next` says how to aim it.
 - views[].status: generated (used) | rejected (did not line up with the geometry after 3 attempts; excluded) |
   planned/pending. edge_agreement/silhouette_iou: alignment scores (good views ~0.3-0.7 / >0.85).
 - summary.views_flagged_inconsistent: views whose content contradicts the others (e.g. a face painted on the back

app/server.py

@@ -82,6 +82,13 @@ def status_payload(job, base: str, events: int = 12) -> dict:
         "elapsed_seconds": round(job.updated - job.created, 1), "summary": summary, "files": files,
         "views": views, "error": job.error, "recent_events": job.events[-events:],
     }
+    last = dict(job.result.get("last") or {})
+    if last.get("images"):
+        last["images"] = {k: f"{url}/files/{v}" for k, v in last["images"].items()}
+    out["last_result"] = last or None
+    if d and d.get("layers"):
+        out["retouch_layers"] = [{"name": L["name"], "mode": L["mode"], "enabled": L.get("enabled", True),
+                                  "compare_url": f"{url}/files/layers/{L['name']}/compare.png"} for L in d["layers"]]
     if ins.get("suggestions"):
         out["retouch_suggestions"] = [{"index": i, "reason": s["reason"], "area_pct": s["area_pct"]}
                                       for i, s in enumerate(ins["suggestions"])]
@@ -127,6 +134,20 @@ def next_actions(job, url: str, st: dict) -> list[dict]:
         return [{"do": "read error, fix the request and create a new job (or retry the operation)",
                  "error": job.error}]
     acts = []
+    last = st.get("last_result") or {}
+    if last.get("operation") == "retouch" and last.get("status") != "applied":
+        why = {"empty_mask": "the mask covered no visible surface from that camera: aim it with "
+                             "POST /pick (render_camera + pixels) and use a sphere mask around the returned point, "
+                             "or use a retouch_suggestions index",
+               "rejected": "the model's output did not keep the framing/geometry; try another camera, a tighter "
+                           "focus, another prompt or another backend"}.get(last.get("status"), last.get("detail"))
+        acts.append({"do": f"retouch was not applied ({last.get('status')})", "why": why,
+                     "pick": {"method": "POST", "url": f"{url}/pick",
+                              "body": {"render_camera": "orbit00", "pixels": [[0.5, 0.5]]}}})
+    elif last.get("operation") == "retouch" and last.get("images", {}).get("compare"):
+        acts.append({"do": "check the retouch (before | model input | model output | after)", "method": "GET",
+                     "url": last["images"]["compare"],
+                     "undo": {"method": "POST", "url": f"{url}/undo-retouch"}})
     files = st.get("files") or {}
     if files.get("textured_glb"):
         acts.append({"do": "download the textured model", "method": "GET", "url": files["textured_glb"]})

tests/smoke.py

@@ -168,8 +168,8 @@ async def mcp_checks(base: str, H: dict) -> None:
                 check("Quota and identity" in res.content[0].text, "guide tool returns llms.txt")
 
 
-def live_checks(base: str, H: dict) -> None:
-    for backend in ("qwen-space", "fibo-space"):
+def live_checks(base: str, H: dict, backends: list[str]) -> None:
+    for backend in backends:
         print(f"LIVE job: {backend}")
         r = requests.post(f"{base}/api/jobs", headers=H, timeout=60, json={
             "sample": "lantern", "backend": backend, "preset": "minimal", "gap_views": False, "texture_size": 2048,
@@ -185,16 +185,26 @@ def live_checks(base: str, H: dict) -> None:
             (OUT / f"live_{backend}_contact_sheet.png").write_bytes(img)
             (OUT / f"live_{backend}_status.json").write_text(json.dumps(d, indent=1))
         if backend == "fibo-space" and d["state"] == "done":
-            print("LIVE retouch (fibo-space, native mask)")
-            r = requests.post(f"{base}/api/jobs/{d['job_id']}/retouch", headers=H, timeout=60, json={
-                "mode": "replace", "render_camera": "orbit00", "mask": {"circle": [0.5, 0.62, 0.06]},
-                "prompt": "a small brass plaque with an engraved number 7"})
-            d2 = wait(base, d["job_id"], H, timeout=1200)
-            ok = d2["state"] == "done"
-            check(ok, f"retouch finished: {d2.get('recent_events', [{}])[-1].get('msg')}")
-            if ok:
-                img = requests.get(d2["files"]["contact_sheet"], headers=H, timeout=60).content
-                (OUT / "live_fibo_retouch_contact_sheet.png").write_bytes(img)
+            print("LIVE retouch (fibo-space, native mask), aimed with /pick like an agent would")
+            jid = d["job_id"]
+            grid = [[x / 8, y / 8] for y in range(2, 7) for x in range(2, 7)]
+            picks = requests.post(f"{base}/api/jobs/{jid}/pick", headers=H, timeout=300,
+                                  json={"render_camera": "orbit00", "pixels": grid}).json()["picks"]
+            hits = [pk for pk in picks if pk["hit"]]
+            check(bool(hits), f"pick found {len(hits)} surface points on orbit00")
+            pt = hits[len(hits) // 2]
+            r = requests.post(f"{base}/api/jobs/{jid}/retouch", headers=H, timeout=60, json={
+                "mode": "replace", "prompt": "a small brass plaque with an engraved number 7",
+                "focus": {"point": pt["point"], "radius": 0.12 * pt["depth"], "direction": pt["normal"]},
+                "mask": {"sphere": pt["point"] + [0.06 * pt["depth"]]}})
+            check(r.status_code == 202, "retouch -> 202")
+            d2 = wait(base, jid, H, timeout=1200)
+            last = d2.get("last_result") or {}
+            check(d2["state"] == "done" and last.get("status") == "applied",
+                  f"retouch applied: {json.dumps({k: last.get(k) for k in ('status', 'detail', 'edge_agreement', 'outside_change')})}")
+            if last.get("images", {}).get("compare"):
+                (OUT / "live_fibo_retouch_compare.png").write_bytes(
+                    requests.get(last["images"]["compare"], headers=H, timeout=60).content)
 
 
 def main() -> int:
@@ -202,6 +212,7 @@ def main() -> int:
     ap.add_argument("base")
     ap.add_argument("--live", action="store_true")
     ap.add_argument("--skip-free", action="store_true")
+    ap.add_argument("--backends", default="qwen-space,fibo-space", help="live backends to test")
     a = ap.parse_args()
     base = a.base.rstrip("/")
     H: dict = {}
@@ -215,7 +226,7 @@ def main() -> int:
         rest_checks(base, H)
         asyncio.run(mcp_checks(base, H))
     if a.live:
-        live_checks(base, H)
+        live_checks(base, H, a.backends.split(","))
     print("\nRESULT:", "all checks passed" if not FAILS else f"{len(FAILS)} failed: {FAILS}")
     return 1 if FAILS else 0