@@ -1,22 +1,23 @@
 
 ;; test-records is a hash table testname:item_path => vector < testname testconfig waitons priority items-info ... >
-(define (runs:run-tests-queue-new run-id runname test-records keyvals flags test-patts required-tests reglen)
+(define (runs:run-tests-queue-new run-id runname test-records keyvals flags test-patts required-tests reglen-in)
   ;; At this point the list of parent tests is expanded 
   ;; NB// Should expand items here and then insert into the run queue.
   (debug:print 5 "test-records: " test-records ", flags: " (hash-table->alist flags))
   (let ((run-info              (cdb:remote-run db:get-run-info #f run-id))
-	(tests-info            (cdb:remote-run db:get-tests-for-run #f run-id #f '() '())) ;;  qryvals: "id,testname,item_path"))
+	(tests-info            (mt:get-tests-for-run run-id #f '() '())) ;;  qryvals: "id,testname,item_path"))
 	(sorted-test-names     (tests:sort-by-priority-and-waiton test-records))
 	(test-registry         (make-hash-table))
 	(registry-mutex        (make-mutex))
 	(num-retries           0)
 	(max-retries           (config-lookup *configdat* "setup" "maxretries"))
 	(max-concurrent-jobs   (let ((mcj (config-lookup *configdat* "setup"     "max_concurrent_jobs")))
 				 (if (and mcj (string->number mcj))
 				     (string->number mcj)
-				     1)))) ;; length of the register queue ahead
+				     1))) ;; length of the register queue ahead
+	(reglen                (if (number? reglen-in) reglen-in 1)))
     ;; Initialize the test-registery hash with tests that already have a record
     (for-each (lambda (trec)
 		(let ((id (db:test-get-id        trec))
 		      (tn (db:test-get-testname  trec))
 		      (ip (db:test-get-item-path trec))
@@ -78,19 +79,20 @@
 
 	    (cond ;; OUTER COND
 	     ((not items) ;; when false the test is ok to be handed off to launch (but not before)
 	      (if (and (not (tests:match test-patts (tests:testqueue-get-testname test-record) item-path required: required-tests))
 	               (not (null? tal)))
-	          (loop (car tal)(cdr tal) reg reruns))
+               ;; This was (car tal)(cdr tal) in new but (car newtal)(cdr newtal) in classic
+	          (loop (car newtal)(cdr newtal) reg reruns))
 	      (let* ((run-limits-info         (cdb:remote-run runs:can-run-more-tests #f jobgroup max-concurrent-jobs)) ;; look at the test jobgroup and tot jobs running
 		      ;; (open-run-close runs:can-run-more-tests #f jobgroup max-concurrent-jobs)) ;; look at the test jobgroup and tot jobs running
 		     (have-resources          (car run-limits-info))
 		     (num-running             (list-ref run-limits-info 1))
 		     (num-running-in-jobgroup (list-ref run-limits-info 2))
 		     (max-concurrent-jobs     (list-ref run-limits-info 3))
 		     (job-group-limit         (list-ref run-limits-info 4))
-		     (prereqs-not-met         (db:get-prereqs-not-met run-id waitons item-path mode: testmode))
+		     (prereqs-not-met         (mt:get-prereqs-not-met run-id waitons item-path mode: testmode))
 		     (fails                   (runs:calc-fails prereqs-not-met))
 		     (non-completed           (runs:calc-not-completed prereqs-not-met)))
 		(debug:print-info 8 "have-resources: " have-resources " prereqs-not-met: " 
 			     (string-intersperse 
 			      (map (lambda (t)
@@ -137,10 +139,11 @@
 		        		   (mutex-unlock! registry-mutex))
 		        		 (conc test-name "/" item-path))))
 		    (thread-start! th))
 		  (cdb:remote-run runs:shrink-can-run-more-tests-count #f)   ;; DELAY TWEAKER (still needed?)
 		  (if (and (null? tal)(null? reg))
+              ;; What is the logic here? Why redo the loop with the same variable contents?
 		      (loop hed tal reg reruns)
 		      (loop (runs:queue-next-hed tal reg reglen regfull)
 			    (runs:queue-next-tal tal reg reglen regfull)
 			    (let ((newl (append reg (list hed))))
 			      (if regfull 
@@ -241,11 +244,11 @@
 	     ;;    - but only do that if resources exist to kick off the job
 	     ((or (procedure? items)(eq? items 'have-procedure))
 	      (let ((can-run-more    (cdb:remote-run runs:can-run-more-tests #f jobgroup max-concurrent-jobs)))
 		(if (and (list? can-run-more)
 			 (car can-run-more))
-		    (let* ((prereqs-not-met (db:get-prereqs-not-met run-id waitons item-path mode: testmode))
+		    (let* ((prereqs-not-met (mt:get-prereqs-not-met run-id waitons item-path mode: testmode))
 			   (fails           (runs:calc-fails prereqs-not-met))
 			   (non-completed   (runs:calc-not-completed prereqs-not-met)))
 		      (debug:print-info 8 "can-run-more: " can-run-more
 					"\n testname:        " hed
 					"\n prereqs-not-met: " (runs:pretty-string prereqs-not-met)