diff --git a/action.lisp b/action.lisp
index bfe442d2bb63541ae0b874a5261b83d8c843883e..a6702345a9810f5a51e0cbdb1d96a211b0492bb1 100644
--- a/action.lisp
+++ b/action.lisp
@@ -44,7 +44,7 @@ and a class-name or class designates the canonical instance of the designated cl
   (defun action-component (action)
     (cdr action)))
 
-;;;; Reified representation for storage or debugging. Note: it drops the operation-original-initargs
+;;;; Reified representation for storage or debugging. Note: an action is identified by its class.
 (with-upgradability ()
   (defun action-path (action)
     "A readable data structure that identifies the action."
@@ -67,10 +67,8 @@ and a class-name or class designates the canonical instance of the designated cl
   ;; FORMALS is its list of arguments, which must include OPERATION and COMPONENT.
   ;; IF-NO-OPERATION is a form (defaults to NIL) describing what to do if no operation is found.
   ;; IF-NO-COMPONENT is a form (defaults to NIL) describing what to do if no component is found.
-  ;; If OPERATION-INITARGS is true, then for backward compatibility the function has
-  ;; a &rest argument that is passed into the operation's initargs if and when it is created.
   (defmacro define-convenience-action-methods
-      (function formals &key if-no-operation if-no-component operation-initargs)
+      (function formals &key if-no-operation if-no-component)
     (let* ((rest (gensym "REST"))
            (found (gensym "FOUND"))
            (keyp (equal (last formals) '(&key)))
@@ -95,9 +93,7 @@ and a class-name or class designates the canonical instance of the designated cl
            (defmethod ,function (,@prefix (,operation symbol) ,component ,@suffix ,@more-args)
              (if ,operation
                  ,(next-method
-                   (if operation-initargs ;backward-compatibility with ASDF1's operate. Yuck.
-                       `(apply 'make-operation ,operation :original-initargs ,rest ,rest)
-                       `(make-operation ,operation))
+                   `(make-operation ,operation)
                    `(or (find-component () ,component) ,if-no-component))
                  ,if-no-operation))
            (defmethod ,function (,@prefix (,operation operation) ,component ,@suffix ,@more-args)
@@ -117,7 +113,7 @@ on this component, e.g. \"loading /a/b/c\".
 You can put together sentences using this phrase."))
   (defmethod action-description (operation component)
     (format nil (compatfmt "~@<~A on ~A~@:>")
-            (type-of operation) component))
+            operation component))
 
   (defun format-action (stream action &optional colon-p at-sign-p)
     "FORMAT helper to display an action's action-description.
@@ -399,10 +395,10 @@ in some previous image, or T if it needs to be done.")
         (format stream "~@{~S~^ ~}" :stamp stamp :done-p done-p))))
 
   (defmethod component-operation-time ((o operation) (c component))
-    (gethash (type-of o) (component-operation-times c)))
+    (gethash o (component-operation-times c)))
 
   (defmethod (setf component-operation-time) (stamp (o operation) (c component))
-    (setf (gethash (type-of o) (component-operation-times c)) stamp))
+    (setf (gethash o (component-operation-times c)) stamp))
 
   (defmethod mark-operation-done ((o operation) (c component))
     (setf (component-operation-time o c) (compute-action-stamp nil o c :just-done t))))
diff --git a/bundle.lisp b/bundle.lisp
index 82f65544610c8b123c23922e0bf68b216aa69a31..6f56525d0356c3a6d509fb8f3b2a2d81caba04eb 100644
--- a/bundle.lisp
+++ b/bundle.lisp
@@ -17,8 +17,7 @@
    #:deliver-asd-op #:monolithic-deliver-asd-op
    #:program-op #:image-op #:compiled-file #:precompiled-system #:prebuilt-system
    #:user-system-p #:user-system #:trivial-system-p
-   #:make-build
-   #:build-args #:name-suffix #:prologue-code #:epilogue-code #:static-library))
+   #:prologue-code #:epilogue-code #:static-library))
 (in-package :asdf/bundle)
 
 (with-upgradability ()
@@ -26,10 +25,7 @@
     ;; NB: use of instance-allocated slots for operations is DEPRECATED
     ;; and only supported in a temporary fashion for backward compatibility.
     ;; Supported replacement: Define slots on program-system instead.
-    ((build-args :initarg :args :initform nil :accessor extra-build-args)
-     (name-suffix :initarg :name-suffix :initform nil)
-     (bundle-type :initform :no-output-file :reader bundle-type)
-     #+(or clasp ecl) (lisp-files :initform nil :accessor extra-object-files))
+    ((bundle-type :initform :no-output-file :reader bundle-type :allocation :class))
     (:documentation "base class for operations that bundle outputs from multiple components"))
 
   (defclass monolithic-op (operation) ()
@@ -60,13 +56,13 @@ itself."))
      (extra-build-args :initarg :extra-build-args
                        :initform nil :accessor extra-build-args)))
 
-  (defmethod prologue-code ((x t)) nil)
-  (defmethod epilogue-code ((x t)) nil)
-  (defmethod no-uiop ((x t)) nil)
-  (defmethod prefix-lisp-object-files ((x t)) nil)
-  (defmethod postfix-lisp-object-files ((x t)) nil)
-  (defmethod extra-object-files ((x t)) nil)
-  (defmethod extra-build-args ((x t)) nil)
+  (defmethod prologue-code ((x system)) nil)
+  (defmethod epilogue-code ((x system)) nil)
+  (defmethod no-uiop ((x system)) nil)
+  (defmethod prefix-lisp-object-files ((x system)) nil)
+  (defmethod postfix-lisp-object-files ((x system)) nil)
+  (defmethod extra-object-files ((x system)) nil)
+  (defmethod extra-build-args ((x system)) nil)
 
   (defclass link-op (bundle-op) ()
     (:documentation "Abstract operation for linking files together"))
@@ -204,13 +200,13 @@ for all the linkable object files associated with the system or its dependencies
 
   (defclass image-op (monolithic-bundle-op selfward-operation
                       #+(or clasp ecl mkcl) link-op #+(or clasp ecl mkcl) gather-operation)
-    ((bundle-type :initform :image)
+    ((bundle-type :initform :image :allocation :class)
      #+(or clasp ecl mkcl) (gather-type :initform :static-library :allocation :class)
      (selfward-operation :initform '(#-(or clasp ecl mkcl) load-op) :allocation :class))
     (:documentation "create an image file from the system and its dependencies"))
 
   (defclass program-op (image-op)
-    ((bundle-type :initform :program))
+    ((bundle-type :initform :program :allocation :class))
     (:documentation "create an executable file from the system and its dependencies"))
 
   ;; From the ASDF-internal bundle-type identifier, get a filesystem-usable pathname type.
@@ -246,7 +242,14 @@ for all the linkable object files associated with the system or its dependencies
       (unless (or (eq bundle-type :no-output-file) ;; NIL already means something regarding type.
                   (and (null (input-files o c)) (not (member bundle-type '(:image :program)))))
         (let ((name (or (component-build-pathname c)
-                        (format nil "~A~@[~A~]" (component-name c) (slot-value o 'name-suffix))))
+                        (let ((suffix
+                               (unless (typep o 'program-op)
+                                 ;; "." is no good separator for Logical Pathnames, so we use "--"
+                                 (if (operation-monolithic-p o)
+                                     "--all-systems"
+                                     ;; These use a different type .fasb or .a instead of .fasl
+                                     #-(or clasp ecl mkcl) "--system"))))
+                          (format nil "~A~@[~A~]" (component-name c) suffix))))
               (type (bundle-pathname-type bundle-type)))
           (values (list (subpathname (component-pathname c) name :type type))
                   (eq (class-of o) (coerce-class (component-build-operation c)
@@ -288,31 +291,12 @@ or of opaque libraries shipped along the source code."))
 ;;; a FASL, a statically linked library, a shared library, etc.
 ;;; The different targets are defined by specialization.
 ;;;
-(with-upgradability ()
-  (defmethod initialize-instance :after ((instance bundle-op) &rest initargs
-                                         &key (name-suffix nil name-suffix-p)
-                                         &allow-other-keys)
-    (declare (ignore initargs name-suffix))
-    ;; TODO: make that class slots or methods, not instance slots
-    (unless name-suffix-p
-      (setf (slot-value instance 'name-suffix)
-            (unless (typep instance 'program-op)
-              ;; "." is no good separator for Logical Pathnames, so we use "--"
-              (if (operation-monolithic-p instance) "--all-systems" #-(or clasp ecl mkcl) "--system"))))
-    (when (typep instance 'monolithic-bundle-op)
-      (destructuring-bind (&key lisp-files prologue-code epilogue-code
-                           &allow-other-keys)
-          (operation-original-initargs instance)
-        (setf (prologue-code instance) prologue-code
-              (epilogue-code instance) epilogue-code)
-        #-(or clasp ecl) (assert (null (or lisp-files #-mkcl epilogue-code #-mkcl prologue-code)))
-        #+(or clasp ecl) (setf (extra-object-files instance) lisp-files)))
-    (setf (extra-build-args instance)
-          (remove-plist-keys
-           '(:type :monolithic :name-suffix :epilogue-code :prologue-code :lisp-files
-             :force :force-not :plan-class) ;; TODO: refactor so we don't mix plan and operation arguments
-           (operation-original-initargs instance))))
+(when-upgrading (:version "3.1.9")
+  ;; Cancel any previously defined method
+  (defmethod initialize-instance :after ((instance bundle-op) &rest initargs &key &allow-other-keys)
+    (declare (ignore initargs))))
 
+(with-upgradability ()
   (defgeneric trivial-system-p (component))
 
   (defun user-system-p (s)
@@ -362,48 +346,7 @@ or of opaque libraries shipped along the source code."))
       ((:image)
        'image-op)
       ((:program)
-       'program-op)))
-
-  ;; DEPRECATED. This is originally from asdf-ecl.lisp.
-  ;; It must die, and so must any use of initargs in operation,
-  ;; unless keys to the asdf-cache are substantially modified to accommodate for them.
-  ;; Coordinate with the ECL maintainers to get them to stop using it.
-  ;; SUPPORTED REPLACEMENT: Use program-op and program-system
-  (defun make-build (system &rest args &key (monolithic nil) (type :fasl)
-                             (move-here nil move-here-p)
-                             &allow-other-keys)
-    (let* ((operation-name (select-bundle-operation type monolithic))
-           (move-here-path (if (and move-here
-                                    (typep move-here '(or pathname string)))
-                               (ensure-pathname move-here :namestring :lisp :ensure-directory t)
-                               (system-relative-pathname system "asdf-output/")))
-           (operation (apply 'operate operation-name
-                             system
-                             (remove-plist-keys '(:monolithic :type :move-here) args)))
-           (system (find-system system))
-           (files (and system (output-files operation system))))
-      (if (or move-here (and (null move-here-p)
-                             (member operation-name '(:program :image))))
-          (loop :with dest-path = (resolve-symlinks* (ensure-directories-exist move-here-path))
-                :for f :in files
-                :for new-f = (make-pathname :name (pathname-name f)
-                                            :type (pathname-type f)
-                                            :defaults dest-path)
-                :do (handler-case (rename-file-overwriting-target f new-f)
-                      (file-error (c)
-                        (declare (ignore c))
-                        (copy-file f new-f)
-                        (delete-file-if-exists f)))
-                :collect new-f)
-          files)))
-
-  ;; DEPRECATED. Apparently, some users of ECL, MKCL and ABCL may still be using it;
-  ;; but at the very least, this function should be renamed, and/or
-  ;; some way of specifying the output directory should be provided.
-  ;; As is, it is not such a useful interface.
-  (defun bundle-system (system &rest args &key force (verbose t) version &allow-other-keys)
-    (declare (ignore force verbose version))
-    (apply 'operate 'deliver-asd-op system args)))
+       'program-op))))
 
 ;;;
 ;;; LOAD-BUNDLE-OP
@@ -538,8 +481,7 @@ which is probably not what you want; you probably need to tweak your output tran
         (when non-fasl-files
           (error "On ~A, asdf/bundle can only bundle FASL files, but these were also produced: ~S"
                  (implementation-type) non-fasl-files))
-        (when (or (prologue-code o) (epilogue-code o)
-                  (prologue-code c) (epilogue-code c))
+        (when (or (prologue-code c) (epilogue-code c))
           (error "prologue-code and epilogue-code are not supported on ~A"
                  (implementation-type)))
         (with-staging-pathname (output-file)
@@ -615,9 +557,9 @@ which is probably not what you want; you probably need to tweak your output tran
                        object-files
                        (when programp (postfix-lisp-object-files c)))
                :kind kind
-               :prologue-code (or (prologue-code o) (when programp (prologue-code c)))
-               :epilogue-code (or (epilogue-code o) (when programp (epilogue-code c)))
-               :build-args (or (extra-build-args o) (when programp (extra-build-args c)))
-               :extra-object-files (or (extra-object-files o) (when programp (extra-object-files c)))
+               :prologue-code (when programp (prologue-code c))
+               :epilogue-code (when programp (epilogue-code c))
+               :build-args (when programp (extra-build-args c))
+               :extra-object-files (when programp (extra-object-files c))
                :no-uiop (no-uiop c)
                (when programp `(:entry-point ,(component-entry-point c))))))))
diff --git a/interface.lisp b/interface.lisp
index f1a086b9120af029337255df1406b8be75be6fc2..d654ae91ba7f69e8eb26d381d04039367088befc 100644
--- a/interface.lisp
+++ b/interface.lisp
@@ -35,7 +35,7 @@
    #:needed-in-image-p
    #:component-load-dependencies #:run-shell-command ; deprecated, do not use
    #:bundle-op #:monolithic-bundle-op #:precompiled-system #:compiled-file #:bundle-system
-   #:program-system #:make-build
+   #:program-system
    #:basic-compile-bundle-op #:prepare-bundle-op
    #:compile-bundle-op #:load-bundle-op #:monolithic-compile-bundle-op #:monolithic-load-bundle-op
    #:lib-op #:dll-op #:deliver-asd-op #:program-op #:image-op
diff --git a/lisp-action.lisp b/lisp-action.lisp
index b7bfeb7847ace40efb79e2e58c741950297d8db5..9c1fa5a8d5b3d22394d587e1f6ffed1b1fc0278f 100644
--- a/lisp-action.lisp
+++ b/lisp-action.lisp
@@ -3,18 +3,17 @@
 
 (uiop/package:define-package :asdf/lisp-action
   (:recycle :asdf/lisp-action :asdf)
-  (:intern #:proclamations #:flags)
   (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/cache
    :asdf/component :asdf/system :asdf/find-component :asdf/find-system
    :asdf/operation :asdf/action)
   (:export
    #:try-recompiling
    #:cl-source-file #:cl-source-file.cl #:cl-source-file.lsp
-   #:basic-load-op #:basic-compile-op #:compile-op-flags #:compile-op-proclamations
+   #:basic-load-op #:basic-compile-op
    #:load-op #:prepare-op #:compile-op #:test-op #:load-source-op #:prepare-source-op
    #:call-with-around-compile-hook
    #:perform-lisp-compilation #:perform-lisp-load-fasl #:perform-lisp-load-source
-   #:lisp-compilation-output-files #:flags))
+   #:lisp-compilation-output-files))
 (in-package :asdf/lisp-action)
 
 
@@ -35,11 +34,7 @@
 (with-upgradability ()
   (defclass basic-load-op (operation) ()
     (:documentation "Base class for operations that apply the load-time effects of a file"))
-  (defclass basic-compile-op (operation)
-    ;; NB: These slots are deprecated. They are for backward compatibility only,
-    ;; and will be removed at some point in the future.
-    ((proclamations :initarg :proclamations :accessor compile-op-proclamations :initform nil)
-     (flags :initarg :flags :accessor compile-op-flags :initform nil))
+  (defclass basic-compile-op (operation) ()
     (:documentation "Base class for operations that apply the compile-time effects of a file")))
 
 
@@ -125,7 +120,7 @@ Note that it will NOT be called around the performing of LOAD-OP."))
                           (append
                            #+clisp (list :lib-file lib-file)
                            #+(or clasp ecl mkcl) (list :object-file object-file)
-                           flags (compile-op-flags o))))))
+                           flags)))))
         (check-lisp-compile-results output warnings-p failure-p
                                     "~/asdf-action::format-action/" (list (cons o c))))))
   (defun report-file-p (f)
diff --git a/operate.lisp b/operate.lisp
index 0a5b6e70548b48fedd5e7ab0434b8db26f1e0209..992bc7984d3b305b4048c2ec62860bf9faa2a1bf 100644
--- a/operate.lisp
+++ b/operate.lisp
@@ -44,9 +44,6 @@ when instantiating a new operation, that will in turn be inherited by new operat
 But do NOT depend on it, for this is deprecated behavior."))
 
   (define-convenience-action-methods operate (operation component &key)
-    ;; I'd like to at least remove-plist-keys :force :force-not :verbose,
-    ;; but swank.asd relies on :force (!).
-    :operation-initargs t ;; backward-compatibility with ASDF1. Deprecated.
     :if-no-component (error 'missing-component :requires component))
 
   (defvar *in-operate* nil
@@ -65,9 +62,8 @@ But do NOT depend on it, for this is deprecated behavior."))
            (*in-operate* t)
            (operation-remaker ;; how to remake the operation after ASDF was upgraded (if it was)
             (etypecase operation
-              (operation (let ((name (type-of operation))
-                               (initargs (operation-original-initargs operation)))
-                           #'(lambda () (apply 'make-operation name :original-initargs initargs initargs))))
+              (operation (let ((name (type-of operation)))
+                           #'(lambda () (make-operation name))))
               ((or symbol string) (constantly operation))))
            (component-path (typecase component ;; to remake the component after ASDF upgrade
                              (component (component-find-path component))
@@ -78,7 +74,7 @@ But do NOT depend on it, for this is deprecated behavior."))
        (unless in-operate
          (when (upgrade-asdf)
            ;; If we were upgraded, restart OPERATE the hardest of ways, for
-           ;; its function may have been redefined, its symbol uninterned, its package deleted.
+           ;; its function may have been redefined.
            (return-from operate
              (apply 'operate (funcall operation-remaker) component-path keys)))))
       ;; Setup proper bindings around any operate call.
@@ -284,5 +280,5 @@ the implementation's REQUIRE rather than by internal ASDF mechanisms."))
       ;; Mark the timestamps of the common lisp-action operations as 0.
       (let ((times (component-operation-times component)))
         (dolist (o '(load-op compile-op prepare-op))
-          (setf (gethash o times) 0))))))
+          (setf (gethash (make-operation o) times) 0))))))
 
diff --git a/operation.lisp b/operation.lisp
index 9defb97eeeb2991602fd16777ffa470d76a1c4d4..dbac55545f677055e6ff220bfb236b3723572258 100644
--- a/operation.lisp
+++ b/operation.lisp
@@ -6,40 +6,25 @@
   (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/find-system)
   (:export
    #:operation
-   #:operation-original-initargs #:original-initargs ;; backward-compatibility only. DO NOT USE.
    #:*operations* #:make-operation #:find-operation
    #:feature)) ;; TODO: stop exporting the deprecated FEATURE feature.
 (in-package :asdf/operation)
 
 ;;; Operation Classes
-
-(when-upgrading (:when (find-class 'operation nil))
+(when-upgrading (:version "2.27" :when (find-class 'operation nil))
   ;; override any obsolete shared-initialize method when upgrading from ASDF2.
   (defmethod shared-initialize :after ((o operation) (slot-names t) &key)
     (values)))
 
 (with-upgradability ()
   (defclass operation ()
-    ((original-initargs ;; for backward-compat -- used by GBBopen, and swank (via operation-forced)
-      :initform nil :initarg :original-initargs :accessor operation-original-initargs))
+    ()
     (:documentation "The base class for all ASDF operations.
 
-ASDF does NOT, never did and never will distinguish between multiple operations of the same class.
-Therefore, all slots of all operations must have (:allocation class) and no initargs.
-
-Any exceptions currently maintained for backward-compatibility are deprecated,
-and support for them may be discontinued at any moment.
+ASDF does NOT and never did distinguish between multiple operations of the same class.
+Therefore, all slots of all operations MUST have :allocation :class and no initargs. No exceptions.
 "))
 
-  ;; Cache a copy of the INITARGS in the ORIGINAL-INITARGS slot, if that slot is not already bound.
-  ;; This is a deprecated feature temporarily maintained for backward compatibility.
-  ;; It will be removed at some point in the future.
-  (defmethod initialize-instance :after ((o operation) &rest initargs
-                                         &key force force-not system verbose &allow-other-keys)
-    (declare (ignore force force-not system verbose))
-    (unless (slot-boundp o 'original-initargs)
-      (setf (operation-original-initargs o) initargs)))
-
   (defvar *in-make-operation* nil)
 
   (defun check-operation-constructor ()
@@ -48,9 +33,13 @@ and support for them may be discontinued at any moment.
       (sysdef-error "OPERATION instances must only be created through MAKE-OPERATION.")))
 
   (defmethod print-object ((o operation) stream)
-    (print-unreadable-object (o stream :type t :identity nil)
-      (ignore-errors
-       (format stream "~{~S~^ ~}" (operation-original-initargs o))))))
+    (print-unreadable-object (o stream :type t :identity nil)))
+
+  ;;; Override previous methods (from 3.1.7 and earlier) and add proper error checking.
+  (defmethod initialize-instance :after ((o operation) &rest initargs &key &allow-other-keys)
+    (unless (null initargs)
+      (parameter-error "~S does not accept initargs" 'operation))))
+
 
 ;;; make-operation, find-operation
 
@@ -59,30 +48,27 @@ and support for them may be discontinued at any moment.
   (defparameter* *operations* (make-hash-table :test 'equal))
 
   ;; A memoizing way of creating instances of operation.
-  (defun make-operation (operation-class &rest initargs)
+  (defun make-operation (operation-class)
     "This function creates and memoizes an instance of OPERATION-CLASS.
 All operation instances MUST be created through this function.
 
-Use of INITARGS is for backward compatibility and may be discontinued at any time."
+Use of INITARGS is not supported at this time."
     (let ((class (coerce-class operation-class
                                :package :asdf/interface :super 'operation :error 'sysdef-error))
           (*in-make-operation* t))
-      (ensure-gethash (cons class initargs) *operations*
-                      (list* 'make-instance class initargs))))
+      (ensure-gethash class *operations* `(make-instance ,class))))
 
-  ;; We preserve the operation-original-initargs of the context,
-  ;; but only as an unsupported feature.
-  ;; This is all done purely for the temporary sake of backwards compatibility.
+  ;; This function is mostly for backward and forward compatibility:
+  ;; operations used to preserve the operation-original-initargs of the context,
+  ;; and may in the future preserve some operation-canonical-initargs.
+  ;; Still, the treatment of NIL as a disabling context is useful in some cases.
   (defgeneric find-operation (context spec)
     (:documentation "Find an operation by resolving the SPEC in the CONTEXT"))
   (defmethod find-operation ((context t) (spec operation))
     spec)
-  (defmethod find-operation (context (spec symbol))
+  (defmethod find-operation ((context t) (spec symbol))
     (when spec ;; NIL designates itself, i.e. absence of operation
-      (apply 'make-operation spec (operation-original-initargs context))))
-  (defmethod find-operation (context (spec string))
-    (apply 'make-operation spec (operation-original-initargs context)))
-  (defmethod operation-original-initargs ((context symbol))
-    (declare (ignorable context))
-    nil))
+      (make-operation spec))) ;; TODO: preserve the (operation-canonical-initargs context)
+  (defmethod find-operation ((context t) (spec string))
+    (make-operation spec))) ;; TODO: preserve the (operation-canonical-initargs context)
 
diff --git a/plan.lisp b/plan.lisp
index b8e650a43e244217685a5fd275511b4e1c14efce..6f57579f0aad2a5de3b5ed4562546f48083915a9 100644
--- a/plan.lisp
+++ b/plan.lisp
@@ -12,7 +12,7 @@
    #:plan #:plan-traversal #:sequential-plan #:*default-plan-class*
    #:planned-action-status #:plan-action-status #:action-already-done-p
    #:circular-dependency #:circular-dependency-actions
-   #:node-for #:needed-in-image-p
+   #:needed-in-image-p
    #:action-index #:action-planned-p #:action-valid-p
    #:plan-record-dependency
    #:normalize-forced-systems #:action-forced-p #:action-forced-not-p
@@ -83,13 +83,6 @@ the action of OPERATION on COMPONENT in the PLAN"))
   (defmethod action-planned-p ((action-status t))
     t) ; default method for non planned-action-status objects
 
-  ;; TODO: either confirm there are no operation-original-initargs, eliminate NODE-FOR,
-  ;; and use (CONS O C); or keep the operation initargs, and here use MAKE-OPERATION.
-  ;; However, see also component-operation-time and mark-operation-done
-  (defun node-for (o c)
-    "Given operation O and component C, return an object to use as key in action-indexed tables."
-    (cons (type-of o) c))
-
   (defun action-already-done-p (plan operation component)
     "According to this plan, is this action already done and up to date?"
     (action-done-p (plan-action-status plan operation component)))
@@ -99,11 +92,10 @@ the action of OPERATION on COMPONENT in the PLAN"))
       (make-instance 'action-status :stamp stamp :done-p done-p)))
 
   (defmethod (setf plan-action-status) (new-status (plan null) (o operation) (c component))
-    (let ((to (type-of o))
-          (times (component-operation-times c)))
+    (let ((times (component-operation-times c)))
       (if (action-done-p new-status)
-          (remhash to times)
-          (setf (gethash to times) (action-stamp new-status))))
+          (remhash o times)
+          (setf (gethash o times) (action-stamp new-status))))
     new-status))
 
 
@@ -315,11 +307,11 @@ initialized with SEED."
     plan)
 
   (defmethod (setf plan-action-status) (new-status (p plan-traversal) (o operation) (c component))
-    (setf (gethash (node-for o c) (plan-visited-actions p)) new-status))
+    (setf (gethash (cons o c) (plan-visited-actions p)) new-status))
 
   (defmethod plan-action-status ((p plan-traversal) (o operation) (c component))
     (or (and (action-forced-not-p p o c) (plan-action-status nil o c))
-        (values (gethash (node-for o c) (plan-visited-actions p)))))
+        (values (gethash (cons o c) (plan-visited-actions p)))))
 
   (defmethod action-valid-p ((p plan-traversal) (o operation) (s system))
     (and (not (action-forced-not-p p o s)) (call-next-method)))
diff --git a/test/sample-system/a.lisp b/test/sample-system/a.lisp
deleted file mode 100644
index 7563fd2dc8d74a7a7213c3deb38112ebdbdda786..0000000000000000000000000000000000000000
--- a/test/sample-system/a.lisp
+++ /dev/null
@@ -1,9 +0,0 @@
-;;;; a.lisp
-
-(defpackage :sample
-  (:use #:cl)
-  (:export #:loaded))
-
-(in-package :sample)
-(defparameter loaded t)
-
diff --git a/test/sample-system/sample-system.asd b/test/sample-system/sample-system.asd
deleted file mode 100644
index ea858a2b3535e87e63c97e14aaf27be29a1d1a0a..0000000000000000000000000000000000000000
--- a/test/sample-system/sample-system.asd
+++ /dev/null
@@ -1,5 +0,0 @@
-;;;; foo.asd
-
-(asdf:defsystem #:sample-system
-  :serial t
-  :components ((:file "a")))
diff --git a/test/test-make-build.script b/test/test-make-build.script
deleted file mode 100644
index 257c5a0b0bd46469350324ae2f2129c75db023a9..0000000000000000000000000000000000000000
--- a/test/test-make-build.script
+++ /dev/null
@@ -1,15 +0,0 @@
-;;; -*- Lisp -*-
-
-(unless (or #+(or (and clisp os-unix) clozure cmucl
-                  (and ecl (not ecl-bytecmp)) lispworks mkcl sbcl scl) t)
-  (DBG "Creating executables is not supported on your CL implementation")
-  (leave-test "Skipping test" 0))
-
-(DBG "build sample-system. Should load from sample-system/")
-(setf *central-registry* (list (subpathname *test-directory* "sample-system/")))
-
-#+lispworks (lispworks:load-all-patches)
-
-(make-build 'sample-system
-            :type :program :monolithic t
-            #+ecl :epilogue-code #+ecl '(println "blue sky"))
diff --git a/test/test-utilities.script b/test/test-utilities.script
index 8ca10ee7322cdbb0948c97a9d29b4c5ed68e9d89..c9c0e56b944ce2d5e0bd08f0b1ee3e0b781d7183 100644
--- a/test/test-utilities.script
+++ b/test/test-utilities.script
@@ -23,11 +23,11 @@
 (defun simplify-pathname-directory-component (dir)
   (setf dir (normalize-pathname-directory-component dir))
   (loop
-   :with head = (progn
-                  (unless (and (consp dir) (cdr dir)) (return dir))
-                  (subseq dir 0 1))
-   :with tail = (rest dir)
-   :for (next rest) :on tail :do
+    :with head = (progn
+                   (unless (and (consp dir) (cdr dir)) (return dir))
+                   (subseq dir 0 1))
+    :with tail = (rest dir)
+    :for next :in tail :do
    (unless (equal next ".")
      (when (member next '(".." :up) :test 'equal) (setf next :back))
      (setf head (merge-pathname-directory-components (list :relative next) head)))
@@ -213,9 +213,7 @@
     asdf/action:done-p
     asdf/action:stamp
     asdf/bundle:prologue-code
-    asdf/bundle:build-args
     asdf/bundle:epilogue-code
-    asdf/bundle:name-suffix
     asdf/component:absolute-pathname
     asdf/component:around-compile
     asdf/component:author
@@ -242,9 +240,7 @@
     asdf/component:relative-pathname
     asdf/component:sideway-dependencies
     asdf/component:version
-    asdf/lisp-action:flags
     asdf/operation:feature
-    asdf/operation:original-initargs
     asdf/plan:index
     asdf/plan:forced
     asdf/plan:forced-not