src/Pure/Thy/thy_resources.scala

       (nodes.iterator ++ nodes_committed.iterator).forall({ case (_, st) => st.ok })
   }
 
   val default_check_delay = Time.seconds(0.5)
   val default_nodes_status_delay = Time.seconds(-1.0)
-  val default_commit_clean_delay = Time.seconds(60.0)
+  val default_commit_cleanup_delay = Time.seconds(60.0)
   val default_watchdog_timeout = Time.seconds(600.0)
 
 
   class Session private[Thy_Resources](
     session_name: String,

       watchdog_timeout: Time = default_watchdog_timeout,
       nodes_status_delay: Time = default_nodes_status_delay,
       id: UUID = UUID(),
       // commit: must not block, must not fail
       commit: Option[(Document.Snapshot, Document_Status.Node_Status) => Unit] = None,
-      commit_clean_delay: Time = default_commit_clean_delay,
+      commit_cleanup_delay: Time = default_commit_cleanup_delay,
       progress: Progress = No_Progress): Theories_Result =
     {
       val dep_theories =
       {
         val import_names =

           Standard_Thread.delay_first(nodes_status_delay max Time.zero) {
             progress.nodes_status(use_theories_state.value.nodes_status)
           }
 
         val delay_commit_clean =
-          Standard_Thread.delay_first(commit_clean_delay max Time.zero) {
+          Standard_Thread.delay_first(commit_cleanup_delay max Time.zero) {
             val clean = use_theories_state.value.already_committed.keySet
             resources.clean_theories(session, id, clean)
           }
 
         val dep_theories_set = dep_theories.toSet

 
               theory_progress.foreach(progress.theory(_))
 
               check_result()
 
-              if (commit.isDefined && commit_clean_delay > Time.zero) {
+              if (commit.isDefined && commit_cleanup_delay > Time.zero) {
                 if (use_theories_state.value.finished_result)
                   delay_commit_clean.revoke
                 else delay_commit_clean.invoke
               }
             }