src/Pure/ML/ml_process.scala

 import java.io.{File => JFile}
 
 
 object ML_Process {
   def apply(options: Options,
-    sessions_structure: Sessions.Structure,
+    base_info: Sessions.Base_Info,
     store: Sessions.Store,
     logic: String = "",
     raw_ml_system: Boolean = false,
     use_prelude: List[String] = Nil,
     eval_main: String = "",
     args: List[String] = Nil,
     modes: List[String] = Nil,
     cwd: JFile = null,
     env: JMap[String, String] = Isabelle_System.settings(),
     redirect: Boolean = false,
-    cleanup: () => Unit = () => (),
-    session_base: Option[Sessions.Base] = None
+    cleanup: () => Unit = () => ()
   ): Bash.Process = {
     val logic_name = Isabelle_System.default_logic(logic)
 
     val heaps: List[String] =
       if (raw_ml_system) Nil
       else {
-        sessions_structure.selection(logic_name).
+        base_info.sessions_structure.selection(logic_name).
           build_requirements(List(logic_name)).
           map(a => File.platform_path(store.the_heap(a)))
       }
 
     val eval_init =

     val eval_options = if (heaps.isEmpty) Nil else List("Options.load_default ()")
     val isabelle_process_options = Isabelle_System.tmp_file("options")
     Isabelle_System.chmod("600", File.path(isabelle_process_options))
     File.write(isabelle_process_options, YXML.string_of_body(options.encode))
 
-    // session base
-    val (init_session_base, eval_init_session) =
-      session_base match {
-        case None => (Sessions.Base.bootstrap, Nil)
-        case Some(base) => (base, List("Resources.init_session_env ()"))
-      }
+    // session resources
+    val eval_init_session = if (raw_ml_system) Nil else List("Resources.init_session_env ()")
     val init_session = Isabelle_System.tmp_file("init_session")
     Isabelle_System.chmod("600", File.path(init_session))
-    File.write(init_session, new Resources(sessions_structure, init_session_base).init_session_yxml)
+    val resources = new Resources(base_info.sessions_structure, base_info.base)
+    File.write(init_session, resources.init_session_yxml)
 
     // process
     val eval_process =
       proper_string(eval_main).getOrElse(
         if (heaps.isEmpty) {

       if (args.isEmpty || more_args.nonEmpty) getopts.usage()
 
       val base_info = Sessions.base_info(options, logic, dirs = dirs).check_errors
       val store = Sessions.store(options)
       val result =
-        ML_Process(options, base_info.sessions_structure, store, logic = logic, args = eval_args,
-          modes = modes, session_base = Some(base_info.base)).result(
+        ML_Process(options, base_info, store, logic = logic, args = eval_args, modes = modes)
+          .result(
             progress_stdout = Output.writeln(_, stdout = true),
             progress_stderr = Output.writeln(_))
 
       sys.exit(result.rc)
     })