diff --git a/Makefile b/Makefile
index 34c9d4c4c36f6534295c7bae613991df0a607948..a9d285953d9b2b2e3d497258712b31299dad1159 100644
--- a/Makefile
+++ b/Makefile
@@ -55,7 +55,7 @@ install: archive-copy
 
 bump: bump-version
 bump-version: build/asdf.lisp
-	./bin/asdf-builder bump-version
+	./bin/asdf-builder bump-version ${v}
 
 driver-files:
 	@echo $(driver_lisp)
diff --git a/asdf.asd b/asdf.asd
index bbb03027078cd010a79a35bb6ab2b82d981d30ad..4eb5a40e3fafda66b033b53b990731416bc8be43 100644
--- a/asdf.asd
+++ b/asdf.asd
@@ -15,7 +15,7 @@
   :licence "MIT"
   :description "Another System Definition Facility"
   :long-description "ASDF builds Common Lisp software organized into defined systems."
-  :version "2.26.127" ;; to be automatically updated by bin/bump-revision
+  :version "2.26.128" ;; to be automatically updated by make bump-version
   :depends-on ()
   :components ((:module "build" :components ((:file "asdf"))))
   :in-order-to (#+asdf2.27 (compile-op (monolithic-load-concatenated-source-op asdf/defsystem))))
diff --git a/bin/asdf-builder b/bin/asdf-builder
index 60d281ba384e5f0fcfbaeca3137a0b60244fcdd6..e6861a030c5e4d0f53b7179b139fbc45e70fb170 100755
--- a/bin/asdf-builder
+++ b/bin/asdf-builder
@@ -172,7 +172,7 @@
 
 (defparameter *versioned-files*
   '(("version.lisp-expr" "\"" "\"")
-    ("asdf.asd" "  :version \"" "\" ;; to be automatically updated by bin/bump-revision")
+    ("asdf.asd" "  :version \"" "\" ;; to be automatically updated by make bump-version")
     ("header.lisp" "This is ASDF " ": Another System Definition Facility.")
     ("upgrade.lisp" "   (asdf-version \"" "\")")))
 
diff --git a/bin/prelude.lisp b/bin/prelude.lisp
index 9e57c3eeec6bdbb643c747023574a988817be608..4d6138788d57187b933adf337119f32124f432d2 100644
--- a/bin/prelude.lisp
+++ b/bin/prelude.lisp
@@ -3,13 +3,23 @@
 
 (format t "Loading your implementation's ASDF... ~%")
 (require :asdf)
-(in-package :asdf)
+(format t "~:[No ~;~]ASDF~:*~@[ ~A~] was provided~%"
+  (when (find-package :asdf)
+    (or (symbol-value (or (find-symbol (string :*asdf-version*) :asdf)
+                          (find-symbol (string :*asdf-revision*) :asdf)))
+        (string :1.x))))
 #-asdf2 (error "Not ASDF2, you lose!")
+
+(in-package :asdf)
+(defparameter *provided-version* (asdf-version))
 (format t "Initializing the source registry... ~%")
 (initialize-source-registry)
 (format t "Upgrading to the latest ASDF... ~%")
-(upgrade-asdf)
-(format t "At ASDF ~A.~%" (asdf-version))
+(load-system :asdf)
+(let ((ver (asdf-version)))
+  (if (equal ver *provided-version*)
+      (format t "Congratulations to your implementation for being up to date!~%")
+      (format t "Upgraded to ASDF ~A~%" ver)))
 (format t "Now loading some dependencies... ~%")
 (load-systems :cl-ppcre :fare-utils :inferior-shell)
 
diff --git a/header.lisp b/header.lisp
index c1e0b0ebe67813bbbc1e2900247a03ab02c9f055..c0d93d18990df0621643a83bb42e8c980b94a50f 100644
--- a/header.lisp
+++ b/header.lisp
@@ -1,5 +1,5 @@
 ;; -*- mode: Common-Lisp; Base: 10 ; Syntax: ANSI-Common-Lisp ; coding: utf-8 -*-
