src/Pure/PIDE/headless.scala

                     val (nodes_status_changed, nodes_status1) =
                       st.nodes_status.update(resources, state, version,
                         domain = Some(domain), trim = changed.assignment)
 
                     if (nodes_status_delay >= Time.zero && nodes_status_changed) {
-                      delay_nodes_status.invoke
+                      delay_nodes_status.invoke()
                     }
 
                     val theory_progress =
                       (for {
                         (name, node_status) <- nodes_status1.present.iterator

 
               check_state()
 
               if (commit.isDefined && commit_cleanup_delay > Time.zero) {
                 if (use_theories_state.value.finished_result)
-                  delay_commit_clean.revoke
-                else delay_commit_clean.invoke
+                  delay_commit_clean.revoke()
+                else delay_commit_clean.invoke()
               }
             }
         }
       }
 
       try {
         session.commands_changed += consumer
         check_state()
         use_theories_state.guarded_access(_.join_result)
-        check_progress.cancel
+        check_progress.cancel()
       }
       finally {
         session.commands_changed -= consumer
         resources.unload_theories(session, id, dep_theories)
       }

     {
       val session = new Session(session_base_info.session, options, resources)
 
       progress.echo("Starting session " + session_base_info.session + " ...")
       Isabelle_Process(session, options, session_base_info.sessions_structure, store,
-        logic = session_base_info.session, modes = print_mode).await_startup
+        logic = session_base_info.session, modes = print_mode).await_startup()
 
       session
     }