@@ -246,11 +246,11 @@
 		   );; obviously haven't had any work to do for a while
         	  (else 0)))
   
   (let* ((num-running             (rmt:get-count-tests-running run-id))
 	 (num-running-in-jobgroup (rmt:get-count-tests-running-in-jobgroup run-id jobgroup))
-	 (job-group-limit         (let ((jobg-count (config-lookup *configdat* "jobgroups" jobgroup)))
+	 (job-group-limit         (let ((jobg-count (configf:lookup *configdat* "jobgroups" jobgroup)))
 				    (if (string? jobg-count)
 					(string->number jobg-count)
 					jobg-count))))
     (if (> (+ num-running num-running-in-jobgroup) 0)
 	(runs:inc-can-run-more-tests-count runsdat)) ;; (set! *runs:can-run-more-tests-count* (+ *runs:can-run-more-tests-count* 1)))
@@ -386,11 +386,12 @@
          (waitors-upon       (make-hash-table)) ;; given a test, return list of tests waiting upon this test.
 	 (task-key           (conc (hash-table->alist flags) " " (get-host-name) " " (current-process-id)))
 	 ;; (tdbdat             (tasks:open-db))
 	 (config-reruns      (let ((x (configf:lookup *configdat* "setup" "reruns")))
 			       (if x (string->number x) #f)))
-	 (allowed-tests      #f))
+	 (allowed-tests      #f)
+	 (runconf            #f))
 
     ;; check if readonly
     (when readonly-mode
       (debug:print-error 0 *default-log-port* "megatest.db is readonly.  Cannot proceed.")
       (exit 1))
@@ -546,11 +547,11 @@
 	  (let*-values (((waitons waitors config) (tests:get-waitons hed all-tests-registry))
 
 			;; NOTE: Have the config - can extract [waitons] section
 			
                         ((hed-mode)
-                         (let ((m (config-lookup config "requirements" "mode")))
+                         (let ((m (configf:lookup config "requirements" "mode")))
                            (if m (map string->symbol (string-split m)) '(normal))))
                         ((hed-itemized-waiton) ;; are items in hed waiting on items of waiton?
                          (not (null? (lset-intersection eq? hed-mode '(itemmatch itemwait)))))
                         )
 	    (debug:print-info 8 *default-log-port* "waitons: " waitons)
@@ -567,11 +568,11 @@
 	    (if (not (hash-table-ref/default test-records hed #f)) ;; waiton-tconfig below will be #f until that test is visted here at least once
 		(hash-table-set! test-records ;; BB: we are doing a manual make-tests:testqueue
 				 hed (vector hed     ;; 0 ;; testname
 					     config  ;; 1 
 					     waitons ;; 2 
-					     (config-lookup config "requirements" "priority")     ;; priority 3
+					     (configf:lookup config "requirements" "priority")     ;; priority 3
 					     (tests:get-items config) ;; 4 ;; expand the [items] and or [itemstable] into explict items
 					     #f      ;; itemsdat 5
 					     #f      ;; spare - used for item-path
 					     waitors ;; 
 					     )))
@@ -1346,11 +1347,11 @@
          (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-retries           (configf:lookup *configdat* "setup" "maxretries"))
          (max-concurrent-jobs   (configf:lookup-number *configdat* "setup" "max_concurrent_jobs" default: 50))
          (reglen                (if (number? reglen-in) reglen-in 1))
          (last-time-incomplete  (- (current-seconds) 900)) ;; force at least one clean up cycle
          (last-time-some-running (current-seconds))
          ;; (tdbdat                (tasks:open-db))
@@ -1416,12 +1417,12 @@
 
       ;; (print "Top of loop, hed=" hed ", tal=" tal " ,reruns=" reruns)
       (let* ((test-record (hash-table-ref test-records hed))
 	     (test-name   (tests:testqueue-get-testname test-record))
 	     (tconfig     (tests:testqueue-get-testconfig test-record))
-	     (jobgroup    (config-lookup tconfig "test_meta" "jobgroup"))
-	     (testmode    (let ((m (config-lookup tconfig "requirements" "mode")))
+	     (jobgroup    (configf:lookup tconfig "test_meta" "jobgroup"))
+	     (testmode    (let ((m (configf:lookup tconfig "requirements" "mode")))
 			    (if m (map string->symbol (string-split m)) '(normal))))
 	     (itemmaps    (tests:get-itemmaps tconfig)) ;;  (configf:lookup tconfig "requirements" "itemmap"))
 	     (priority    (tests:testqueue-get-priority   test-record))
 	     (itemdat     (tests:testqueue-get-itemdat    test-record)) ;; itemdat can be a string, list or #f
 	     (items       (tests:testqueue-get-items      test-record))
@@ -2541,11 +2542,11 @@
 	  (rmt:testmeta-add-record test-name)))
     (for-each 
      (lambda (key)
        (let* ((idx (cadr key))
 	      (fld (car  key))
-	      (val (config-lookup test-conf "test_meta" fld)))
+	      (val (configf:lookup test-conf "test_meta" fld)))
 	 ;; (debug:print 5 *default-log-port* "idx: " idx " fld: " fld " val: " val)
 	 (if (and val (not (equal? (vector-ref currrecord idx) val)))
 	     (begin
 	       (print "Updating " test-name " " fld " to " val)
 	       (rmt:testmeta-update-field test-name fld val)))))
@@ -2576,11 +2577,11 @@
      (hash-table-keys test-names))))
 
 ;; This could probably be refactored into one complex query ...
 ;; NOT PORTED - DO NOT USE YET
 ;;
-(define (runs:rollup-run keys runname user keyvals)
+#;(define (runs:rollup-run keys runname user keyvals)
   (debug:print 4 *default-log-port* "runs:rollup-run, keys: " keys " -runname " runname " user: " user)
   (let* ((db              #f)
 	 ;; register run operates on the main db
 	 (new-run-id      (rmt:register-run keyvals runname "new" "n/a" user (args:get-arg "-contour")))
 	 (prev-tests      (rmt:get-matching-previous-test-run-records new-run-id "%" "%"))