-;;; This is ASDF 2.26.127: Another System Definition Facility.
+;;; This is ASDF 2.26.128: Another System Definition Facility.
 ;;;
 ;;; Feedback, bug reports, and patches are all welcome:
 ;;; please mail to <asdf-devel@common-lisp.net>.
@@ -46,3 +46,21 @@
 ;;; we can't use defsystem to compile it.  Hence, all in one file.
 
 #+xcvb (module ())
+
+#+clisp
+(in-package :cl-user)
+#+clisp
+(eval-when (:load-toplevel :compile-toplevel :execute)
+  (unless (member :asdf2.27 *features*)
+    (let ((p (find-package :asdf)))
+      (when p
+        (rename-package
+         :asdf
+         (format nil "~A-~A" :asdf
+                 (or (symbol-value (and (member :asdf2 *features*)
+                                        (or (find-symbol (string :*asdf-version*) :asdf)
+                                            (find-symbol (string :*asdf-revision*) :asdf))))
+                     :1.x)))
+        (when *load-verbose*
+          (format t "; Renamed package ~A away to ~A~%"
+                  :asdf (package-name p)))))))
diff --git a/image.lisp b/image.lisp
index a6b8bccf7b50ed9d832d92d89f9860b53a901f34..9eb79349ab3296a7044563b669381be7718a66c3 100644
--- a/image.lisp
+++ b/image.lisp
@@ -226,7 +226,7 @@ if we are not called from a directly executable image dumped by XCVB."
     (standard-eval-thunk *image-prelude*)
     (let ((results (multiple-value-list
                     (if *image-entry-point*
-                        (apply (ensure-function *image-entry-point*) *command-line-arguments*)
+                        (call-function *image-entry-point*)
                         t))))
       (if *lisp-interaction*
           (apply 'values results)
diff --git a/package.lisp b/package.lisp
index 3764563679ccd32a8e567950b89a8d9af27e2099..4cb9ea1a2ac37cf2916c18bcf287ffc14fc56f40 100644
--- a/package.lisp
+++ b/package.lisp
@@ -10,8 +10,6 @@
 ;; and reexported in a different package
 ;; (alternatively the package may be dropped & replaced by one with a new name).
 
-#+clisp (declaim (optimize (speed 1)(safety 3)(debug 3)))
-
 (defpackage :asdf/package
   (:use :common-lisp)
   (:export
diff --git a/test/run-tests.sh b/test/run-tests.sh
index b3cc3ad518c7c0483ddf550fba82443ce03edb52..b21c05050a7f57ef6b0497428852771646a5cce5 100755
--- a/test/run-tests.sh
+++ b/test/run-tests.sh
@@ -240,7 +240,7 @@ upgrade_tags () {
     # 1.369 is the last release by Gary King
     # 2.000 to 2.019 and 2.20 to 2.27 and beyond are Faré's "stable" releases
     # 2.26.61 is the last single-package ASDF.
-    echo REQUIRE 1.37 1.97 1.369 2.26.61
+    echo REQUIRE 1.37 1.97 1.369
     git tag -l '2.0??'
     git tag -l '2.??'
 }
diff --git a/test/script-support.lisp b/test/script-support.lisp
index ed74220a5a381e4a80182723c1ad9a23b8f9e45f..6a56d512eb818bb22cf44094b381fccbbef52333 100644
--- a/test/script-support.lisp
+++ b/test/script-support.lisp
@@ -251,14 +251,6 @@ is bound, write a message and exit on an error.  If
 (defun register-directory (dir)
   (pushnew dir (symbol-value (asym :*central-registry*))))
 
-(defun clean-asdf-system ()
-  (let ((fasl (resolve-output "asdf" "build" "asdf.fasl")))
-    (when (DBG :clean fasl (probe-file fasl)) (delete-file fasl))))
-
-(defun load-asdf-lisp-clean ()
-  (load-asdf-lisp)
-  (clean-asdf-system))
-
 (defun load-asdf-system (&rest keys)
   (quietly
    (register-directory *asdf-directory*)
@@ -359,16 +351,22 @@ is bound, write a message and exit on an error.  If
     (register-directory *test-directory*)
     (acall :oos (asym :load-op) x :verbose verbose)))
 
+(defun get-asdf-version ()
+  (when (find-package :asdf)
+    (or (symbol-value (or (find-symbol (string :*asdf-version*) :asdf)
+                          (find-symbol (string :*asdf-revision*) :asdf)))
+        (string :1.x))))
+
 (defun test-upgrade (old-method new-method tag) ;; called by run-test
   (with-test ()
-    #+clisp (trace compile-file load)
     (when old-method
       (cond
         ((string-equal tag "REQUIRE")
-         (format t "Requiring some previous asdf ~A~%" tag)
+         (format t "Requiring some previous ASDF ~A~%" tag)
          (ignore-errors (funcall 'require "asdf"))
-         (unless (member "ASDF" *modules* :test 'equalp)
-           (leave-test "Your Lisp implementation does not provide ASDF. Skipping test.~%" 0)))
+         (if (member "ASDF" *modules* :test 'equalp)
+             (format t "Your Lisp implementation provided ASDF ~A~%" (get-asdf-version))
+             (leave-test "Your Lisp implementation does not provide ASDF. Skipping test.~%" 0)))
         (t
          (format t "Loading old asdf ~A via ~A~%" tag old-method)
          (funcall old-method tag))))
@@ -394,6 +392,14 @@ is bound, write a message and exit on an error.  If
 (defun test-fasl (file)
   (acall :compile-file-pathname* (test-source file)))
 
+(defun clean-asdf-system ()
+  (let ((fasl (resolve-output "asdf" "build" "asdf.fasl")))
+    (when (DBG :clean fasl (probe-file fasl)) (delete-file fasl))))
+
+(defun load-asdf-lisp-clean ()
+  (load-asdf-lisp)
+  (clean-asdf-system))
+
 (defun configure-asdf ()
   (setf *debug-asdf* (or *debug-asdf* (acall :getenvp "DEBUG_ASDF_TEST")))
   (untrace)
diff --git a/test/test-logical-pathname.script b/test/test-logical-pathname.script
index 770417f8c66bdd51ebe410fb10e875881f658004..317f5f8df83fcfd8b0b9a3f2579bda4d55679a17 100644
--- a/test/test-logical-pathname.script
+++ b/test/test-logical-pathname.script
@@ -2,9 +2,6 @@
 
 (load-asdf)
 
-#+clisp
-(trace load compile-file)
-
 #-gcl<2.7
 (setf (logical-pathname-translations "ASDF")
       #+(or allegro clisp)
diff --git a/test/test-module-excessive-depend.script b/test/test-module-excessive-depend.script
index 704e7d02293731eab54ad3d333b0f86ab329622c..dc938bc72f298a85c915e4f988f8fd7d98206abb 100644
--- a/test/test-module-excessive-depend.script
+++ b/test/test-module-excessive-depend.script
@@ -56,8 +56,8 @@
                                      '("file1" "file2" "file3"))))))
 
 ;; and loaded
-(assert (eval (asdf::find-symbol* '#:*file1* :test-package)))
-(assert (eval (asdf::find-symbol* '#:*file3* :test-package)))
+(assert (eval (find-symbol* '#:*file1* :test-package)))
+(assert (eval (find-symbol* '#:*file3* :test-package)))
 
 
 ;; now touch file1 and check that file2 _is_ also recompiled
@@ -66,21 +66,19 @@
 ;; dependency bug is fixed and the excessive compilation bug is fixed.
 
 (defparameter before file3-date)
-(touch-file "file1.lisp" :timestamp (- before 60))
+(touch-file (test-source "file1.lisp") :timestamp (- before 60))
 (touch-file file1 :timestamp (- before 90))
-(touch-file "file2.lisp" :timestamp (- before 30))
+(touch-file (test-source "file2.lisp") :timestamp (- before 30))
 (touch-file file2 :timestamp (- before 15))
 
-(defparameter plan (asdf::traverse
-                    (make-instance 'asdf:load-op)
-                    (asdf:find-system 'test-module-excessive-depend)))
-(defparameter file3 (asdf:find-component :file3-only "file3"))
+(defparameter plan (traverse 'load-op 'test-module-excessive-depend))
+(defparameter file3c (find-component :file3-only "file3"))
 #|(format t "~%Operation plan is:~%")(pprint plan)(terpri)|#
-(when (loop :for (o . c) :in plan :thereis (and (eq c file3) (typep o 'asdf:compile-op)))
+(when (loop :for (o . c) :in plan :thereis (and (eq c file3c) (typep o 'asdf:compile-op)))
   (error "Excessive operations on file3-only system.  Bad propagation of dependencies."))
 (asdf:operate 'asdf:load-op 'test-module-excessive-depend)
 (assert (>= (file-write-date file1) before))
-(assert (>= (file-write-date file2) before)))
+(assert (>= (file-write-date file2) before))
 (unless (= (file-write-date file3)
            file3-date)
   (error "Excessive compilation of file3.lisp:  traverse bug."))
diff --git a/upgrade.lisp b/upgrade.lisp
index c27bb70426a14fa2b05b3b5f0326947cd80d1c7f..d19058f700c691a5416c43f7072a3965af52dbc3 100644
--- a/upgrade.lisp
+++ b/upgrade.lisp
@@ -28,14 +28,14 @@
 
 (eval-when (:load-toplevel :compile-toplevel :execute)
   (let* (;; For bug reporting sanity, please always bump this version when you modify this file.
-         ;; Please also modify asdf.asd to reflect this change. The script bin/bump-version
+         ;; Please also modify asdf.asd to reflect this change. make bump-version
          ;; can help you do these changes in synch (look at the source for documentation).
          ;; Relying on its automation, the version is now redundantly present on top of this file.
          ;; "2.345" would be an official release
          ;; "2.345.6" would be a development version in the official upstream
          ;; "2.345.0.7" would be your seventh local modification of official release 2.345
          ;; "2.345.6.7" would be your seventh local modification of development version 2.345.6
-         (asdf-version "2.26.127")
+         (asdf-version "2.26.128")
          (existing-asdf (find-class (find-symbol* :component :asdf nil) nil))
          (existing-version *asdf-version*)
          (already-there (equal asdf-version existing-version))
@@ -65,7 +65,7 @@
         (format *trace-output*
                 (compatfmt "~&~@<; ~@;Upgrading ASDF ~@[from version ~A ~]to version ~A~@:>~%")
                 existing-version asdf-version))
-      (loop :for name :in (append #-(or clisp ecl common-lisp) redefined-functions)
+      (loop :for name :in (append #-(or clisp ecl) redefined-functions)
               :for sym = (find-symbol* name :asdf nil) :do
                 (when sym
                   ;;(format t "Undefining ~S~%" sym);XXX
diff --git a/utility.lisp b/utility.lisp
index 63a363663e1c2f2e4b4d0783764ccc1ffd50f11f..5b877b4dc50d9bde6ab66faf137036ba138cb095 100644
--- a/utility.lisp
+++ b/utility.lisp
@@ -59,11 +59,11 @@
             (declare (ignorable supersede))
             `(progn
              ;; undefining the previous function is the portable way
-             ;; of overriding any incompatible previous gf,
-             ;; but we usually try to do it only for the functions that need it,
+             ;; of overriding any incompatible previous gf, except on CLISP.
+             ;; We usually try to do it only for the functions that need it,
              ;; which happens in asdf/upgrade - however, for ECL, we need this hammer,
              ;; (which causes issues in clisp)
-               ,@(when (or #-ecl supersede #+(or (and gcl (not gcl-pre2.7))) t) ; XXX
+               ,@(when (or supersede #+(or ecl (and gcl (not gcl-pre2.7))) t) ; XXX
                    `((undefine-function ',name)))
                #-gcl ; gcl 2.7.0 notinline functions lose secondary return values :-(
                ,@(when (and #+ecl (symbolp name)) ; fails for setf functions on ecl
diff --git a/version.lisp-expr b/version.lisp-expr
index 70bb2415887b27dcb83812ef38b07d6e72c10b4a..a2f774a8ca06f7d51a1976327fee7f9af5d9d514 100644
--- a/version.lisp-expr
+++ b/version.lisp-expr
@@ -1 +1 @@
-"2.26.127"
+"2.26.128"