Index: common.scm
==================================================================
--- common.scm
+++ common.scm
@@ -244,11 +244,11 @@
 (define (common:args-get-target #!key (split #f))
   (let* ((target  (if (args:get-arg "-reqtarg")
 		      (args:get-arg "-reqtarg")
 		      (if (args:get-arg "-target")
 			  (args:get-arg "-target")
-			  #f)))
+			  (getenv "MT_TARGET"))))
 	 (tlist   (if target (string-split target "/" #t) '()))
 	 (valid   (if target
 		      (and (not (null? tlist))
 			   (null? (filter string-null? tlist)))
 		      #f)))

Index: configf.scm
==================================================================
--- configf.scm
+++ configf.scm
@@ -111,11 +111,11 @@
 	      (print "ERROR: " cmd " returned bad exit code " status)))
 	  ""))))
 
 ;; Lookup a value in runconfigs based on -reqtarg or -target
 (define (runconfigs-get config var)
-  (let ((targ (or (args:get-arg "-reqtarg")(args:get-arg "-target"))))
+  (let ((targ (or (args:get-arg "-reqtarg")(args:get-arg "-target")(getenv "MT_TARGET"))))
     (if targ
 	(or (configf:lookup config targ var)
 	    (configf:lookup config "default" var))
 	(configf:lookup config "default" var))))
 

Index: dashboard-tests.scm
==================================================================
--- dashboard-tests.scm
+++ dashboard-tests.scm
@@ -660,11 +660,13 @@
 						      ";megatest -target " keystring " -runname " runname 
 						      " -runtests " (conc testname "/" (if (equal? item-path "")
 											   "%" 
 											   item-path))
 						      )))
-				       (system (conc cmd " &")))))
+				       (system (conc (dtests:get-pre-command)
+						     cmd 
+						     (dtests:get-post-command))))))
 	       (remove-test (lambda (x)
 			      (iup:attribute-set!
 			       command-text-box "VALUE"
 			       (conc "megatest -remove-runs -target " keystring " -runname " runname
 				     " -testpatt " (conc testname "/" (if (equal? item-path "")

Index: dashboard.scm
==================================================================
--- dashboard.scm
+++ dashboard.scm
@@ -81,11 +81,11 @@
 (if (args:get-arg "-h")
     (begin
       (print help)
       (exit)))
 
-(if (not (setup-for-run))
+(if (not (launch:setup-for-run))
     (begin
       (print "Failed to find megatest.config, exiting") 
       (exit 1)))
 
 (define *dbdir* (conc (configf:lookup *configdat* "setup" "linktree") "/.db"))
@@ -137,22 +137,34 @@
 				     (vector "Sort -a" 'testname   "DESC")
 				     (vector "Sort +t" 'event_time "ASC")
 				     (vector "Sort -t" 'event_time "DESC")
 				     (vector "Sort +s" 'statestatus "ASC")
 				     (vector "Sort -s" 'statestatus "DESC")))
+
+(define *tests-sort-type-index* '(("+testname" 0)
+				  ("-testname" 1)
+				  ("+event_time" 2)
+				  ("-event_time" 3)
+				  ("+statestatus" 4)
+				  ("-statestatus" 5)))
 
 ;; Don't forget to adjust the >= below if you add to the sort-options above
 (define (next-sort-option)
   (if (>= *tests-sort-reverse* 5)
       (set! *tests-sort-reverse* 0)
       (set! *tests-sort-reverse* (+ *tests-sort-reverse* 1)))
   *tests-sort-reverse*)
+
+(define *tests-sort-reverse* 
+  (let ((t-sort (assoc (configf:lookup *configdat* "dashboard" "testsort") *tests-sort-type-index*)))
+    (if t-sort
+	(cadr t-sort)
+	3)))
 
 (define (get-curr-sort)
   (vector-ref *tests-sort-options* *tests-sort-reverse*))
 
-(define *tests-sort-reverse* 3)
 (define *hide-empty-runs* #f)
 (define *hide-not-hide* #t) ;; toggle for hide/not hide
 (define *hide-not-hide-button* #f)
 (define *hide-not-hide-tabs* #f)
 
@@ -462,11 +474,17 @@
 			   (testfullname (test:test-get-fullname test))
 			   (teststatus (db:test-get-status   test))
 			   (teststate  (db:test-get-state    test))
 			   ;;(teststart  (db:test-get-event_time test))
 			   (runtime    (db:test-get-run_duration test))
-			   (buttontxt  (if (equal? teststate "COMPLETED") teststatus teststate))
+			   (buttontxt  (cond
+					((equal? teststate "COMPLETED") teststatus)
+					((and (equal? teststate "NOT_STARTED")
+					      (member teststatus '("ZERO_ITEMS" "BLOCKED" "PREQ_FAIL" "PREQ_DISCARDED" "KEEP_TRYING" "TEN_STRIKES")))
+					 teststatus)
+					(else
+					 teststate)))
 			   (button     (vector-ref columndat rown))
 			   (color      (car (gutils:get-color-for-state-status teststate teststatus)))
 			   (curr-color (vector-ref buttondat 1)) ;; (iup:attribute button "BGCOLOR"))
 			   (curr-title (vector-ref buttondat 2))) ;; (iup:attribute button "TITLE")))
 		      (if (not (equal? curr-color color))
@@ -681,47 +699,14 @@
 	    (hash-table-set! tests-draw-state 'scalef 8)
 	    (hash-table-set! tests-draw-state 'tests-info (make-hash-table))
 	    (hash-table-set! tests-draw-state 'selected-tests (make-hash-table))
 	    ;; set these 
 	    (hash-table-set! tests-draw-state 'test-browse-xoffset 20) ;; (- 0 (* (/ sizex 2) (* 8 xadj))))
-	    (hash-table-set! tests-draw-state 'test-browse-yoffset 20))) ;; (- 0 (* (/ sizey 2) (* 8 (- 1 yadj)))))))
-      (let* ((scalef (hash-table-ref/default tests-draw-state 'scalef 8))
-	     (test-browse-xoffset (hash-table-ref tests-draw-state 'test-browse-xoffset))
-	     (test-browse-yoffset (hash-table-ref tests-draw-state 'test-browse-yoffset))
-	     (xtorig (+ test-browse-xoffset (* (/ sizex 2) scalef (- 0.5 xadj)))) ;;  (- xadj 1))))
-	     (ytorig (+ test-browse-yoffset (* (/ sizey 2) scalef (- yadj 0.5))))
-	     (boxw   90)
-	     (boxh   25)
-	     (gapx   20)
-	     (gapy   30)
-	     (tests-hash     (hash-table-ref tests-draw-state 'tests-info))
-	     (selected-tests (hash-table-ref tests-draw-state 'selected-tests )))
-	;; (print "sizex: " sizex " sizey: " sizey " font: " (canvas-font cnv) " originx: " originx " originy: " originy " xtorig: " xtorig " ytorig: " ytorig " xadj: " xadj " yadj: " yadj)
-	(let loop ((hed (car (reverse sorted-testnames)))
-		   (tal (cdr (reverse sorted-testnames)))
-		   (llx xtorig)
-		   (lly ytorig)
-		   (urx (+ xtorig boxw))
-		   (ury (+ ytorig boxh)))
-	  ; (print "hed " hed " llx " llx " lly " lly " urx " urx " ury " ury)
-	  (canvas-text! cnv (+ llx 5)(+ lly 5) hed) ;; (conc testname " (" xtorig "," ytorig ")"))
-	  (canvas-rectangle! cnv llx urx lly ury)
-	  (if (hash-table-ref/default selected-tests hed #f)
-	      (canvas-box! cnv llx (+ llx 5) lly (+ lly 5)))
-	  (hash-table-set! tests-hash hed (list llx urx (- sizey ury)(- sizey lly))) ;; NB// Swap ury and lly
-	  (if (not (null? tal))
-	      ;; leave a column of space to the right to list items
-	      (let ((have-room 
-		     (if #t ;; put "auto" here where some form of auto rearanging can be done
-			 (> (* 3 (+ boxw gapx)) (- urx xtorig))
-			 (< urx (- sizex boxw gapx boxw)))))  ;; is there room for another column?
-		(loop (car tal)
-		      (cdr tal)
-		      (if have-room (+ llx boxw gapx) xtorig) ;; have room, 
-		      (if have-room lly (+ lly boxh gapy))
-		      (if have-room (+ urx boxw gapx) (+ xtorig boxw))
-		      (if have-room ury (+ ury boxh gapy)))))))))
+	    (hash-table-set! tests-draw-state 'test-browse-yoffset 20) ;; (- 0 (* (/ sizey 2) (* 8 (- 1 yadj)))))))
+	    (dcommon:initial-draw-tests cnv xadj yadj sizex sizey sizexmm sizeymm originx originy tests-draw-state sorted-testnames))
+	  (dcommon:redraw-tests cnv xadj yadj sizex sizey sizexmm sizeymm originx originy tests-draw-state sorted-testnames))
+      ))
 
 ;;======================================================================
 ;; R U N   C O N T R O L S
 ;;======================================================================
 ;;
@@ -804,11 +789,11 @@
 	    (dboard:data-set-command! *data* default-cmd)
 	    lb)))
 
 	(iup:frame
 	 #:title "Runname"
-	 (let* ((default-run-name (conc "ww" (seconds->work-week/day (current-seconds))))
+	 (let* ((default-run-name (seconds->work-week/day (current-seconds)))
 		(tb (iup:textbox #:expand "HORIZONTAL"
 				 #:action (lambda (obj val txt)
 					    ;; (print "obj: " obj " val: " val " unk: " unk)
 					    (dboard:data-set-run-name! *data* txt) ;; (iup:attribute obj "VALUE"))
 					    (dashboard:update-run-command))
@@ -886,65 +871,76 @@
        (iup:frame
 	#:title "Tests and Tasks"
 	(let* ((updater #f)
 	       (last-xadj 0)
 	       (last-yadj 0)
-	       (canvas-obj   
-	(iup:canvas #:action (make-canvas-action
-			      (lambda (cnv xadj yadj)
-				(if (not updater)
-				    (set! updater (lambda (xadj yadj)
-						    ;; (print "cnv: " cnv " x: " x " y: " y)
-						    (dashboard:draw-tests cnv xadj yadj tests-draw-state sorted-testnames))))
-				(updater xadj yadj)
-				(set! last-xadj xadj)
-				(set! last-yadj yadj)))
-		    ;; Following doesn't work 
-		    ;; #:wheel-cb (make-canvas-action
-		    ;;           (lambda (cnv xadj yadj)
-		    ;;    	 ;; (print "cnv: " cnv " x: " x " y: " y)
-		    ;;    	 (dashboard:draw-tests cnv xadj yadj tests-draw-state sorted-testnames)))
-		    ;; #:size "50x50"
-		    #:expand "YES"
-		    #:scrollbar "YES"
-		    #:posx "0.5"
-		    #:posy "0.5"
-		    #:button-cb (lambda (obj btn pressed x y status)
-				  ;; (print "obj: " obj)
-				  (let ((tests-info     (hash-table-ref tests-draw-state  'tests-info))
-					(selected-tests (hash-table-ref tests-draw-state  'selected-tests)))
-				    ;; (print "x\ty\tllx\tlly\turx\tury")
-				    (for-each (lambda (test-name)
-						(let* ((rec-coords (hash-table-ref tests-info test-name))
-						       (llx        (list-ref rec-coords 0))
-						       (urx        (list-ref rec-coords 1))
-						       (lly        (list-ref rec-coords 2))
-						       (ury        (list-ref rec-coords 3)))
-						  ;; (print x "\t" y "\t" llx "\t" lly "\t" urx "\t" ury "\t" test-name " "
-						  (if (and (eq? pressed 1)
-							   (> x llx)
-							   (> y lly)
-							   (< x urx)
-							   (< y ury))
-						      (let ((patterns (string-split (iup:attribute test-patterns-textbox "VALUE"))))
-							(let* ((selected     (not (member test-name patterns)))
-							       (newpatt-list (if selected
-										 (cons test-name patterns)
-										 (delete test-name patterns)))
-							       (newpatt      (string-intersperse newpatt-list "\n")))
-							  ;; (if cnv-obj
-							  ;;    (dashboard:draw-tests cnv-obj 0 0 tests-draw-state sorted-testnames))
-							  (iup:attribute-set! obj "REDRAW" "ALL")
-							  (hash-table-set! selected-tests test-name selected)
-							  (iup:attribute-set! test-patterns-textbox "VALUE" newpatt)
-							  (dboard:data-set-test-patts! *data* (dboard:lines->test-patt newpatt))
-							  (dashboard:update-run-command)
-							  (if updater (updater last-xadj last-yadj)))))))
-					      (hash-table-keys tests-info)))))))
+	       (the-cnv   #f)
+	       (canvas-obj 
+                (iup:canvas #:action (make-canvas-action
+				      (lambda (cnv xadj yadj)
+					(if (not updater)
+					    (set! updater (lambda (xadj yadj)
+							    ;; (print "cnv: " cnv " xadj: " xadj " yadj: " yadj)
+							    (dashboard:draw-tests cnv xadj yadj tests-draw-state sorted-testnames)
+							    (set! last-xadj xadj)
+							    (set! last-yadj yadj))))
+					(updater xadj yadj)
+					(set! the-cnv cnv)
+					))
+			    ;; Following doesn't work 
+			    #:wheel-cb (lambda (obj step x y dir) ;; dir is 4 for up and 5 for down. I think.
+					 (let ((xadj last-xadj)
+					       (yadj (+ last-yadj (if (> step 0)
+								      -0.01
+								      0.01))))
+					   ;; (print "step: " step " x: " x " y: " y " dir: \"" dir "\"")
+					   ;; (print "the-cnv: " the-cnv " obj: " obj " xadj: " xadj " yadj: " yadj " dir: " dir)
+					   (if the-cnv
+					       (dashboard:draw-tests the-cnv xadj yadj tests-draw-state sorted-testnames))
+					   (set! last-xadj xadj)
+					   (set! last-yadj yadj)
+					   ))
+			    ;; #:size "50x50"
+			    #:expand "YES"
+			    #:scrollbar "YES"
+			    #:posx "0.5"
+			    #:posy "0.5"
+			    #:button-cb (lambda (obj btn pressed x y status)
+					  ;; (print "obj: " obj)
+					  (let ((tests-info     (hash-table-ref tests-draw-state  'tests-info))
+						(selected-tests (hash-table-ref tests-draw-state  'selected-tests)))
+					    ;; (print "x\ty\tllx\tlly\turx\tury")
+					    (for-each (lambda (test-name)
+							(let* ((rec-coords (hash-table-ref tests-info test-name))
+							       (llx        (list-ref rec-coords 0))
+							       (urx        (list-ref rec-coords 1))
+							       (lly        (list-ref rec-coords 2))
+							       (ury        (list-ref rec-coords 3)))
+							  ;; (print x "\t" y "\t" llx "\t" lly "\t" urx "\t" ury "\t" test-name " "
+							  (if (and (eq? pressed 1)
+								   (> x llx)
+								   (> y lly)
+								   (< x urx)
+								   (< y ury))
+							      (let ((patterns (string-split (iup:attribute test-patterns-textbox "VALUE"))))
+								(let* ((selected     (not (member test-name patterns)))
+								       (newpatt-list (if selected
+											 (cons test-name patterns)
+											 (delete test-name patterns)))
+								       (newpatt      (string-intersperse newpatt-list "\n")))
+								  ;; (if cnv-obj
+								  ;;    (dashboard:draw-tests cnv-obj 0 0 tests-draw-state sorted-testnames))
+								  (iup:attribute-set! obj "REDRAW" "ALL")
+								  (hash-table-set! selected-tests test-name selected)
+								  (iup:attribute-set! test-patterns-textbox "VALUE" newpatt)
+								  (dboard:data-set-test-patts! *data* (dboard:lines->test-patt newpatt))
+								  (dashboard:update-run-command)
+								  (if updater (updater last-xadj last-yadj)))))))
+						      (hash-table-keys tests-info)))))))
 	  canvas-obj)))
       ;; (print "obj: " obj " btn: " btn " pressed: " pressed " x: " x " y: " y " status: " status))
-      
+       
       (iup:frame
        #:title "Logs" ;; To be replaced with tabs
        (let ((logs-tb (iup:textbox #:expand "YES"
 				   #:multiline "YES")))
 	 (dboard:data-set-logs-textbox! *data* logs-tb)
@@ -1213,14 +1209,25 @@
 	      ;;  		      (mark-for-update)
 	      ;;  		      (update-search "item-name" val))
 	      ))
 	    (iup:vbox
 	     (iup:hbox
-	      (iup:button "Sort -t"   #:action (lambda (obj)
-						 (next-sort-option)
-						 (iup:attribute-set! obj "TITLE" (vector-ref (vector-ref *tests-sort-options* *tests-sort-reverse*) 0))
-						 (mark-for-update)))
+	      (let* ((cmds-list '("+testname" "-testname" "+event_time" "-event_time" "+statestatus" "-statestatus"))
+		     (lb         (iup:listbox #:expand "HORIZONTAL"
+					      #:dropdown "YES"
+					      #:action (lambda (obj val index lbstate)
+							 (set! *tests-sort-reverse* index)
+							 (mark-for-update))))
+		     (default-cmd (car (list-ref *tests-sort-type-index* *tests-sort-reverse*))))
+		(iuplistbox-fill-list lb cmds-list selected-item: default-cmd)
+		(mark-for-update)
+		;; (set! *tests-sort-reverse* *tests-sort-reverse*0)
+		lb)
+	      ;; (iup:button "Sort -t"   #:action (lambda (obj)
+	      ;;   				 (next-sort-option)
+	      ;;   				 (iup:attribute-set! obj "TITLE" (vector-ref (vector-ref *tests-sort-options* *tests-sort-reverse*) 0))
+	      ;;   				 (mark-for-update)))
 	      (iup:button "HideEmpty" #:action (lambda (obj)
 						 (set! *hide-empty-runs* (not *hide-empty-runs*))
 						 (iup:attribute-set! obj "TITLE" (if *hide-empty-runs* "+HideE" "-HideE"))
 						 (mark-for-update)))
 	      (let ((hideit (iup:button "HideTests" #:action (lambda (obj)
@@ -1429,11 +1436,11 @@
 ;;
 (define *last-db-update-time* (file-modification-time *db-file-path*)) ;; (conc *toppath* "/db/main.db")))
 (define *last-recalc-ended-time* 0)
 
 (define (dashboard:been-changed)
-  (> (file-modification-time *db-file-path* *last-db-update-time*)))
+  (> (file-modification-time *db-file-path*) *last-db-update-time*))
 
 (define (dashboard:set-db-update-time)
   (set! *last-db-update-time* (file-modification-time *db-file-path*)))
 
 (define (dashboard:recalc modtime please-update-buttons last-db-update-time)
@@ -1544,7 +1551,27 @@
 			     (mutex-lock! *update-mutex*)
 			     (set! *update-is-running* #f)
 			     (mutex-unlock! *update-mutex*))))
 		       1))))
 
-(iup:main-loop)
-(db:close-all *dbstruct-local*)
+(let ((th1 (make-thread (lambda ()
+			  (thread-sleep! 1)
+			  (set! *please-update-buttons* #t)
+			  (dashboard:run-update 1)) "update buttons once"))
+			  ;; need to wait for first *update-is-running* #t
+			  ;; (let loop ()
+			  ;;   (mutex-lock! *update-mutex*)
+			  ;;   (if *update-is-running*
+			  ;;       (begin
+			  ;;         (set! *please-update-buttons* #t)
+			  ;;         (mark-for-update)
+			  ;;         (print "Did redraw trigger")) "First update after startup")
+			  ;;   (mutex-unlock! *update-mutex*)
+			  ;;   (thread-sleep! 1)
+			  ;;   (if (not *please-update-buttons*)
+			  ;;       (loop))))))
+      (th2 (make-thread iup:main-loop "Main loop")))
+  (thread-start! th1)
+  (thread-start! th2)
+  (thread-join! th2))
+
+;; (iup:main-loop)(db:close-all *dbstruct-local*)

Index: dcommon.scm
==================================================================
--- dcommon.scm
+++ dcommon.scm
@@ -545,6 +545,89 @@
 		       ;;  					     ;; set positon using coordinates or center, start, top, left, end, bottom, right, parent-center, current
 		       ;;  					     ;; #:x 'mouse
 		       ;;  					     ;; #:y 'mouse
 		       ;;  )					     
 		       ))))
+
+;;======================================================================
+;; CANVAS STUFF FOR TESTS
+;;======================================================================
+
+(define (dcommon:draw-test cnv x y w h name selected)
+  (let* ((llx x)
+	 (lly y)
+	 (urx (+ x w))
+	 (ury (+ y h)))
+    (canvas-text! cnv (+ llx 5)(+ lly 5) name) ;; (conc testname " (" xtorig "," ytorig ")"))
+    (canvas-rectangle! cnv llx urx lly ury)
+    (if selected (canvas-box! cnv llx (+ llx 5) lly (+ lly 5)))))
+
+(define (dcommon:initial-draw-tests cnv xadj yadj sizex sizey sizexmm sizeymm originx originy tests-draw-state sorted-testnames)
+      (let* ((scalef (hash-table-ref/default tests-draw-state 'scalef 8))
+	     (test-browse-xoffset (hash-table-ref tests-draw-state 'test-browse-xoffset))
+	     (test-browse-yoffset (hash-table-ref tests-draw-state 'test-browse-yoffset))
+	     (xtorig (+ test-browse-xoffset (* (/ sizex 2) scalef (- 0.5 xadj)))) ;;  (- xadj 1))))
+	     (ytorig (+ test-browse-yoffset (* (/ sizey 2) scalef (- yadj 0.5))))
+	     (boxw   90) ;; default, overriden by length estimate below
+	     (boxh   25)
+	     (gapx   20)
+	     (gapy   30)
+	     (tests-hash     (hash-table-ref tests-draw-state 'tests-info))
+	     (selected-tests (hash-table-ref tests-draw-state 'selected-tests )))
+	(hash-table-set! tests-draw-state 'xtorig xtorig)
+	(hash-table-set! tests-draw-state 'ytorig ytorig)
+	(let ((longest-str   (car (sort sorted-testnames (lambda (a b)(>= (string-length a)(string-length b)))))))
+	  (let-values (((x-max y-max) (canvas-text-size cnv longest-str)))
+             (if (> x-max boxw)(set! boxw (+ 10 x-max)))))
+	;; (print "sizex: " sizex " sizey: " sizey " font: " (canvas-font cnv) " originx: " originx " originy: " originy " xtorig: " xtorig " ytorig: " ytorig " xadj: " xadj " yadj: " yadj)
+	(let loop ((hed (car (reverse sorted-testnames)))
+		   (tal (cdr (reverse sorted-testnames)))
+		   (llx xtorig)
+		   (lly ytorig)
+		   (urx (+ xtorig boxw))
+		   (ury (+ ytorig boxh)))
+	  ; (print "hed " hed " llx " llx " lly " lly " urx " urx " ury " ury)
+	  (dcommon:draw-test cnv llx lly boxw boxh hed (hash-table-ref/default selected-tests hed #f))
+	  ;; data used by mouse click calc. keep the wacky order for now.
+	  (hash-table-set! tests-hash hed  (list llx urx (- sizey ury)(- sizey lly) lly boxw boxh)) 
+	  ;; (list llx lly boxw boxh)) ;; NB// Swap ury and lly
+	  (if (not (null? tal))
+	      ;; leave a column of space to the right to list items
+	      (let ((have-room 
+		     (if #t ;; put "auto" here where some form of auto rearanging can be done
+			 (> (* 3 (+ boxw gapx)) (- urx xtorig))
+			 (< urx (- sizex boxw gapx boxw)))))  ;; is there room for another column?
+		(loop (car tal)
+		      (cdr tal)
+		      (if have-room (+ llx boxw gapx) xtorig) ;; have room, 
+		      (if have-room lly (+ lly boxh gapy))
+		      (if have-room (+ urx boxw gapx) (+ xtorig boxw))
+		      (if have-room ury (+ ury boxh gapy))))))))
+
+(define (dcommon:redraw-tests cnv xadj yadj sizex sizey sizexmm sizeymm originx originy tests-draw-state sorted-testnames)
+  (let* ((scalef (hash-table-ref/default tests-draw-state 'scalef 8))
+	 (test-browse-xoffset (hash-table-ref tests-draw-state 'test-browse-xoffset))
+	 (test-browse-yoffset (hash-table-ref tests-draw-state 'test-browse-yoffset))
+	 (xtorig (+ test-browse-xoffset (* (/ sizex 2) scalef (- 0.5 xadj)))) ;;  (- xadj 1))))
+	 (ytorig (+ test-browse-yoffset (* (/ sizey 2) scalef (- yadj 0.5))))
+	 (xdelta (- (hash-table-ref tests-draw-state 'xtorig) xtorig))
+	 (ydelta (- (hash-table-ref tests-draw-state 'ytorig) ytorig))
+	 (tests-hash     (hash-table-ref tests-draw-state 'tests-info))
+	 (selected-tests (hash-table-ref tests-draw-state 'selected-tests )))
+    (hash-table-set! tests-draw-state 'xtorig xtorig)
+    (hash-table-set! tests-draw-state 'ytorig ytorig)
+    (let loop ((hed (car (reverse sorted-testnames)))
+	       (tal (cdr (reverse sorted-testnames))))
+      (let* ((tvals (hash-table-ref tests-hash hed))
+	     (llx   (+ xdelta (list-ref tvals 0)))
+	     (lly   (+ ydelta (list-ref tvals 4)))
+	     (boxw  (list-ref tvals 5))
+	     (boxh  (list-ref tvals 6))
+	     (urx   (+ llx boxw))
+	     (ury   (+ lly boxh)))
+	(dcommon:draw-test cnv llx lly boxw boxh hed (hash-table-ref/default selected-tests hed #f))
+	(hash-table-set! tests-hash hed (list llx urx (- sizey ury)(- sizey lly) lly boxw boxh))
+	(if (not (null? tal))
+	    ;; leave a column of space to the right to list items
+	    (loop (car tal)
+		  (cdr tal)))))))
 

Index: launch.scm
==================================================================
--- launch.scm
+++ launch.scm
@@ -91,10 +91,34 @@
                                               runscript))))) ;; assume it is on the path
 	       (rollup-status 0))
 	  (change-directory top-path)
 	  (debug:print 2 "Exectuing " test-name " (id: " test-id ") on " (get-host-name))
 	  (set! keys       (rmt:get-keys))
+	  ;; (runs:set-megatest-env-vars run-id inkeys: keys inkeyvals: keyvals) ;; these may be needed by the launching process
+	  ;; one of these is defunct/redundant ...
+	  (if (not (launch:setup-for-run force: #t))
+	      (begin
+		(debug:print 0 "Failed to setup, exiting") 
+		;; (sqlite3:finalize! db)
+		;; (sqlite3:finalize! tdb)
+		(exit 1)))
+	  (change-directory *toppath*) 
+	  (let ((rconfig (full-runconfigs-read))) ;; (read-config (conc  *toppath* "/runconfigs.config") #f #t sections: (list "default" target))))
+	    ;; (setup-env-defaults (conc *toppath* "/runconfigs.config") run-id (make-hash-table) keyvals target)
+	    ;; (set-run-config-vars run-id keyvals target) ;; (db:get-target db run-id))
+	    ;; Now have runconfigs data loaded, set environment vars
+	    (for-each (lambda (section)
+			(for-each (lambda (varval)
+				    (let ((var (car varval))
+					  (val (cadr varval)))
+				      (if (and (string? var)(string? val))
+					  (begin
+					    (setenv var (config:eval-string-in-environment val))) ;; val)
+					  (debug:print 0 "ERROR: bad variable spec, " var "=" val))))
+				  (configf:get-section rconfig section)))
+		      (list "default" target)))
+	  (change-directory work-area) 
 	  (set! keyvals    (keys:target->keyval keys target))
 	  ;; apply pre-overrides before other variables. The pre-override vars must not
 	  ;; clobbers things from the official sources such as megatest.config and runconfigs.config
 	  (if (string? set-vars)
 	      (let ((varpairs (string-split set-vars ",")))
@@ -124,27 +148,17 @@
 	      (list  "MT_MEGATEST"  megatest)
 	      (list  "MT_TARGET"    target)
 	      (list  "MT_LINKTREE"  (configf:lookup *configdat* "setup" "linktree"))))
 	  (if mt-bindir-path (setenv "PATH" (conc (getenv "PATH") ":" mt-bindir-path)))
 	  ;; (change-directory top-path)
-	  (if (not (setup-for-run))
-	      (begin
-		(debug:print 0 "Failed to setup, exiting") 
-		;; (sqlite3:finalize! db)
-		;; (sqlite3:finalize! tdb)
-		(exit 1)))
 	  ;; Can setup as client for server mode now
 	  ;; (client:setup)
 
-	  (change-directory *toppath*) 
-	  (set-megatest-env-vars run-id inkeys: keys inkeyvals: keyvals) ;; these may be needed by the launching process
-	  (change-directory work-area) 
-
-	  (set-run-config-vars run-id keyvals target) ;; (db:get-target db run-id))
+	  
 	  ;; environment overrides are done *before* the remaining critical envars.
 	  (alist->env-vars env-ovrd)
-	  (set-megatest-env-vars run-id inkeys: keys inkeyvals: keyvals)
+	  (runs:set-megatest-env-vars run-id inkeys: keys inkeyvals: keyvals)
 	  (set-item-env-vars itemdat)
 	  (save-environment-as-files "megatest")
 	  ;; open-run-close not needed for test-set-meta-info
 	  ;; (tests:set-full-meta-info #f test-id run-id 0 work-area)
 	  ;; (tests:set-full-meta-info test-id run-id 0 work-area)
@@ -413,16 +427,16 @@
 			 work-area ":\n====\n exit code " (vector-ref exit-info 2) "\n" "====\n")
 	    (if (not (vector-ref exit-info 1))
 		(exit 4)))))))
 
 ;; set up the very basics needed for doing anything here.
-(define (setup-for-run)
+(define (launch:setup-for-run #!key (force #f))
   ;; would set values for KEYS in the environment here for better support of env-override but 
   ;; have chicken/egg scenario. need to read megatest.config then read it again. Going to 
   ;; pass on that idea for now
   ;; special case
-  (if (not (hash-table? *configdat*))  ;; no need to re-open on every call
+  (if (or force (not (hash-table? *configdat*)))  ;; no need to re-open on every call
       (begin
 	(set! *configinfo* (find-and-read-config 
 			    (if (args:get-arg "-config")(args:get-arg "-config") "megatest.config")
 			    environ-patt: "env-override"
 			    given-toppath: (get-environment-variable "MT_RUN_AREA_HOME")
@@ -709,11 +723,12 @@
     ;; set the megatest to be called on the remote host
     (if (not remote-megatest)(set! remote-megatest local-megatest)) ;; "megatest"))
     (set! mt-bindir-path (pathname-directory remote-megatest))
     (if launcher (set! launcher (string-split launcher)))
     ;; set up the run work area for this test
-    (if (args:get-arg "-preclean") ;; user has requested to preclean for this run
+    (if (and (args:get-arg "-preclean") ;; user has requested to preclean for this run
+	     (not (equal? (db:test-get-rundir testinfo) "n/a"))) ;; n/a is a placeholder and thus not a read dir
 	(begin 
 	  (debug:print-info 0 "attempting to preclean directory " (db:test-get-rundir testinfo) " for test " test-name "/" item-path)
 	  (runs:remove-test-directory #f testinfo #t))) ;; remove data only, do not perturb the record
     (set! diskpath (get-best-disk *configdat*))
     (if diskpath

Index: megatest.scm
==================================================================
--- megatest.scm
+++ megatest.scm
@@ -428,11 +428,11 @@
 
 (if (args:get-arg "-server")
 
     ;; Server? Start up here.
     ;;
-    (let ((tl        (setup-for-run))
+    (let ((tl        (launch:setup-for-run))
 	  (run-id    (and (args:get-arg "-run-id")
 			  (string->number (args:get-arg "-run-id")))))
       (if run-id
 	  (begin
 	    (server:launch run-id)
@@ -447,11 +447,11 @@
 		     (hash-table-keys args:arg-hash)
 		     '("-list-servers"
 		       "-stop-server"
 		       "-show-cmdinfo"
 		       "-list-runs")))
-	(if (setup-for-run)
+	(if (launch:setup-for-run)
 	    (let ((run-id    (and (args:get-arg "-run-id")
 				  (string->number (args:get-arg "-run-id")))))
 	      ;; (set! *fdb*   (filedb:open-db (conc *toppath* "/db/paths.db")))
 	      ;; if not list or kill then start a client (if appropriate)
 	      (if (or (args-defined? "-h" "-version" "-gen-megatest-area" "-gen-megatest-test")
@@ -466,11 +466,11 @@
 ;; MAY STILL NEED THIS
 ;;		       (set! *megatest-db* (make-dbr:dbstruct path: *toppath* local: #t))))))))))
 
 (if (or (args:get-arg "-list-servers")
 	(args:get-arg "-stop-server"))
-    (let ((tl (setup-for-run)))
+    (let ((tl (launch:setup-for-run)))
       (if tl 
 	  (let* ((servers (open-run-close tasks:get-all-servers tasks:open-db))
 		 (fmtstr  "~5a~12a~8a~20a~24a~10a~10a~10a~10a\n")
 		 (servers-to-kill '())
 		 (killinfo   (args:get-arg "-stop-server"))
@@ -537,16 +537,16 @@
 		     (setenv "MT_RUN_AREA_HOME" *toppath*)
 		     (if key-vals
 			 (for-each (lambda (kt)
 				     (setenv (car kt) (cadr kt)))
 				   key-vals))
-		     (read-config "runconfigs.config" #f #t sections: sections))))
+		     (read-config (conc *toppath* "/runconfigs.config") #f #t sections: sections))))
     data))
 
 
 (if (args:get-arg "-show-runconfig")
-    (let ((tl (setup-for-run)))
+    (let ((tl (launch:setup-for-run)))
       (push-directory *toppath*)
       (let ((data (full-runconfigs-read)))
 	;; keep this one local
 	(cond
 	 ((and (args:get-arg "-section")
@@ -561,11 +561,11 @@
 	  (debug:print 0 "ERROR: -dumpmode of " (args:get-arg "-dumpmode") " not recognised")))
 	(set! *didsomething* #t))
       (pop-directory)))
 
 (if (args:get-arg "-show-config")
-    (let ((tl   (setup-for-run))
+    (let ((tl   (launch:setup-for-run))
 	  (data *configdat*)) ;; (read-config "megatest.config" #f #t)))
       (push-directory *toppath*)
       ;; keep this one local
       (cond 
        ((and (args:get-arg "-section")
@@ -667,11 +667,11 @@
 
 ;; NOTE: list-runs and list-db-targets operate on local db!!!
 ;;
 (if (or (args:get-arg "-list-runs")
 	(args:get-arg "-list-db-targets"))
-    (if (setup-for-run)
+    (if (launch:setup-for-run)
 	(let* ((dbstruct (make-dbr:dbstruct path: *toppath* local: #t))
 	       (runpatt  (args:get-arg "-list-runs"))
 	       (testpatt (if (args:get-arg "-testpatt") 
 			     (args:get-arg "-testpatt") 
 			     "%"))
@@ -865,11 +865,11 @@
 	  (change-directory toppath)
 	  (if (not target)
 	      (begin
 		(debug:print 0 "ERROR: -target is required.")
 		(exit 1)))
-	  (if (not (setup-for-run))
+	  (if (not (launch:setup-for-run))
 	      (begin
 		(debug:print 0 "Failed to setup, giving up on -test-paths or -test-files, exiting")
 		(exit 1)))
 	  (let* ((keys     (rmt:get-keys))
 		 ;; db:test-get-paths must not be run remote
@@ -911,11 +911,11 @@
 	  (change-directory testpath)
 	  (if (not target)
 	      (begin
 		(debug:print 0 "ERROR: -target is required.")
 		(exit 1)))
-	  (if (not (setup-for-run))
+	  (if (not (launch:setup-for-run))
 	      (begin
 		(debug:print 0 "Failed to setup, giving up on -archive, exiting")
 		(exit 1)))
 	  (let* ((keys     (rmt:get-keys))
 		 (paths    (tests:test-get-paths-matching keys target)))
@@ -985,11 +985,11 @@
 	     (test-id   (assoc/default 'test-id   cmdinfo))
 	     (itemdat   (assoc/default 'itemdat   cmdinfo))
 	     (work-area (assoc/default 'work-area cmdinfo))
 	     (db        #f))
 	(change-directory testpath)
-	(if (not (setup-for-run))
+	(if (not (launch:setup-for-run))
 	    (begin
 	      (debug:print 0 "Failed to setup, exiting")
 	      (exit 1)))
 	(if (and state status)
 	    (rmt:teststep-set-status! run-id test-id step state status msg logfile)
@@ -1032,11 +1032,11 @@
 	       (itemdat   (assoc/default 'itemdat   cmdinfo))
 	       (work-area (assoc/default 'work-area cmdinfo))
 	       (db        #f) ;; (open-db))
 	       (state     (args:get-arg ":state"))
 	       (status    (args:get-arg ":status")))
-	  (if (not (setup-for-run))
+	  (if (not (launch:setup-for-run))
 	      (begin
 		(debug:print 0 "Failed to setup, exiting")
 		(exit 1)))
 
 	  (if (args:get-arg "-runstep")(debug:print-info 1 "Running -runstep, first change to directory " work-area))
@@ -1137,11 +1137,11 @@
 
 (if (or (args:get-arg "-showkeys")
         (args:get-arg "-show-keys"))
     (let ((db #f)
 	  (keys #f))
-      (if (not (setup-for-run))
+      (if (not (launch:setup-for-run))
 	  (begin
 	    (debug:print 0 "Failed to setup, exiting")
 	    (exit 1)))
       (set! keys (cdb:remote-run db:get-keys db))
       (debug:print 1 "Keys: " (string-intersperse keys ", "))
@@ -1168,31 +1168,31 @@
 ;; Update the database schema, clean up the db
 ;;======================================================================
 
 (if (args:get-arg "-rebuild-db")
     (begin
-      (if (not (setup-for-run))
+      (if (not (launch:setup-for-run))
 	  (begin
 	    (debug:print 0 "Failed to setup, exiting") 
 	    (exit 1)))
       ;; keep this one local
       (open-run-close patch-db #f)
       (set! *didsomething* #t)))
 
 (if (args:get-arg "-cleanup-db")
     (begin
-      (if (not (setup-for-run))
+      (if (not (launch:setup-for-run))
 	  (begin
 	    (debug:print 0 "Failed to setup, exiting") 
 	    (exit 1)))
       ;; keep this one local
       (open-run-close db:clean-up #f)
       (set! *didsomething* #t)))
 
 (if (args:get-arg "-mark-incompletes")
     (begin
-      (if (not (setup-for-run))
+      (if (not (launch:setup-for-run))
 	  (begin
 	    (debug:print 0 "Failed to setup, exiting") 
 	    (exit 1)))
       (open-run-close db:find-and-mark-incomplete #f)
       (set! *didsomething* #t)))
@@ -1201,11 +1201,11 @@
 ;; Update the tests meta data from the testconfig files
 ;;======================================================================
 
 (if (args:get-arg "-update-meta")
     (begin
-      (if (not (setup-for-run))
+      (if (not (launch:setup-for-run))
 	  (begin
 	    (debug:print 0 "Failed to setup, exiting") 
 	    (exit 1)))
       ;; now can find our db
       ;; keep this one local
@@ -1216,11 +1216,11 @@
 ;; Start a repl
 ;;======================================================================
 
 (if (or (args:get-arg "-repl")
 	(args:get-arg "-load"))
-    (let* ((toppath (setup-for-run))
+    (let* ((toppath (launch:setup-for-run))
 	   (dbstruct (if toppath (make-dbr:dbstruct path: toppath local: #t) #f)))
       (if dbstruct
 	  (begin
 	    (set! *db* dbstruct)
 	    (set! *client-non-blocking-mode* #t)
@@ -1242,45 +1242,45 @@
 ;; Wait on a run to complete
 ;;======================================================================
 
 (if (args:get-arg "-run-wait")
     (begin
-      (if (not (setup-for-run))
+      (if (not (launch:setup-for-run))
 	  (begin
 	    (debug:print 0 "Failed to setup, exiting") 
 	    (exit 1)))
       (operate-on 'run-wait)
       (set! *didsomething* #t)))
 
-;; Not converted to use dbstruct yet
-;;
-(if (args:get-arg "-convert-to-norm")
-    (let* ((toppath (setup-for-run))
-	   (dbstruct (if toppath (make-dbr:dbstruct path: toppath local: #t))))
-      (for-each 
-       (lambda (field)
-	 (let ((dat '()))
-	   (debug:print-info 0 "Getting data for field " field)
-	   (sqlite3:for-each-row
-	    (lambda (id val)
-	      (set! dat (cons (list id val) dat)))
-	    (get-db db run-id)
-	    (conc "SELECT id," field " FROM tests;"))
-	   (debug:print-info 0 "found " (length dat) " items for field " field)
-	   (let ((qry (sqlite3:prepare db (conc "UPDATE tests SET " field "=? WHERE id=?;"))))
-	     (for-each
-	      (lambda (item)
-		(let ((newval ;; (sdb:qry 'getid 
-		       (cadr item))) ;; )
-		  (if (not (equal? newval (cadr item)))
-		      (debug:print-info 0 "Converting " (cadr item) " to " newval " for test #" (car item)))
-		  (sqlite3:execute qry newval (car item))))
-	      dat)
-	     (sqlite3:finalize! qry))))
-       (db:close-all dbstruct)
-       (list "uname" "rundir" "final_logf" "comment"))
-      (set! *didsomething* #t)))
+;; ;; ;; redo me ;; Not converted to use dbstruct yet
+;; ;; ;; redo me ;;
+;; ;; ;; redo me (if (args:get-arg "-convert-to-norm")
+;; ;; ;; redo me     (let* ((toppath (setup-for-run))
+;; ;; ;; redo me 	   (dbstruct (if toppath (make-dbr:dbstruct path: toppath local: #t))))
+;; ;; ;; redo me       (for-each 
+;; ;; ;; redo me        (lambda (field)
+;; ;; ;; redo me 	 (let ((dat '()))
+;; ;; ;; redo me 	   (debug:print-info 0 "Getting data for field " field)
+;; ;; ;; redo me 	   (sqlite3:for-each-row
+;; ;; ;; redo me 	    (lambda (id val)
+;; ;; ;; redo me 	      (set! dat (cons (list id val) dat)))
+;; ;; ;; redo me 	    (db:get-db db run-id)
+;; ;; ;; redo me 	    (conc "SELECT id," field " FROM tests;"))
+;; ;; ;; redo me 	   (debug:print-info 0 "found " (length dat) " items for field " field)
+;; ;; ;; redo me 	   (let ((qry (sqlite3:prepare db (conc "UPDATE tests SET " field "=? WHERE id=?;"))))
+;; ;; ;; redo me 	     (for-each
+;; ;; ;; redo me 	      (lambda (item)
+;; ;; ;; redo me 		(let ((newval ;; (sdb:qry 'getid 
+;; ;; ;; redo me 		       (cadr item))) ;; )
+;; ;; ;; redo me 		  (if (not (equal? newval (cadr item)))
+;; ;; ;; redo me 		      (debug:print-info 0 "Converting " (cadr item) " to " newval " for test #" (car item)))
+;; ;; ;; redo me 		  (sqlite3:execute qry newval (car item))))
+;; ;; ;; redo me 	      dat)
+;; ;; ;; redo me 	     (sqlite3:finalize! qry))))
+;; ;; ;; redo me        (db:close-all dbstruct)
+;; ;; ;; redo me        (list "uname" "rundir" "final_logf" "comment"))
+;; ;; ;; redo me       (set! *didsomething* #t)))
 
 (if (args:get-arg "-import-megatest.db")
     (let* ((toppath  (setup-for-run))
 	   (dbstruct (if toppath (make-dbr:dbstruct path: toppath) #f))
 	   (mtdb     (if toppath (db:open-megatest-db)))

Index: newdashboard.scm
==================================================================
--- newdashboard.scm
+++ newdashboard.scm
@@ -67,11 +67,11 @@
 (if (args:get-arg "-h")
     (begin
       (print help)
       (exit)))
 
-(if (not (setup-for-run))
+(if (not (launch:setup-for-run))
     (begin
       (print "Failed to find megatest.config, exiting") 
       (exit 1)))
 
 (if (args:get-arg "-host")

Index: runs.scm
==================================================================
--- runs.scm
+++ runs.scm
@@ -37,11 +37,11 @@
 ;; This is the *new* methodology. One record to inform them and in the chaos, organise them.
 ;;
 (define (runs:create-run-record)
   (let* ((mconfig      (if *configdat*
 		           *configdat*
-		           (if (setup-for-run)
+		           (if (launch:setup-for-run)
 		               *configdat*
 		               (begin
 		                 (debug:print 0 "ERROR: Called setup in a non-megatest area, exiting")
 		                 (exit 1)))))
 	  (runrec      (runs:runrec-make-record))
@@ -88,11 +88,11 @@
 			    (safe-setenv (car varval)(cadr varval)))
 			  (configf:get-section runconfig section)))
 	      (list "default" target))
     (vector target runname testpatt keys keyvals envdat mconfig runconfig serverdat transport db toppath run-id)))
 
-(define (set-megatest-env-vars run-id #!key (inkeys #f)(inrunname #f)(inkeyvals #f))
+(define (runs:set-megatest-env-vars run-id #!key (inkeys #f)(inrunname #f)(inkeyvals #f))
   (let* ((target    (or (common:args-get-target)
 			(get-environment-variable "MT_TARGET")))
 	 (keys    (if inkeys    inkeys    (rmt:get-keys)))
 	 (keyvals   (if inkeyvals inkeyvals (keys:target->keyval keys target)))
 	 (vals      (hash-table-ref/default *env-vars-by-run-id* run-id #f))
@@ -206,25 +206,34 @@
 	 (keyvals            (keys:target->keyval keys target))
 	 (run-id             (rmt:register-run keyvals runname "new" "n/a" user))  ;;  test-name)))
 	 (deferred          '()) ;; delay running these since they have a waiton clause
 	 (runconfigf         (conc  *toppath* "/runconfigs.config"))
 	 (test-records       (make-hash-table))
-	 (all-tests-registry (tests:get-all)) ;; (tests:get-valid-tests (make-hash-table) test-search-path)) ;; all valid tests to check waiton names
-	 (all-test-names     (hash-table-keys all-tests-registry))
-	 (test-names         (tests:filter-test-names all-test-names test-patts))
-	 (required-tests     (lset-intersection equal? (string-split test-patts ",") test-names))) ;; test-names)) ;; Added test-names as initial for required-tests but that failed to work
+	 ;; need to process runconfigs before generating these lists
+	 (all-tests-registry #f)  ;; (tests:get-all)) ;; (tests:get-valid-tests (make-hash-table) test-search-path)) ;; all valid tests to check waiton names
+	 (all-test-names     #f)  ;; (hash-table-keys all-tests-registry))
+	 (test-names         #f)  ;; (tests:filter-test-names all-test-names test-patts))
+	 (required-tests     #f)) ;;(lset-intersection equal? (string-split test-patts ",") test-names))) ;; test-names)) ;; Added test-names as initial for required-tests but that failed to work
 
-    (set-megatest-env-vars run-id inkeys: keys inrunname: runname) ;; these may be needed by the launching process
+    (runs:set-megatest-env-vars run-id inkeys: keys inrunname: runname) ;; these may be needed by the launching process
     (if (file-exists? runconfigf)
-	(setup-env-defaults runconfigf run-id *already-seen-runconfig-info* keyvals "pre-launch-env-vars")
+	(setup-env-defaults runconfigf run-id *already-seen-runconfig-info* keyvals target)
 	(debug:print 0 "WARNING: You do not have a run config file: " runconfigf))
+
+    ;; Now generate all the tests lists
+    (set! all-tests-registry (tests:get-all))
+    (set! all-test-names     (hash-table-keys all-tests-registry))
+    (set! test-names         (tests:filter-test-names all-test-names test-patts))
+    (set! required-tests     (lset-intersection equal? (string-split test-patts ",") test-names))
     
     ;; look up all tests matching the comma separated list of globs in
     ;; test-patts (using % as wildcard)
 
     ;; (set! test-names (delete-duplicates (tests:get-valid-tests *toppath* test-patts)))
-    (debug:print-info 0 "test names " test-names)
+    (debug:print-info 0 "tests search path: " (tests:get-tests-search-path *configdat*))
+    (debug:print-info 0 "all tests:  " (string-intersperse (sort all-test-names string<) " "))
+    (debug:print-info 0 "test names: " (string-intersperse (sort test-names string<) " "))
 
     ;; on the first pass or call to run-tests set FAILS to NOT_STARTED if
     ;; -keepgoing is specified
     (if (eq? *passnum* 0)
 	(begin
@@ -430,14 +439,17 @@
 	       (null? non-completed)))
       (debug:print-info 4 "runs:expand-items: (or (null? prereqs-not-met) (and (member 'toplevel testmode)(null? non-completed)))")
       (let ((test-name (tests:testqueue-get-testname test-record)))
 	(setenv "MT_TEST_NAME" test-name) ;; 
 	(setenv "MT_RUNNAME"   runname)
-	(set-megatest-env-vars run-id inrunname: runname) ;; these may be needed by the launching process
+	(runs:set-megatest-env-vars run-id inrunname: runname) ;; these may be needed by the launching process
 	(let ((items-list (items:get-items-from-config tconfig)))
 	  (if (list? items-list)
 	      (begin
+		(if (null? items-list)
+		    (let ((test-id (rmt:get-test-id run-id test-name "")))
+		      (mt:test-set-state-status-by-id run-id test-id "NOT_STARTED" "ZERO_ITEMS" "Failed to run due to failed prerequisites")))
 		(tests:testqueue-set-items! test-record items-list)
 		(list hed tal reg reruns))
 	      (begin
 		(debug:print 0 "ERROR: The proc from reading the items table did not yield a list - please report this")
 		(exit 1))))))
@@ -470,11 +482,11 @@
 	    (let ((trimmed-tal (mt:discard-blocked-tests run-id hed tal test-records))
 		  (trimmed-reg (mt:discard-blocked-tests run-id hed reg test-records)))
 	      (debug:print 1 "WARNING: test " hed " has discarded prerequisites, removing it from the queue")
 
 	      (let ((test-id (rmt:get-test-id run-id hed "")))
-		(mt:test-set-state-status-by-id test-id "DEQUEUED" "PREQ_FAIL" "Failed to run due to failed prerequisites"))
+		(mt:test-set-state-status-by-id run-id test-id "NOT_STARTED" "PREQ_DISCARDED" "Failed to run due to discarded prerequisites"))
 	      
 	      (if (and (null? trimmed-tal)
 		       (null? trimmed-reg))
 		  #f
 		  (list (runs:queue-next-hed trimmed-tal trimmed-reg reglen regfull)
@@ -546,19 +558,23 @@
 	    ;; num-retries code was here
 	    ;; we use this opportunity to move contents of reg to tal
 	    (list (car newtal)(append (cdr newtal) reg) '() reruns)) ;; an issue with prereqs not yet met?
 	  (begin
 	    (debug:print-info 1 "no fails in prerequisites for " hed " but nothing seen running in a while, dropping test " hed " from the run queue")
+	    (let ((test-id (rmt:get-test-id run-id hed "")))
+	      (mt:test-set-state-status-by-id run-id test-id "DEQUEDED" "TIMED_OUT" "Nothing seen running in a while."))
 	    (list (runs:queue-next-hed tal reg reglen regfull)
 		  (runs:queue-next-tal tal reg reglen regfull)
 		  (runs:queue-next-reg tal reg reglen regfull)
 		  reruns))))
 
      ((and (not (null? fails))(member 'normal testmode))
       (debug:print-info 1 "test "  hed " (mode=" testmode ") has failed prerequisite(s); "
 			(string-intersperse (map (lambda (t)(conc (db:test-get-testname t) ":" (db:test-get-state t)"/"(db:test-get-status t))) fails) ", ")
 			", removing it from to-do list")
+      (let ((test-id (rmt:get-test-id run-id hed "")))
+	(mt:test-set-state-status-by-id run-id test-id "NOT_STARTED" "PREQ_FAIL" "Failed to run due to failed prerequisites"))
       (if (or (not (null? reg))(not (null? tal)))
 	  (begin
 	    (hash-table-set! test-registry hed 'CANNOTRUN)
 	    (list (runs:queue-next-hed tal reg reglen regfull)
 		  (runs:queue-next-tal tal reg reglen regfull)
@@ -739,12 +755,15 @@
 	  (if (or (not (null? reg))(not (null? tal)))
 	      (if (vector? hed)
 		  (begin
 		    (debug:print 1 "WARNING: Dropping test " test-name "/" item-path
 				 " from the launch list as it has prerequistes that are FAIL")
+		    (let ((test-id (rmt:get-test-id run-id hed "")))
+		      (mt:test-set-state-status-by-id run-id test-id "NOT_STARTED" "PREQ_FAIL" "Failed to run due to failed prerequisites"))
 		    (runs:shrink-can-run-more-tests-count) ;; DELAY TWEAKER (still needed?)
 		    ;; (thread-sleep! *global-delta*)
+		    ;; This next is for the items
 		    (mt:test-set-state-status-by-testname run-id test-name item-path "NOT_STARTED" "BLOCKED" #f)
 		    (hash-table-set! test-registry (runs:make-full-test-name test-name item-path) 'removed)
 		    (list (runs:queue-next-hed tal reg reglen regfull)
 			  (runs:queue-next-tal tal reg reglen regfull)
 			  (runs:queue-next-reg tal reg reglen regfull)
@@ -902,11 +921,11 @@
 	     (num-running (rmt:get-count-tests-running-for-run-id run-id)))
 
       (if (> num-running 0)
 	  (set! last-time-some-running (current-seconds)))
 
-      (if (> (current-seconds)(+ last-time-some-running 60))
+      (if (> (current-seconds)(+ last-time-some-running 240))
 	  (hash-table-set! *max-tries-hash* tfullname (+ (hash-table-ref/default *max-tries-hash* tfullname 0) 1)))
 	;; (debug:print 0 "max-tries-hash: " (hash-table->alist *max-tries-hash*))
 
 	;; Ensure all top level tests get registered. This way they show up as "NOT_STARTED" on the dashboard
 	;; and it is clear they *should* have run but did not.
@@ -1116,11 +1135,11 @@
 		      )
     (debug:print 2 "Attempting to launch test " full-test-name)
     (setenv "MT_TEST_NAME" test-name) ;; 
     (setenv "MT_ITEMPATH"  item-path)
     (setenv "MT_RUNNAME"   runname)
-    (set-megatest-env-vars run-id inrunname: runname) ;; these may be needed by the launching process
+    (runs:set-megatest-env-vars run-id inrunname: runname) ;; these may be needed by the launching process
     (change-directory *toppath*)
 
     ;; Here is where the test_meta table is best updated
     ;; Yes, another use of a global for caching. Need a better way?
     ;;
@@ -1360,10 +1379,11 @@
 									(dirb ;; (rmt:sdb-qry 'getstr 
 									 (db:test-get-rundir b))) ;; ) ;; ((filedb:get-path *fdb* (db:test-get-rundir b))))
 								    (if (and (string? dira)(string? dirb))
 									(> (string-length dira)(string-length dirb))
 									#f)))))
+		       (toplevel-retries (make-hash-table)) ;; try three times to loop through and remove top level tests
 		       (test-retry-time  (make-hash-table))
 		       (allow-run-time   10)) ;; seconds to allow for killing tests before just brutally killing 'em
 		   (let loop ((test (car sorted-tests))
 			      (tal  (cdr sorted-tests)))
 		     (let* ((test-id       (db:test-get-id test))
@@ -1385,11 +1405,18 @@
 							       (> (cdb:remote-run db:test-toplevel-num-items db run-id test-name) 0))))
 			     (case action
 			       ((remove-runs)
 				;; if the test is a toplevel-with-children issue an error and do not remove
 				(if toplevel-with-children
-				    (debug:print 0 "WARNING: skipping removal of " test-fulln " with run-id " run-id " as it has sub tests")
+				    (begin
+				      (debug:print 0 "WARNING: skipping removal of " test-fulln " with run-id " run-id " as it has sub tests")
+				      (hash-table-set! toplevel-retries test-fulln (+ (hash-table-ref/default toplevel-retries test-fulln 0) 1))
+				      (if (> (hash-table-ref toplevel-retries test-fulln) 3)
+					  (if (not (null? tal))
+					      (loop (car tal)(cdr tal))) ;; no else clause - drop it if no more in queue and > 3 tries
+					  (let ((newtal (append tal (list test))))
+					    (loop (car newtal)(cdr newtal))))) ;; loop with test still in queue
 				    (begin
 				      (debug:print-info 0 "test: " test-name " itest-state: " test-state)
 				      (if (member test-state (list "RUNNING" "LAUNCHED" "REMOTEHOSTSTART" "KILLREQ"))
 					  (begin
 					    (if (not (hash-table-ref/default test-retry-time test-fulln #f))
@@ -1454,11 +1481,11 @@
   (let* ((run-dir       (db:test-get-rundir test))    ;; run dir is from the link tree
 	 (real-dir      (if (file-exists? run-dir)
 			    (resolve-pathname run-dir)
 			    #f)))
     (if (not remove-data-only)
-	(mt:test-set-state-status-by-id (db:test-get-id test) "REMOVING" "LOCKED" #f))
+	(mt:test-set-state-status-by-id (db:test-get-run-id test)(db:test-get-id test) "REMOVING" "LOCKED" #f))
     (debug:print-info 1 "Attempting to remove " (if real-dir (conc " dir " real-dir " and ") "") " link " run-dir)
     (if (and real-dir 
 	     (> (string-length real-dir) 5)
 	     (file-exists? real-dir)) ;; bad heuristic but should prevent /tmp /home etc.
 	(begin ;; let* ((realpath (resolve-pathname run-dir)))
@@ -1508,11 +1535,11 @@
       (debug:print 0 "ERROR: Missing required parameter for " switchname ", you must specify the run name with -runname runname")
       (exit 3))
      (else
       (let ((db   #f)
 	    (keys #f))
-	(if (not (setup-for-run))
+	(if (not (launch:setup-for-run))
 	    (begin 
 	      (debug:print 0 "Failed to setup, exiting")
 	      (exit 1)))
 	;; (if (args:get-arg "-server")
 	;;     (cdb:remote-run server:start db (args:get-arg "-server")))

Index: tasks.scm
==================================================================
--- tasks.scm
+++ tasks.scm
@@ -20,25 +20,37 @@
 
 ;;======================================================================
 ;; Tasks db
 ;;======================================================================
 
+;; If file exists AND
+;;    file readable
+;;         ==> open it
+;; If file exists AND
+;;    file NOT readable
+;;         ==> open in-mem version
+;; If file NOT exists
+;;    ==> open in-mem version
+;;
 (define (tasks:open-db)
   (let* ((linktree     (configf:lookup *configdat* "setup" "linktree"))
 	 (dbpath       (conc linktree "/.db/monitor.db"))
 	 (exists       (file-exists? dbpath))
 	 (write-access (file-write-access? dbpath))
-	 (mdb          (if (file-write-access? *toppath*)
-			   (sqlite3:open-database dbpath)
-			   (sqlite3:open-database ":memory:"))) ;; (never-give-up-open-db dbpath))
+	 (mdb          (cond
+			((file-write-access? *toppath*)(sqlite3:open-database dbpath))
+			((file-read-access? dbpath)    (sqlite3:open-database dbpath))
+			(else (sqlite3:open-database ":memory:")))) ;; (never-give-up-open-db dbpath))
 	 (handler      (make-busy-timeout 36000)))
     (if (and exists
 	     (not write-access))
 	(set! *db-write-access* write-access)) ;; only unset so other db's also can use this control
     (sqlite3:set-busy-handler! mdb handler)
     (sqlite3:execute mdb (conc "PRAGMA synchronous = 0;"))
-    (if (not exists)
+    (if (or (and (not exists)
+		 (file-write-access? *toppath*))
+	    (not (file-read-access? dbpath)))
 	(begin
 	  (sqlite3:execute mdb "CREATE TABLE IF NOT EXISTS tasks_queue (id INTEGER PRIMARY KEY,
                                 action TEXT DEFAULT '',
                                 owner TEXT,
                                 state TEXT DEFAULT 'new',

Index: tests.scm
==================================================================
--- tests.scm
+++ tests.scm
@@ -31,12 +31,11 @@
 (include "run_records.scm")
 (include "test_records.scm")
 
 ;; Call this one to do all the work and get a standardized list of tests
 (define (tests:get-all)
-  (let* ((test-search-path   (cons (conc *toppath* "/tests") ;; the default
-				   (tests:get-tests-search-path *configdat*))))
+  (let* ((test-search-path   (tests:get-tests-search-path *configdat*)))
     (tests:get-valid-tests (make-hash-table) test-search-path)))
 
 (define (tests:get-tests-search-path cfgdat)
   (let ((paths (map cadr (configf:get-section cfgdat "tests-paths"))))
     (cons (conc *toppath* "/tests") paths)))
@@ -474,11 +473,11 @@
 	     #f ;; cannot have a which is waiting on b happening before b
 	     (if (and b-waitons (member (tests:testqueue-get-testname a-record) b-waitons))
 		 #t ;; this is the correct order, b is waiting on a and b is before a
 		 (if (> a-priority b-priority)
 		     #t ;; if a is a higher priority than b then we are good to go
-		     #f))))))))
+		     (string-compare3 a b)))))))))
 
 ;; for each test:
 ;;   
 (define (tests:filter-non-runnable run-id testkeynames testrecordshash)
   (let ((runnables '()))

Index: tests/fullrun/megatest.config
==================================================================
--- tests/fullrun/megatest.config
+++ tests/fullrun/megatest.config
@@ -11,10 +11,11 @@
 [include config/mt_include_1.config]
 
 [dashboard]
 pre-command  xterm -geometry 180x20 -e "
 post-command |& tee results.log ;echo Press any key to continue;bash -c 'read -n 1 -s'" &
+testsort -event_time
 
 [misc]
 home #{shell readlink -f $MT_RUN_AREA_HOME}
 parent #{shell readlink -f $MT_RUN_AREA_HOME/..}
 

Index: utils/Makefile_latest.installall
==================================================================
--- utils/Makefile_latest.installall
+++ utils/Makefile_latest.installall
@@ -13,13 +13,16 @@
 help :
 	@echo You may need to do the following first:
 	@echo sudo apt-get install libreadline-dev
 	@echo sudo apt-get install libwebkitgtk-dev 
 	@echo sudo apt-get install libmotif3
+	@echo For IUP set IUPBRANCH, currently $(IUPBRANCH)
 	@echo You are using PREFIX=$(PREFIX)
-	@echo You are using proxy="$(proxy)"
-	@echo If needed set proxy to host.dom:port
+	@echo You are using PROXY="$(PROXY)"
+	@echo If needed set PROXY to host.dom:port
+	@echo   http_proxy=$(http_proxy)
+	@echo   PROX=$(PROX)
 	@echo 
 	@echo To make all do: make all
 
 # Put the installation here
 ifeq ($(PREFIX),)
@@ -28,19 +31,23 @@
 
 # Set this on the command line of your make call if needed: make PROXY=host.com:1234
 PROXY=
 
 # Select version of chicken, sqlite3 etc
-CHICKEN_VERSION=4.8.0
-SQLITE3_VERSION=3071401
+CHICKEN_VERSION=4.9.0.1
+SQLITE3_VERSION=3080500
+# http://www.sqlite.org/2014/sqlite-autoconf-3080500.tar.gz
+
+# Override IUPBRANCH to use other than trunk
+IUPBRANCH=iup-3.10.1
 
 # Eggs to install (straightforward ones)
 EGGS=matchable readline apropos base64 regex-literals format regex-case test coops trace csv \
      dot-locking posix-utils posix-extras directory-utils hostinfo tcp-server rpc csv-xml fmt \
      json md5 awful http-client spiffy uri-common intarweb spiffy-request-vars \
-     spiffy-directory-listing ssax sxml-serializer sxml-modifications sqlite3 sql-de-lite \
-     srfi-19
+     spiffy-directory-listing ssax sxml-serializer sxml-modifications sql-de-lite \
+     srfi-19 refdb
 
 #
 # Derived variables
 #
 
@@ -73,13 +80,14 @@
 else
 ARCHSIZE=64_
 endif
 
 CSCLIBS=$(shell echo $(LD_LIBRARY_PATH) | sed 's/:/ -L/g')
+CSC_OPTIONS="-I$(PREFIX)/include -L$(CSCLIBS)"
 # CSC_OPTIONS=-I$(PREFIX)/include -L$(CSCLIBS)
 
-all : chkn eggs libiup logprobin
+all : chkn eggs libiup logprobin $(PREFIX)/lib/sqlite3.so
 
 chkn : $(CHICKEN_INSTALL)
 
 eggs : $(EGGSOFILES)
 
@@ -103,28 +111,47 @@
 setup-chicken4x.sh : $(EGGFLAGS)
 	(echo "export PATH=$(PATH)" > setup-chicken4x.sh)
 	(echo "export LD_LIBRARY_PATH=$(LD_LIBRARY_PATH)" >> setup-chicken4x.sh)
 	mkdir -p $(PREFIX)
 
-chicken-core/chicken.scm : chicken-4.9.0rc1.tar.gz
-	tar xfz chicken-4.9.0rc1.tar.gz
-	ln -sf chicken-4.9.0rc1 chicken-core
-	# git clone http://code.call-cc.org/git/chicken-core.git
+chicken-core/chicken.scm : chicken-$(CHICKEN_VERSION).tar.gz
+	tar xfz chicken-$(CHICKEN_VERSION).tar.gz
+	ln -sf chicken-$(CHICKEN_VERSION) chicken-core
 
 
 chicken-4.9.0rc1.tar.gz : 
 	wget http://code.call-cc.org/dev-snapshots/2014/04/17/chicken-4.9.0rc1.tar.gz
 
+chicken-4.9.0.1.tar.gz :
+	wget http://code.call-cc.org/releases/4.9.0/chicken-4.9.0.1.tar.gz
+
 # git clone git://code.call-cc.org/chicken-core
+# git clone http://code.call-cc.org/git/chicken-core.git
 
 $(CHICKEN_INSTALL) : chicken-core/chicken.scm setup-chicken4x.sh
 	cd chicken-core;make PLATFORM=linux PREFIX=$(PREFIX)
 	cd chicken-core;make PLATFORM=linux PREFIX=$(PREFIX) install
 
-# 
-# IUP
-#
+#======================================================================
+# S Q L I T E 3
+#======================================================================
+
+sqlite-autoconf-$(SQLITE3_VERSION).tar.gz :
+	wget  http://www.sqlite.org/2014/sqlite-autoconf-$(SQLITE3_VERSION).tar.gz
+
+sqlite-autoconf-$(SQLITE3_VERSION)/config.log : sqlite-autoconf-$(SQLITE3_VERSION).tar.gz
+	tar xfz  sqlite-autoconf-$(SQLITE3_VERSION).tar.gz
+
+$(PREFIX)/bin/sqlite3 : sqlite-autoconf-$(SQLITE3_VERSION)/config.log
+	cd sqlite-autoconf-$(SQLITE3_VERSION);./configure --prefix=$(PREFIX);make;make install
+
+$(PREFIX)/lib/sqlite3.so : $(PREFIX)/bin/sqlite3
+	CSC_OPTIONS="-I$(PREFIX)/include -L$(PREFIX)/lib" $(CHICKEN_INSTALL) $(PROX) sqlite3
+
+#======================================================================
+# I U P 
+#======================================================================
 
 ffcall.fossil :
 	fossil clone http://www.kiatoa.com/fossils/ffcall ffcall.fossil
 
 ffcall/README : ffcall.fossil
@@ -139,21 +166,25 @@
 iuplib.fossil :
 	fossil clone http://www.kiatoa.com/fossils/iuplib iuplib.fossil
 
 iup/installall.sh : iuplib.fossil
 	mkdir -p iup
-	cd iup && if [ -e installall.sh ];then fossil update; else fossil open ../iuplib.fossil; fi
+	cd iup && if [ -e installall.sh ];then fossil update $(IUPBRANCH); else fossil open ../iuplib.fossil;fossil update $(IUPBRANCH); fi
 
-iup/iup/alldone : iup/installall.sh
+iup/alldone : iup/installall.sh $(PREFIX)/include/iup.h $(PREFIX)/lib/libiup.so
 	cd iup && ./makeall.sh
 
-$(PREFIX)/lib/libiup.so : iup/iup/alldone
-	touch -c $(PREFIX)/lib/libiup.so
+$(PREFIX)/lib/libiup.so $(PREFIX)/include/iup.h : iup/installall.sh iup/alldone
+	cd iup && ./installall.sh
+
+# $(PREFIX)/lib/libiup.so : iup/iup/alldone
+#	touch -c $(PREFIX)/lib/libiup.so
 
 $(CHICKEN_EGG_DIR)/iup.so : $(PREFIX)/lib/libiup.so
-	$(CHICKEN_INSTALL) $(PROX) -D no-library-checks -feature disable-iup-web iup
+	LD_LIBRARY_PATH=$(LD_LIBRARY_PATH) CSC_OPTIONS=$(CSC_OPTIONS) $(CHICKEN_INSTALL) $(PROX) -D no-library-checks -feature disable-iup-web iup
 
 $(CHICKEN_EGG_DIR)/canvas-draw.so :  $(PREFIX)/lib/libiup.so
-	$(CHICKEN_INSTALL) $(PROX) -D no-library-checks canvas-draw
+	CSC_OPTIONS=$(CSC_OPTIONS) $(CHICKEN_INSTALL) $(PROX) -D no-library-checks canvas-draw
+
 
 clean :
 	rm -rf chicken-4.8.0 eggflags ffcall sqlite-autoconf-$(SQLITE3_VERSION)

ADDED   utils/installck.sh
Index: utils/installck.sh
==================================================================
--- /dev/null
+++ utils/installck.sh
@@ -0,0 +1,22 @@
+#!/bin/bash
+
+myhome=$(dirname $0)
+
+if [[ $proxy == "" ]]; then 
+  echo 'Please set the environment variable "proxy" to host.com:port (e.g. foo.com:1234) to use a proxy'
+  echo PROX=""
+else
+  export http_proxy=http://$proxy
+  export PROX="-proxy $proxy"
+fi
+
+if [[ -z $PREFIX ]];then
+  echo "\$PREFIX variable is required"
+  exit
+fi
+
+export LD_LIBRARY_NAME=$PREFIX/lib
+
+logname=$(basename $PREFIX)
+
+script -c "make -f $myhome/Makefile_latest.installall all" $logname.log

Index: utils/loadrunner
==================================================================
--- utils/loadrunner
+++ utils/loadrunner
@@ -1,9 +1,42 @@
 #!/bin/bash 
+
+LOADRUNNER=$0
 
 # load=`uptime|awk '{print $10}'|cut -d, -f1`
-load=`uptime|perl -pe 's/.*: (\d+.\d+),.*/$1/'`
+load=$(uptime|perl -pe 's/.*: (\d+.\d+),.*/$1/')
+load2=$(uptime|perl -pe 's/.*: (\d+.\d+), (\d+.\d+),.*/$2/')
+# echo "load2=$load2, load=$load"
+
+# Run a job detached from stdin/stdout (i.e. daemonized)
+# Launch on remotehost if specified by TARGETHOST
+#
+function launchjob () {
+  # Can't always trust $PWD
+  CURRWD=`pwd`
+  if [[ $TARGETHOST_LOGF == "" ]]; then
+      TARGETHOST_LOGF=NBFAKE-`date +%GWW%V.%u_%T`
+  fi
+  echo "#======================================================================"
+  echo "# NBFAKE Running command:"
+  echo "#     \"$*\""
+  echo "#======================================================================"
+  
+  if [[ $TARGETHOST == ""  ]]; then
+    sh -c "cd $CURRWD;export DISPLAY=$DISPLAY; export PATH=$PATH; nohup $* > $TARGETHOST_LOGF 2>&1 &"
+  else
+    ssh -n -f $TARGETHOST "sh -c \"cd $CURRWD;export DISPLAY=$DISPLAY; export PATH=$PATH; nohup $* > $TARGETHOST_LOGF 2>&1 &\""
+  fi
+}
+
+function get_delay_time () {
+  RANGE=$1
+  number=$RANDOM
+  let "number %= $RANGE"
+  echo $number
+}
+
 if which cpucheck > /dev/null;then
     numcpu=`cpucheck|tail -1|awk '{print $6}'`
 elif which lscpu > /dev/null;then
     numcpu=`lscpu|grep "CPU.s.:"|awk '{print $2}'`
 else
@@ -10,20 +43,34 @@
     numcpu=2
 fi
 
 # NB// max_load is in units of percent.
 #
-lperc=`echo "100 * $load / $numcpu"|bc`
+lperc=$(echo "100 * $load / $numcpu"|bc)
+lperc2=$(echo "100 * $load2 / $numcpu"|bc)
 if [[ "x$MAX_ALLOWED_LOAD" == "x" ]]; then
   max_load=100
 else
   max_load=$MAX_ALLOWED_LOAD
 fi
+
+lfile=/tmp/loadrunner-$USER.lockfile
+lockfile -r 5 -l 60 $lfile
 
 if [[  $lperc -lt $max_load ]];then
-  echo "Load acceptable: lperc=$lperc %, max_load=$max_load %, load=$load, numcpu=$numcpu, MAX_ALLOWED_LOAD=$MAX_ALLOWED_LOAD %"
-  echo "Starting command: \"$@\""
-  nbfake "$@"
+  if [[ $lperc -le $lperc2 ]];then
+    echo "Load acceptable: lperc=$lperc %, max_load=$max_load %, load=$load, numcpu=$numcpu, MAX_ALLOWED_LOAD=$MAX_ALLOWED_LOAD % and $lperc2 < $lperc"
+    echo "Starting command: \"$@\""
+    launchjob "$@"
+    # we sleep ten seconds here to keep the lock a little longer and give time for
+    # the uptime to show a response
+    sleep 10
+  else
+   echo "$LOADRUNNER $@" | at now + 2 minutes 2> /dev/null
+  fi
 else
   # echo "Load too high: lperc=$lperc, max_load=$max_load, waiting two minutes before trying to run command: \"$@\""
-  echo "loadrunner $@" | at now + 2 minutes 2> /dev/null
+  echo "$LOADRUNNER $@" | at now + 2 minutes 2> /dev/null
 fi
+
+sleep $(get_delay_time 10)
+rm -f $lfile