Add per-sample diagnostic prints (no behavior change)

Logs per sample: colmap point count, fused point count, triangulation
track output sizes, final predicted vertex/edge count, pipeline status
(ok / fuse_failed / track_failed / predict_failed).

submission.json output is byte-identical to the prior commit — only
stdout changes. Score should reproduce the 0.4584 baseline; if not,
the rollback wasn't clean.

Once we have HF Space logs we can correlate input signal strength with
output size and identify which scenes are systematically failing,
targeting the next experiment with evidence instead of guesses.

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

script.py

@@ -382,33 +382,61 @@ if __name__ == "__main__":
         for sample in tqdm(dataset[subset_name], desc=subset_name):
             order_id = sample["order_id"]
 
+            # Diagnostic: input signal strength. No behavior change.
+            n_colmap_pts = -1
+            try:
+                from hoho2025.example_solutions import convert_entry_to_human_readable
+                _good = convert_entry_to_human_readable(sample)
+                _rec = _good.get('colmap') or _good.get('colmap_binary')
+                if _rec is not None:
+                    n_colmap_pts = len(_rec.points3D)
+            except Exception:
+                pass
+
             # Fuse + sample
             fused = fuse_and_sample(sample, cfg, rng)
+            n_fused_pts = len(fused["xyz_norm"]) if fused is not None else 0
+            track_v_count, track_e_count = 0, 0
+            pred_status = "ok"
+
             if fused is None:
                 pred_v, pred_e = empty_solution()
+                pred_status = "fuse_failed"
             else:
                 try:
                     pred_v, pred_e = predict_sample(fused, model, device)
                     if torch.cuda.is_available():
                         torch.cuda.empty_cache()
-                    
+
                     # Apply handcrafted triangulation tracking to catch missing corners/edges
                     try:
                         from triangulation import predict_wireframe_tracks
                         # Use min_views=3 for highly precise, conservative geometric tracks
                         track_v, track_e = predict_wireframe_tracks(sample, min_views=3)
-                        
+                        track_v_count = len(track_v) if track_v is not None else 0
+                        track_e_count = len(track_e) if track_e is not None else 0
+
                         pred_v, pred_e = hybrid_merge(pred_v, pred_e, track_v, track_e, merge_radius=0.8)
                     except Exception as track_e_err:
                         print(f"  Track ensemble failed for {order_id}: {track_e_err}")
-                        
+                        pred_status = "track_failed"
+
                 except Exception as e:
                     import traceback
                     print(f"  Predict failed for {order_id}:\n{traceback.format_exc()}")
                     pred_v, pred_e = empty_solution()
+                    pred_status = "predict_failed"
                     if torch.cuda.is_available():
                         torch.cuda.empty_cache()
 
+            n_pred_v = len(pred_v) if hasattr(pred_v, '__len__') else 0
+            n_pred_e = len(pred_e) if hasattr(pred_e, '__len__') else 0
+            print(
+                f"[DIAG] order_id={order_id} colmap={n_colmap_pts} fused={n_fused_pts} "
+                f"track_v={track_v_count} track_e={track_e_count} "
+                f"pred_v={n_pred_v} pred_e={n_pred_e} status={pred_status}"
+            )
+
             solution.append({
                 "order_id": order_id,
                 "wf_vertices": pred_v.tolist() if isinstance(pred_v, np.ndarray) else pred_v,