Index: megatest-version.scm
==================================================================
--- megatest-version.scm
+++ megatest-version.scm
@@ -1,7 +1,7 @@
 ;; Always use two digit decimal
 ;; 1.01, 1.02...1.10,1.11 ... 1.99,2.00..
 
 (declare (unit megatest-version))
 
-(define megatest-version 1.5504)
+(define megatest-version 1.5506)
 

Index: megatest.scm
==================================================================
--- megatest.scm
+++ megatest.scm
@@ -408,11 +408,11 @@
 		  (print x))
 		targets)
       (set! *didsomething* #t)))
 
 (define (full-runconfigs-read)
-  (let* ((keys   (cdb:remote-run get-keys #f))
+  (let* ((keys   (cdb:remote-run db:get-keys #f))
 	 (target (if (args:get-arg "-reqtarg")
 		     (args:get-arg "-reqtarg")
 		     (if (args:get-arg "-target")
 			 (args:get-arg "-target")
 			 #f)))

Index: runs.scm
==================================================================
--- runs.scm
+++ runs.scm
@@ -339,11 +339,11 @@
       (cdr reg)
       (if (null? tal) ;; if tal is null and reg not full then '() as reg contents moved to tal
 	  '()
 	  reg)))
 
-(define (runs:expand-items hed tal reg reruns regfull newtal jobgroup max-concurrent-jobs run-id waitons item-path testmode test-record can-run-more items runname tconfig)
+(define (runs:expand-items hed tal reg reruns regfull newtal jobgroup max-concurrent-jobs run-id waitons item-path testmode test-record can-run-more items runname tconfig reglen)
   (let* ((loop-list       (list hed tal reg reruns))
 	 (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 4 "START OF INNER COND #2 "
@@ -397,11 +397,11 @@
 
      (else
       (debug:print 4 "ERROR: No handler for this condition.")
       (list (car newtal)(cdr newtal) reg reruns)))))
 
-(define (runs:process-expanded-tests hed tal reg reruns reglen regfull test-record runname test-name item-path jobgroup max-concurrent-jobs run-id waitons item-path testmode test-patts required-tests test-registry registry-mutex flags keyvals run-info)
+(define (runs:process-expanded-tests hed tal reg reruns reglen regfull test-record runname test-name item-path jobgroup max-concurrent-jobs run-id waitons item-path testmode test-patts required-tests test-registry registry-mutex flags keyvals run-info newtal)
   (let* ((run-limits-info         (runs:can-run-more-tests 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))
@@ -629,22 +629,26 @@
 	 ((not items)
 	  (debug:print-info 4 "OUTER COND: (not items)")
 	  (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))
-	  (let ((loop-list (runs:process-expanded-tests hed tal reg reruns reglen regfull test-record runname test-name item-path jobgroup max-concurrent-jobs run-id waitons item-path testmode test-patts required-tests test-registry registry-mutex flags keyvals run-info)))
+	  (let ((loop-list (runs:process-expanded-tests hed tal reg reruns reglen regfull test-record runname test-name item-path jobgroup max-concurrent-jobs run-id waitons item-path testmode test-patts required-tests test-registry registry-mutex flags keyvals run-info newtal)))
 	    (if loop-list (apply loop loop-list))))
 
 	 ;; items processed into a list but not came in as a list been processed
 	 ;;
 	 ((and (list? items)     ;; thus we know our items are already calculated
 	       (not   itemdat))  ;; and not yet expanded into the list of things to be done
 	  (debug:print-info 4 "OUTER COND: (and (list? items)(not itemdat))")
-	  (if (and (debug:debug-mode 1) ;; (>= *verbosity* 1)
+	  ;; Must determine if the items list is valid. Discard the test if it is not.
+	  (if (and (list? items)
 		   (> (length items) 0)
-		   (> (length (car items)) 0))
+		   (and (list? (car items))
+			(> (length (car items)) 0))
+		   (debug:debug-mode 1))
 	      (pp items))
+	  
 	  (for-each
 	   (lambda (my-itemdat)
 	     (let* ((new-test-record (let ((newrec (make-tests:testqueue)))
 				       (vector-copy! test-record newrec)
 				       newrec))
@@ -655,25 +659,30 @@
 		     (tests:testqueue-set-itemdat!   new-test-record my-itemdat)
 		     (tests:testqueue-set-item_path! new-test-record my-item-path)
 		     (hash-table-set! test-records newtestname new-test-record)
 		     (set! tal (append tal (list newtestname))))))) ;; since these are itemized create new test names testname/itempath
 	   items)
+
+	  ;; (debug:print-info 0 "Test " (tests:testqueue-get-testname test-record) " is itemized but has no items")
+
 	  ;; At this point we have possibly added items to tal but all must be handed off to 
 	  ;; INNER COND logic. I think loop without rotating the queue 
 	  ;; (loop hed tal reg reruns))
 	  ;; (let ((newtal (append tal (list hed))))  ;; We should discard hed as it has been expanded into it's items? Yes, but only if this *is* an itemized test
 	  ;; (loop (car newtal)(cdr newtal) reg reruns)
-	  (loop (car tal)(cdr tal) reg reruns))
+	  (if (null? tal)
+	      #f
+	      (loop (car tal)(cdr tal) reg reruns)))
 	    
 	 ;; if items is a proc then need to run items:get-items-from-config, get the list and loop 
 	 ;;    - but only do that if resources exist to kick off the job
 	 ;; EXPAND ITEMS
 	 ((or (procedure? items)(eq? items 'have-procedure))
 	  (let ((can-run-more    (runs:can-run-more-tests jobgroup max-concurrent-jobs)))
 	    (if (and (list? can-run-more)
 		     (car can-run-more))
-		(let ((loop-list (runs:expand-items hed tal reg reruns regfull newtal jobgroup max-concurrent-jobs run-id waitons item-path testmode test-record can-run-more items runname tconfig)))
+		(let ((loop-list (runs:expand-items hed tal reg reruns regfull newtal jobgroup max-concurrent-jobs run-id waitons item-path testmode test-record can-run-more items runname tconfig reglen)))
 		  (if loop-list
 		      (apply loop loop-list)))
 		;; if can't run more just loop with next possible test
 		(loop (car newtal)(cdr newtal) reg reruns))))
 	    

Index: tests/Makefile
==================================================================
--- tests/Makefile
+++ tests/Makefile
@@ -16,11 +16,11 @@
 
 # The NEWTARGET causes some tests to fail. Do not use until this is fixed.
 NEWTARGET  = "$(OS)/$(FS)/$(VER)"
 TARGET     = "ubuntu/nfs/none"
 
-all : test1 test2 test3 test4 test5
+all : test1 test2 test3 test4 test5 test6 test7 test8 test9
 
 server :
 	cd ..;make;make install
 	cd fullrun;../../bin/megatest -server - -debug 22 &
 
@@ -60,12 +60,14 @@
 	cd fullrun;sleep 0;$(MEGATEST) -runtests % -target $(TARGET) :runname $(RUNNAME)_aa -debug $(DEBUG) $(LOGGING) > aa.log 2> aa.log &
 	cd fullrun;sleep 0;$(MEGATEST) -runtests % -target $(TARGET) :runname $(RUNNAME)_ab -debug $(DEBUG) $(LOGGING) > ab.log 2> ab.log &
 	cd fullrun;sleep 0;$(MEGATEST) -runtests % -target $(TARGET) :runname $(RUNNAME)_ac -debug $(DEBUG) $(LOGGING) > ac.log 2> ac.log &
 	cd fullrun;sleep 0;$(MEGATEST) -runtests % -target $(TARGET) :runname $(RUNNAME)_ad -debug $(DEBUG) $(LOGGING) > ad.log 2> ad.log &	
 #	cd fullrun;sleep 0;$(MEGATEST) -runtests % -target $(TARGET) :runname $(RUNNAME)_ae -debug $(DEBUG) $(LOGGING) > ae.log 2> ae.log &	
-#	cd fullrun;sleep 0;$(MEGATEST) -runtests % -target $(TARGET) :runname $(RUNNAME)_af -debug $(DEBUG) $(LOGGING) > af.log 2> af.log &	
-	cd fullrun;sleep 10;$(MEGATEST) -run-wait  -target $(TARGET) :runname % -testpatt % :state RUNNING,LAUNCHED,NOT_STARTED,REMOTEHOSTSTART;echo ALL DONE
+#	cd fullrun;sleep 0;$(MEGATEST) -runtests % -target $(TARGET) :runname $(RUNNAME)_af -debug $(DEBUG) $(LOGGING) > af.log 2> af.log &	a
+
+# MUST ADD THIS BACK IN ASAP!!!!
+	# cd fullrun;sleep 10;$(MEGATEST) -run-wait  -target $(TARGET) :runname % -testpatt % :state RUNNING,LAUNCHED,NOT_STARTED,REMOTEHOSTSTART;echo ALL DONE
 
 test6: fullprep
 	cd fullrun;$(MEGATEST) -runtests runfirst -testpatt %/1 -reqtarg ubuntu/nfs/none :runname $(RUNNAME)_itempatt -v
 	cd fullrun;$(MEGATEST) -runtests runfirst -testpatt %blahha% -reqtarg ubuntu/nfs/none :runname $(RUNNAME)_itempatt -debug 10
 	cd fullrun;$(MEGATEST) -rollup :runname newrun -target ubuntu/nfs/none -debug 10
@@ -93,11 +95,11 @@
 	cd fullrun;$(MEGATEST) -runtests runfirst/fall 1 -target ubuntu/nfs/none :runname $(RUNNAME)_singleitem
 	cd fullrun;$(MEGATEST) -runtests test_mt_vars/2 -target ubuntu/nfs/none :runname $(RUNNAME)_singleitem_waiton
 
 # Some simple checks for bootstrapping and run loop logic 
 
-test9 : minsetup test9a test9b test9c
+test9 : minsetup test9a test9b test9c test9d
 
 test9a :
 	@echo Run super-simple mintest e, no waitons.
 	cd mintest;megatest -runtests e -target $(VER) :runname `date +%H.%M.%S` -debug $(DEBUG)
 

Index: tests/fdktestqa/testqa/Makefile
==================================================================
--- tests/fdktestqa/testqa/Makefile
+++ tests/fdktestqa/testqa/Makefile
@@ -1,8 +1,9 @@
-BINDIR=$(PWD)/../../../bin
-MEGATEST=$(BINDIR)/megatest
-DASHBOARD=$(BINDIR)/dashboard
+BINDIR    = $(PWD)/../../../bin
+PATH     := $(BINDIR):$(PATH)
+MEGATEST  = $(BINDIR)/megatest
+DASHBOARD = $(BINDIR)/dashboard
 all :
 	$(MEGATEST) -runtests % -target a/b :runname c
 
 bigbig :
 	for tn in a b c d;do \

Index: tests/mintest/tests/f/testconfig
==================================================================
--- tests/mintest/tests/f/testconfig
+++ tests/mintest/tests/f/testconfig
@@ -1,6 +1,6 @@
 # Add steps here. Format is "stepname script"
 [ezsteps]
 step1 echo SUCCESS
 
 [requirements]
-waiton b
+waiton