src/Pure/Build/build_manager.scala

     sessions: List[String] = Nil,
     build_heap: Boolean = false,
     clean_build: Boolean = false,
     export_files: Boolean = false,
     fresh_build: Boolean = false,
-    presentation: Boolean = false
+    presentation: Boolean = false,
+    verbose: Boolean = false
   ) extends Build_Config {
     def name: String = User_Build.name
     def components: List[Component] = afp_rev.map(Component.AFP).toList
     def command(build_hosts: List[Build_Cluster.Host]): String = {
       " build" +

         if_proper(build_heap, " -b") +
         if_proper(clean_build, " -c") +
         if_proper(export_files, " -e") +
         if_proper(fresh_build, " -f") +
         Options.Spec.bash_strings(prefs, bg = true) +
-        " -v" +
+        if_proper(verbose, " -v") +
         sessions.map(session => " " + Bash.string(session)).mkString
     }
   }
 
   enum Priority { case low, normal, high }

       val build_heap = SQL.Column.bool("build_heap")
       val clean_build = SQL.Column.bool("clean_build")
       val export_files = SQL.Column.bool("export_files")
       val fresh_build = SQL.Column.bool("fresh_build")
       val presentation = SQL.Column.bool("presentation")
+      val verbose = SQL.Column.bool("verbose")
 
       val table =
         make_table(List(kind, id, submit_date, priority, isabelle_rev, components, prefs,
           requirements, all_sessions, base_sessions, exclude_session_groups, exclude_sessions,
           session_groups, sessions, build_heap, clean_build, export_files, fresh_build,
-          presentation),
+          presentation, verbose),
         name = "pending")
     }
 
     def pull_pending(db: SQL.Database): Build_Manager.State.Pending =
       db.execute_query_statement(Pending.table.select(), Map.from[String, Task], get =

               val build_heap = res.bool(Pending.build_heap)
               val clean_build = res.bool(Pending.clean_build)
               val export_files = res.bool(Pending.export_files)
               val fresh_build = res.bool(Pending.fresh_build)
               val presentation = res.bool(Pending.presentation)
+              val verbose = res.bool(Pending.verbose)
 
               val afp_rev = components.find(_.name == Component.AFP().name).map(_.rev)
               User_Build(afp_rev, prefs, requirements, all_sessions, base_sessions,
                 exclude_session_groups, exclude_sessions, session_groups, sessions, build_heap,
-                clean_build, export_files, fresh_build, presentation)
+                clean_build, export_files, fresh_build, presentation, verbose)
             }
 
           val task = Task(build_config, UUID.make(id), submit_date, priority, isabelle_rev)
 
           task.name -> task

             stmt.bool(15) = get(_.build_heap)
             stmt.bool(16) = get(_.clean_build)
             stmt.bool(17) = get(_.export_files)
             stmt.bool(18) = get(_.fresh_build)
             stmt.bool(19) = get(_.presentation)
+            stmt.bool(20) = get(_.verbose)
           })
       }
 
       update
     }

     fresh_build: Boolean = false,
     session_groups: List[String] = Nil,
     sessions: List[String] = Nil,
     prefs: List[Options.Spec] = Nil,
     exclude_sessions: List[String] = Nil,
+    verbose: Boolean = false,
     rev: String = "",
     progress: Progress = new Progress
   ): UUID.T = {
     val id = UUID.random()
     val afp_rev = if (afp_root.nonEmpty) Some("") else None
 
     val build_config = User_Build(afp_rev, prefs, requirements, all_sessions, base_sessions,
       exclude_session_groups, exclude_sessions, session_groups, sessions, build_heap, clean_build,
-      export_files, fresh_build, presentation)
+      export_files, fresh_build, presentation, verbose)
     val task = Task(build_config, id, Date.now(), Priority.high)
 
     val context = Context(store, task)
 
     progress.interrupt_handler {

       var export_files = false
       var fresh_build = false
       val session_groups = new mutable.ListBuffer[String]
       var options = Options.init(specs = Options.Spec.ISABELLE_BUILD_OPTIONS)
       var prefs: List[Options.Spec] = Nil
+      var verbose = false
       var rev = ""
       val exclude_sessions = new mutable.ListBuffer[String]
 
       val getopts = Getopts("""
 Usage: isabelle build_task [OPTIONS] [SESSIONS ...]

     -f           fresh build
     -g NAME      select session group NAME
     -o OPTION    override Isabelle system OPTION (via NAME=VAL or NAME)
     -p OPTIONS   comma-separated preferences for build process
     -r REV       explicit revision (default: state of working directory)
+    -v           verbose
     -x NAME      exclude session NAME and all descendants
 
   Submit build task on SSH server. Notable system options:
 
 """ + Library.indent_lines(2, show_options(notable_client_options, options)) + "\n",

         "f" -> (_ => fresh_build = true),
         "g:" -> (arg => session_groups += arg),
         "o:" -> (arg => options = options + arg),
         "p:" -> (arg => prefs = Options.Spec.parse(arg)),
         "r:" -> (arg => rev = arg),
+        "v" -> (_ => verbose = true),
         "x:" -> (arg => exclude_sessions += arg))
 
       val sessions = getopts(args)
       val store = Store(options)
       val progress = new Console_Progress()

       build_task(options, store = store, afp_root = afp_root, base_sessions =
         base_sessions.toList, presentation = presentation, requirements = requirements,
         exclude_session_groups = exclude_session_groups.toList, all_sessions = all_sessions,
         build_heap = build_heap, clean_build = clean_build, export_files = export_files,
         fresh_build = fresh_build, session_groups = session_groups.toList, sessions = sessions,
-        prefs = prefs, rev = rev, exclude_sessions = exclude_sessions.toList, progress = progress)
+        prefs = prefs, verbose = verbose, rev = rev, exclude_sessions = exclude_sessions.toList,
+        progress = progress)
     })
 }
 
 class Build_Manager_Tools extends Isabelle_Scala_Tools(
   Build_Manager.isabelle_tool, Build_Manager.isabelle_tool1)