diff --git a/modules/ksb/Application.pm b/modules/ksb/Application.pm
index 8fbab25..d77e238 100644
--- a/modules/ksb/Application.pm
+++ b/modules/ksb/Application.pm
@@ -1,2327 +1,2327 @@
 package ksb::Application 0.20;
 
 # Class: Application
 #
 # Contains the application-layer logic (i.e. creating a build context, reading
 # options, parsing command-line, etc.)
 
 use strict;
 use warnings;
 use 5.014;
 no if $] >= 5.018, 'warnings', 'experimental::smartmatch';
 
 use ksb::Debug 0.30;
 use ksb::Util;
 use ksb::BuildContext 0.35;
 use ksb::BuildSystem::QMake;
 use ksb::BuildException 0.20;
 use ksb::Module;
 use ksb::ModuleResolver 0.20;
 use ksb::ModuleSet 0.20;
 use ksb::ModuleSet::KDEProjects;
 use ksb::OSSupport;
 use ksb::PromiseChain;
 use ksb::RecursiveFH;
 use ksb::DependencyResolver 0.20;
 use ksb::Updater::Git;
 use ksb::Version qw(scriptVersion);
 
 use Mojo::IOLoop;
 use Mojo::Promise;
 
 use Fcntl; # For sysopen
 use List::Util qw(first min);
 use File::Basename; # basename, dirname
 use File::Glob ':glob';
 use POSIX qw(:sys_wait_h _exit :errno_h);
 use Getopt::Long qw(GetOptionsFromArray :config gnu_getopt nobundling);
 use IO::Handle;
 use IO::Select;
 
 ### Package-specific variables (not shared outside this file).
 
 use constant {
     # We use a named remote to make some git commands work that don't accept the
     # full path.
     KDE_PROJECT_ID   => 'kde-projects',          # git-repository-base for kde_projects.xml
 };
 
 ### Package methods
 
 sub new
 {
     my ($class, @options) = @_;
 
     my $self = bless {
         context         => ksb::BuildContext->new(),
         metadata_module => undef,
         run_mode        => 'build',
         modules         => undef,
         module_resolver => undef, # ksb::ModuleResolver but see below
         _base_pid       => $$, # See finish()
     }, $class;
 
     # Default to colorized output if sending to TTY
     ksb::Debug::setColorfulOutput(-t STDOUT);
 
     return $self;
 }
 
 # Call after establishContext (to read in config file and do one-time metadata
 # reading).
 #
 # Need to call this before you call startHeadlessBuild
 sub setModulesToProcess
 {
     my ($self, @modules) = @_;
     $self->{modules} = \@modules;
 
     $self->context()->addModule($_)
         foreach @modules;
 
     # i.e. niceness, ulimits, etc.
     $self->context()->setupOperatingEnvironment();
 }
 
 # Sets the application to be non-interactive, intended to make this suitable as
 # a backend for a Mojolicious-based web server with a separate U/I.
 sub setHeadless
 {
     my $self = shift;
     $self->{run_mode} = 'headless';
     return $self;
 }
 
 # Method: _readCommandLineOptionsAndSelectors
 #
 # Returns a list of module/module-set selectors, selected module/module-set
 # options, and global options, based on the command-line arguments passed to
 # this function.
 #
 # This is a package method, should be called as
 # $app->_readCommandLineOptionsAndSelectors
 #
 # Phase:
 #  initialization - Do not call <finish> from this function.
 #
 # Parameters:
 #  cmdlineOptions - hashref to hold parsed modules options to be applied later.
 #    *Note* this must be done separately, it is not handled by this subroutine.
 #    Global options will be stored in a hashref at $cmdlineOptions->{global}.
 #    Module or module-set options will be stored in a hashref at
 #    $cmdlineOptions->{$moduleName} (it will be necessary to disambiguate
 #    later in the run whether it is a module set or a single module).
 #
 #    If the global option 'start-program' is set, then the program to start and
 #    its options will be found in a listref pointed to under the
 #    'start-program' option.
 #
 #  selectors - listref to hold the list of module or module-set selectors to
 #    build, in the order desired by the user. These will just be strings, the
 #    caller will have to figure out whether the selector is a module or
 #    module-set, and create any needed objects, and then set the recommended
 #    options as listed in cmdlineOptions.
 #
 #  ctx - <BuildContext> to hold the global build state.
 #
 #  @options - The remainder of the arguments are treated as command line
 #    arguments to process.
 #
 # Returns:
 #  Nothing. An exception will be raised on failure, or this function may quit
 #  the program directly (e.g. to handle --help, --usage).
 sub _readCommandLineOptionsAndSelectors
 {
     my $self = shift;
     my ($cmdlineOptionsRef, $selectorsRef, $ctx, @options) = @_;
     my $phases = $ctx->phases();
     my @savedOptions = @options; # Copied for use in debugging.
     my $os = ksb::OSSupport->new;
     my $version = "kdesrc-build " . scriptVersion();
     my $author = <<DONE;
 $version was written (mostly) by:
   Michael Pyne <mpyne\@kde.org>
 
 Many people have contributed code, bugfixes, and documentation.
 
 Please report bugs using the KDE Bugzilla, at https://bugs.kde.org/
 DONE
 
     # Getopt::Long will store options in %foundOptions, since that is what we
     # pass in. To allow for custom subroutines to handle an option it is
     # required that the sub *also* be in %foundOptions... whereupon it will
     # promptly be overwritten if we're not careful. Instead we let the custom
     # subs save to %auxOptions, and read those in back over it later.
     my (%foundOptions, %auxOptions);
     %foundOptions = (
         version => sub { say $version; exit },
         author  => sub { say $author;  exit },
         'show-info' => sub { say $version; say "OS: ", $os->vendorID(); exit },
         help    => sub { _showHelpMessage(); exit 0 },
         install => sub {
             $self->{run_mode} = 'install';
             $phases->phases('install');
         },
         uninstall => sub {
             $self->{run_mode} = 'uninstall';
             $phases->phases('uninstall');
         },
         'no-src' => sub {
             $phases->filterOutPhase('update');
         },
         'no-install' => sub {
             $phases->filterOutPhase('install');
         },
         'no-tests' => sub {
             # The "right thing" to do
             $phases->filterOutPhase('test');
 
             # What actually works at this point.
             $foundOptions{'run-tests'} = 0;
         },
         'no-build' => sub {
             $phases->filterOutPhase('build');
         },
         # Mostly equivalent to the above
         'src-only' => sub {
             $phases->phases('update');
 
             # We have an auto-switching function that we only want to run
             # if --src-only was passed to the command line, so we still
             # need to set a flag for it.
             $foundOptions{'allow-auto-repo-move'} = 1;
         },
         'build-only' => sub {
             $phases->phases('build');
         },
         'install-only' => sub {
             $self->{run_mode} = 'install';
             $phases->phases('install');
         },
         prefix => sub {
             my ($optName, $arg) = @_;
             $auxOptions{prefix} = $arg;
             $foundOptions{kdedir} = $arg; #TODO: Still needed for compat?
             $foundOptions{reconfigure} = 1;
         },
         query => sub {
             my (undef, $arg) = @_;
 
             my $validMode = qr/^[a-zA-Z0-9_][a-zA-Z0-9_-]*$/;
             die("Invalid query mode $arg")
                 unless $arg =~ $validMode;
 
             # Add useful aliases
             $arg = 'source-dir'  if $arg =~ /^src-?dir$/;
             $arg = 'build-dir'   if $arg =~ /^build-?dir$/;
             $arg = 'install-dir' if $arg eq 'prefix';
 
             $self->{run_mode} = 'query';
             $auxOptions{query} = $arg;
             $auxOptions{pretend} = 1; # Implied pretend mode
         },
         pretend => sub {
             # Set pretend mode but also force the build process to run.
             $auxOptions{pretend} = 1;
             $foundOptions{'build-when-unchanged'} = 1;
         },
         resume => sub {
             $auxOptions{resume} = 1;
             $phases->filterOutPhase('update'); # Implied --no-src
             $foundOptions{'no-metadata'} = 1;  # Implied --no-metadata
         },
         verbose => sub { $foundOptions{'debug-level'} = ksb::Debug::WHISPER },
         quiet => sub { $foundOptions{'debug-level'} = ksb::Debug::NOTE },
         'really-quiet' => sub { $foundOptions{'debug-level'} = ksb::Debug::WARNING },
         debug => sub {
             $foundOptions{'debug-level'} = ksb::Debug::DEBUG;
             debug ("Commandline was: ", join(', ', @savedOptions));
         },
 
         # Hack to set module options
         'set-module-option-value' => sub {
             my ($optName, $arg) = @_;
             my ($module, $option, $value) = split (',', $arg, 3);
             if ($module && $option) {
                 $cmdlineOptionsRef->{$module} //= { };
                 $cmdlineOptionsRef->{$module}->{$option} = $value;
             }
         },
 
         # Getopt::Long doesn't set these up for us even though we specify an
         # array. Set them up ourselves.
         'start-program' => [ ],
         'ignore-modules' => [ ],
 
         # Module selectors, the <> is Getopt::Long shortcut for an
         # unrecognized non-option value (i.e. an actual argument)
         '<>' => sub {
             my $arg = shift;
             push @{$selectorsRef}, $arg;
         },
     );
 
     # Handle any "cmdline-eligible" options not already covered.
     my $flagHandler = sub {
         my ($optName, $optValue) = @_;
 
         # Assume to set if nothing provided.
         $optValue = 1 if (!defined $optValue or $optValue eq '');
         $optValue = 0 if lc($optValue) eq 'false';
         $optValue = 0 if !$optValue;
 
         $auxOptions{$optName} = $optValue;
     };
 
     foreach my $option (keys %ksb::BuildContext::defaultGlobalFlags) {
         if (!exists $foundOptions{$option}) {
             $foundOptions{$option} = $flagHandler; # A ref to a sub here!
         }
     }
 
     # Actually read the options.
     my $optsSuccess = GetOptionsFromArray(\@options, \%foundOptions,
         'version', 'author', 'help', 'show-info', 'disable-snapshots|no-snapshots',
         'install', 'uninstall', 'no-src|no-svn', 'no-install', 'no-build',
         'no-tests', 'build-when-unchanged|force-build', 'no-metadata',
         'verbose|v', 'quiet|quite|q', 'really-quiet', 'debug',
         'reconfigure', 'colorful-output|color!',
         'src-only|svn-only', 'build-only', 'install-only', 'build-system-only',
         'rc-file=s', 'prefix=s', 'niceness|nice:10', 'ignore-modules=s{,}',
         'print-modules', 'pretend|dry-run|p', 'refresh-build',
         'query=s', 'start-program|run=s{,}',
         'launch-browser',
         'revision=i', 'resume-from=s', 'resume-after=s',
         'rebuild-failures', 'resume', 'stop-on-failure',
         'stop-after=s', 'stop-before=s', 'set-module-option-value=s',
         'metadata-only', 'include-dependencies',
 
         # Special sub used (see above), but have to tell Getopt::Long to look
         # for strings
         (map { "$_:s" } (keys %ksb::BuildContext::defaultGlobalFlags)),
 
         # Default handling fine, still have to ask for strings.
         (map { "$_:s" } (keys %ksb::BuildContext::defaultGlobalOptions)),
 
         '<>', # Required to read non-option args
         );
 
     if (!$optsSuccess) {
         croak_runtime("Error reading command-line options.");
     }
 
     # To store the values we found, need to strip out the values that are
     # subroutines, as those are the ones we created. Alternately, place the
     # subs inline as an argument to the appropriate option in the
     # GetOptionsFromArray call above, but that's ugly too.
     my @readOptionNames = grep {
         ref($foundOptions{$_}) ne 'CODE'
     } (keys %foundOptions);
 
     # Slice assignment: $left{$key} = $right{$key} foreach $key (@keys), but
     # with hashref syntax everywhere.
     @{ $cmdlineOptionsRef->{'global'} }{@readOptionNames}
         = @foundOptions{@readOptionNames};
 
     @{ $cmdlineOptionsRef->{'global'} }{keys %auxOptions}
         = values %auxOptions;
 }
 
 # Generates the build context, builds various module, dependency and branch
 # group resolvers, and splits up the provided option/selector mix read from
 # cmdline into selectors (returned to caller, if any) and pre-built context and
 # resolvers.
 #
 # Use "modulesFromSelectors" to further generate the list of ksb::Modules in
 # dependency order.
 #
 # After this function is called all module set selectors will have been
 # expanded, and we will have downloaded kde-projects metadata.
 #
 # Returns: List of Selectors to build.
 sub establishContext
 {
     my $self = shift;
     my @argv = @_;
 
     # Note: Don't change the order around unless you're sure of what you're
     # doing.
 
     my $ctx = $self->context();
     my $cmdlineOptions = { global => { }, };
     my $cmdlineGlobalOptions = $cmdlineOptions->{global};
     my $deferredOptions = { }; # 'options' blocks
 
     # Process --help, --install, etc. first.
     my @selectors;
     $self->_readCommandLineOptionsAndSelectors($cmdlineOptions, \@selectors,
         $ctx, @argv);
 
     # Convert list to hash for lookup
     my %ignoredSelectors =
         map { $_, 1 } @{$cmdlineGlobalOptions->{'ignore-modules'}};
 
     my @startProgramAndArgs = @{$cmdlineGlobalOptions->{'start-program'}};
     delete @{$cmdlineGlobalOptions}{qw/ignore-modules start-program/};
 
     # rc-file needs special handling.
     if (exists $cmdlineGlobalOptions->{'rc-file'} && $cmdlineGlobalOptions->{'rc-file'}) {
         $ctx->setRcFile($cmdlineGlobalOptions->{'rc-file'});
     }
 
     my $fh = $ctx->loadRcFile();
     $ctx->loadPersistentOptions();
 
     if (exists $cmdlineGlobalOptions->{'resume'}) {
         my $moduleList = $ctx->getPersistentOption('global', 'resume-list');
         if (!$moduleList) {
             error ("b[--resume] specified, but unable to find resume point!");
             error ("Perhaps try b[--resume-from] or b[--resume-after]?");
             croak_runtime("Invalid --resume flag");
         }
 
         unshift @selectors, split(/,\s*/, $moduleList);
     }
 
     if (exists $cmdlineGlobalOptions->{'rebuild-failures'}) {
         my $moduleList = $ctx->getPersistentOption('global', 'last-failed-module-list');
         if (!$moduleList) {
             error ("b[y[--rebuild-failures] was specified, but unable to determine");
             error ("which modules have previously failed to build.");
             croak_runtime("Invalid --rebuild-failures flag");
         }
 
         unshift @selectors, split(/,\s*/, $moduleList);
     }
 
     # _readConfigurationOptions will add pending global opts to ctx while ensuring
     # returned modules/sets have any such options stripped out. It will also add
     # module-specific options to any returned modules/sets.
     my @optionModulesAndSets = _readConfigurationOptions($ctx, $fh, $deferredOptions);
     close $fh;
 
     # Check if we're supposed to drop into an interactive shell instead.  If so,
     # here's the stop off point.
 
     if (@startProgramAndArgs) {
         $ctx->setupEnvironment(); # Read options from set-env
         $ctx->commitEnvironmentChanges(); # Apply env options to environment
         _executeCommandLineProgram(@startProgramAndArgs); # noreturn
     }
 
     # Everything else in cmdlineOptions should be OK to apply directly as a module
     # or context option.
     $ctx->setOption(%{$cmdlineGlobalOptions});
 
     # Selecting modules or module sets would requires having the KDE
     # build metadata (kde-build-metadata and sysadmin/repo-metadata)
     # available.
     $ctx->setKDEDependenciesMetadataModuleNeeded();
     $ctx->setKDEProjectsMetadataModuleNeeded();
 
     if (!exists $ENV{HARNESS_ACTIVE}) {
         # Running in a test harness, avoid downloading metadata which will be
         # ignored in the test or making changes to git config
         ksb::Updater::Git::verifyGitConfig();
         $self->_downloadKDEProjectMetadata();
     }
 
     # The user might only want metadata to update to allow for a later
     # --pretend run, check for that here.
     if (exists $cmdlineGlobalOptions->{'metadata-only'}) {
         return;
     }
 
     # At this point we have our list of candidate modules / module-sets (as read in
     # from rc-file). The module sets have not been expanded into modules.
     # We also might have cmdline "selectors" to determine which modules or
     # module-sets to choose. First let's select module sets, and expand them.
 
     my @globalCmdlineArgs = keys %{$cmdlineGlobalOptions};
     my $commandLineModules = scalar @selectors;
 
     my $moduleResolver
         = $self->{module_resolver}
         = ksb::ModuleResolver->new($ctx);
     $moduleResolver->setCmdlineOptions($cmdlineOptions);
     $moduleResolver->setDeferredOptions($deferredOptions);
     $moduleResolver->setInputModulesAndOptions(\@optionModulesAndSets);
     $moduleResolver->setIgnoredSelectors([keys %ignoredSelectors]);
 
     return @selectors;
 }
 
 # Requires establishContext to have been called first. Converts string-based
 # "selectors" for modules or module-sets into a list of ksb::Modules (only
 # modules, no sets).
 #
 # After this function is called all module set selectors will have been
 # expanded, and we will have downloaded kde-projects metadata.
 #
 # The modules returns must still be added (using setModulesToProcess) to the
 # context if you intend to build. This is a separate step to allow for some
 # introspection prior to making choice to build.
 #
 # Returns: List of Modules to build.
 sub modulesFromSelectors
 {
     my ($self, @selectors) = @_;
     my $moduleResolver = $self->{module_resolver};
     my $ctx = $self->context();
 
     my @modules;
     if (@selectors) {
         @modules = $moduleResolver->resolveSelectorsIntoModules(@selectors);
 
         ksb::Module->setModuleSource('cmdline');
     }
     else {
         # Build everything in the rc-file, in the order specified.
         my @rcfileModules = @{$moduleResolver->{inputModulesAndOptions}};
         @modules = $moduleResolver->expandModuleSets(@rcfileModules);
 
         ksb::Module->setModuleSource('config');
     }
 
     # If modules were on the command line then they are effectively forced to
     # process unless overridden by command line options as well. If phases
     # *were* overridden on the command line, then no update pass is required
     # (all modules already have correct phases)
     @modules = _updateModulePhases(@modules)
         unless @selectors;
 
     # TODO: Verify this does anything still
     my $metadataModule = $ctx->getKDEDependenciesMetadataModule();
     $ctx->addToIgnoreList($metadataModule->scm()->ignoredModules());
 
     # Remove modules that are explicitly blanked out in their branch-group
     # i.e. those modules where they *have* a branch-group, and it's set to
     # be empty ("").
     my $resolver = $ctx->moduleBranchGroupResolver();
     my $branchGroup = $ctx->effectiveBranchGroup();
 
     @modules = grep {
         my $branch = $_->isKDEProject()
             ? $resolver->findModuleBranch($_->fullProjectPath(), $branchGroup)
             : 1; # Just a placeholder truthy value
         whisper ("Removing ", $_->fullProjectPath(), " due to branch-group") if (defined $branch and !$branch);
         (!defined $branch or $branch); # This is the actual test
     } (@modules);
 
     @modules = $self->_resolveModuleDependencies(@modules);
 
     # Filter --resume-foo options. This might be a second pass, but that should
     # be OK since there's nothing different going on from the first pass (in
     # resolveSelectorsIntoModules) in that event.
     @modules = _applyModuleFilters($ctx, @modules);
 
     return @modules;
 }
 
 # Causes kde-projects metadata to be downloaded (unless --pretend, --no-src, or
 # --no-metadata is in effect, although we'll download even in --pretend if
 # nothing is available).
 #
 # No return value.
 sub _downloadKDEProjectMetadata
 {
     my $self = shift;
     my $ctx = $self->context();
     my $updateStillNeeded = 0;
 
     my $wasPretending = pretending();
 
     eval {
         for my $metadataModule (
             $ctx->getKDEDependenciesMetadataModule(),
             $ctx->getKDEProjectsMetadataModule())
         {
             my $sourceDir = $metadataModule->getSourceDir();
             super_mkdir($sourceDir);
 
             my $moduleSource = $metadataModule->fullpath('source');
             my $updateDesired = !$ctx->getOption('no-metadata') && $ctx->phases()->has('update');
             my $updateNeeded = (! -e $moduleSource) || is_dir_empty($moduleSource);
             my $lastUpdate = $ctx->getPersistentOption('global', 'last-metadata-update') // 0;
 
             $updateStillNeeded ||= $updateNeeded;
 
             if (!$updateDesired && $updateNeeded && (time - ($lastUpdate)) >= 7200) {
                 warning (" r[b[*] Skipping build metadata update, but it hasn't been updated recently!");
             }
 
             if ($updateNeeded && pretending()) {
                 warning (" y[b[*] Ignoring y[b[--pretend] option to download required metadata\n" .
                          " y[b[*] --pretend mode will resume after metadata is available.");
                 ksb::Debug::setPretending(0);
             }
 
             if ($updateDesired && (!pretending() || $updateNeeded)) {
                 $metadataModule->scm()->updateInternal();
                 $ctx->setPersistentOption('global', 'last-metadata-update', time);
             }
 
             ksb::Debug::setPretending($wasPretending);
         }
     };
 
     my $err = $@;
 
     ksb::Debug::setPretending($wasPretending);
 
     if ($err) {
         die $err if $updateStillNeeded;
 
         # Assume previously-updated metadata will work if not updating
         warning (" b[r[*] Unable to download required metadata for build process");
         warning (" b[r[*] Will attempt to press onward...");
         warning (" b[r[*] Exception message: $@");
     }
 }
 
 # Returns a list of Modules in the proper build order according to the
 # kde-build-metadata dependency information.
 #
 # The kde-build-metadata repository must have already been updated, and the
 # module factory must be setup. The Modules to reorder must be passed as
 # arguments.
 sub _resolveModuleDependencies
 {
     my $self = shift;
     my $ctx = $self->context();
     my $metadataModule = $ctx->getKDEDependenciesMetadataModule();
     my @modules = @_;
 
     @modules = eval {
         my $moduleResolver = $self->{module_resolver};
         my $dependencyResolver = ksb::DependencyResolver->new(sub {
             # Maps module names (what dep resolver has) to built ksb::Modules
             # (which we need), needs to include all option handling (cmdline,
             # rc-file, module-sets, etc)
             return $moduleResolver->resolveModuleIfPresent(shift);
         });
         my $branchGroup = $ctx->effectiveBranchGroup();
 
         for my $file ('dependency-data-common', "dependency-data-$branchGroup")
         {
             my $dependencyFile = $metadataModule->fullpath('source') . "/$file";
             my $dependencies = pretend_open($dependencyFile)
                 or die "Unable to open $dependencyFile: $!";
 
             debug (" -- Reading dependencies from $dependencyFile");
             $dependencyResolver->readDependencyData($dependencies);
             close $dependencies;
         }
 
         my @reorderedModules = $dependencyResolver->resolveDependencies(@modules);
         return @reorderedModules;
     };
 
     if ($@) {
         warning (" r[b[*] Problems encountered trying to sort modules into correct order:");
         warning (" r[b[*] $@");
         warning (" r[b[*] Will attempt to continue.");
     }
 
     return @modules;
 }
 
 # Similar to the old interactive runAllModulePhases. Actually performs the
 # build for the modules selected by setModulesToProcess.
 #
 # Returns a Mojo::Promise that must be waited on. The promise resolves to
 # return a single success/failure result; use the event handler for now to get
 # more detail during a build.
 sub startHeadlessBuild
 {
     my $self = shift;
     my $ctx = $self->context();
     $ctx->statusMonitor()->createBuildPlan($ctx);
 
     my $promiseChain = ksb::PromiseChain->new;
     my $startPromise = Mojo::Promise->new;
 
     # These succeed or die outright
     $startPromise = _handle_updates ($ctx, $promiseChain, $startPromise);
     $startPromise = _handle_build   ($ctx, $promiseChain, $startPromise);
 
     die "Can't obtain build lock" unless $ctx->takeLock();
 
     # Install signal handlers to ensure that the lockfile gets closed.
     _installSignalHandlers(sub {
         note ("Signal received, terminating.");
         @main::atexit_subs = (); # Remove their finish, doin' it manually
         $self->finish(5);
     });
 
     $startPromise->resolve; # allow build to start
     my $promise = $promiseChain->makePromiseChain($startPromise)->finally(sub {
         my @results = @_;
         my $result = 0; # success, non-zero is failure
 
         # Must use ! here to make '0 but true' hack work
         $result = 1 if defined first { !($_->[0] // 1) } @results;
 
         $ctx->statusMonitor()->markBuildDone();
         $ctx->closeLock();
 
         my $failedModules = join(',', map { "$_" } $ctx->listFailedModules());
         if ($failedModules) {
             # We don't clear the list of failed modules on success so that
             # someone can build one or two modules and still use
             # --rebuild-failures
             $ctx->setPersistentOption('global', 'last-failed-module-list', $failedModules);
         }
 
         $ctx->storePersistentOptions();
         _cleanup_log_directory($ctx);
 
         return $result;
     });
 
     return $promise;
 }
 
 # Method: finish
 #
 # Exits the script cleanly, including removing any lock files created.
 #
 # Parameters:
 #  ctx - Required; BuildContext to use.
 #  [exit] - Optional; if passed, is used as the exit code, otherwise 0 is used.
 sub finish
 {
     my $self = shift;
     my $ctx = $self->context();
     my $exitcode = shift // 0;
 
     if (pretending() || $self->{_base_pid} != $$) {
         # Abort early if pretending or if we're not the same process
         # that was started by the user (for async mode)
         exit $exitcode;
     }
 
     $ctx->closeLock();
     $ctx->storePersistentOptions();
 
     my $logdir = $ctx->getLogDir();
     note ("Your logs are saved in y[$logdir]");
 
     exit $exitcode;
 }
 
 ### Package-internal helper functions.
 
 # Reads a "line" from a file. This line is stripped of comments and extraneous
 # whitespace. Also, backslash-continued multiple lines are merged into a single
 # line.
 #
 # First parameter is the reference to the filehandle to read from.
 # Returns the text of the line.
 sub _readNextLogicalLine
 {
     my $fileReader = shift;
 
     while($_ = $fileReader->readLine()) {
         # Remove trailing newline
         chomp;
 
         # Replace \ followed by optional space at EOL and try again.
         if(s/\\\s*$//)
         {
             $_ .= $fileReader->readLine();
             redo;
         }
 
         s/#.*$//;        # Remove comments
         next if /^\s*$/; # Skip blank lines
 
         return $_;
     }
 
     return undef;
 }
 
 # Takes an input line, and extracts it into an option name, and simplified
 # value. The value has "false" converted to 0, white space simplified (like in
 # Qt), and tildes (~) in what appear to be path-like entries are converted to
 # the home directory path.
 #
 # First parameter is the build context (used for translating option values).
 # Second parameter is the line to split.
 # Return value is (option-name, option-value)
 sub _splitOptionAndValue
 {
     my $ctx = assert_isa(shift, 'ksb::BuildContext');
     my $input = shift;
     my $optionRE = qr/\$\{([a-zA-Z0-9-]+)\}/;
 
     # The option is the first word, followed by the
     # flags on the rest of the line.  The interpretation
     # of the flags is dependant on the option.
     my ($option, $value) = ($input =~ /^\s*     # Find all spaces
                             ([-\w]+) # First match, alphanumeric, -, and _
                             # (?: ) means non-capturing group, so (.*) is $value
                             # So, skip spaces and pick up the rest of the line.
                             (?:\s+(.*))?$/x);
 
     $value //= '';
 
     # Simplify whitespace.
     $value =~ s/\s+$//;
     $value =~ s/^\s+//;
     $value =~ s/\s+/ /g;
 
     # Check for false keyword and convert it to Perl false.
     $value = 0 if lc($value) eq 'false';
 
     # Replace reference to global option with their value.
     # The regex basically just matches ${option-name}.
     my ($sub_var_name) = ($value =~ $optionRE);
     while ($sub_var_name)
     {
         my $sub_var_value = $ctx->getOption($sub_var_name) || '';
         if(!$ctx->hasOption($sub_var_name)) {
             warning (" *\n * WARNING: $sub_var_name is not set at line y[$.]\n *");   ## TODO: filename is missing
         }
 
         debug ("Substituting \${$sub_var_name} with $sub_var_value");
 
         $value =~ s/\$\{$sub_var_name\}/$sub_var_value/g;
 
         # Replace other references as well.  Keep this RE up to date with
         # the other one.
         ($sub_var_name) = ($value =~ $optionRE);
     }
 
     # Replace tildes with home directory.
     1 while ($value =~ s"(^|:|=)~/"$1$ENV{'HOME'}/");
 
     return ($option, $value);
 }
 
 # Ensures that the given ModuleSet has at least a valid repository and
 # use-modules setting based on the given BuildContext.
 sub _validateModuleSet
 {
     my ($ctx, $moduleSet) = @_;
     my $name = $moduleSet->name() || 'unnamed';
     my $rcSources = _getModuleSources($moduleSet);
 
     # re-read option from module set since it may be pre-set
     my $selectedRepo = $moduleSet->getOption('repository');
     if (!$selectedRepo) {
         error (<<EOF);
 
 There was no repository selected for the y[b[$name] module-set declared at
     $rcSources
 
 A repository is needed to determine where to download the source code from.
 
 Most will want to use the b[g[kde-projects] repository. See also
 https://docs.kde.org/trunk5/en/extragear-utils/kdesrc-build/kde-modules-and-selection.html#module-sets
 EOF
         die make_exception('Config', 'Missing repository option');
     }
 
     my $repoSet = $ctx->getOption('git-repository-base');
     if ($selectedRepo ne KDE_PROJECT_ID &&
         not exists $repoSet->{$selectedRepo})
     {
         my $projectID = KDE_PROJECT_ID;
         my $moduleSetName = $moduleSet->name();
         my $moduleSetId = $moduleSetName ? "module-set ($moduleSetName)"
                                          : "module-set";
 
         error (<<EOF);
 There is no repository assigned to y[b[$selectedRepo] when assigning a
 $moduleSetId at $rcSources.
 
 These repositories are defined by g[b[git-repository-base] in the global
 section of your configuration.
 
 Make sure you spelled your repository name right, but you probably meant
 to use the magic b[$projectID] repository for your module-set instead.
 EOF
 
         die make_exception('Config', 'Unknown repository base');
     }
 }
 
 # Reads in the options from the config file and adds them to the option store.
 # The first parameter is a BuildContext object to use for creating the returned
 #     ksb::Module under.
 # The second parameter is a reference to the file handle to read from.
 # The third parameter is the ksb::OptionsBase to use (module, module-set, ctx,
 #     etc.)
 #     For global options, just pass in the BuildContext for this param.
 # The fourth parameter is optional, if provided it should be a regexp for the
 #     terminator to use for the block being parsed in the rc file.
 #
 # The return value is the ksb::OptionsBase provided, with options set as given in
 # the configuration file section being processed.
 sub _parseModuleOptions
 {
     my ($ctx, $fileReader, $module, $endRE) = @_;
     assert_isa($ctx, 'ksb::BuildContext');
     assert_isa($module, 'ksb::OptionsBase');
 
     my $endWord = $module->isa('ksb::BuildContext') ? 'global'     :
                   $module->isa('ksb::ModuleSet')    ? 'module-set' :
                   $module->isa('ksb::Module')       ? 'module'     :
                                                       'options';
 
     # Just look for an end marker if terminator not provided.
     $endRE //= qr/^end[\w\s]*$/;
 
     _markModuleSource($module, $fileReader->currentFilename() . ":$.");
 
     # Read in each option
     while (($_ = _readNextLogicalLine($fileReader)) && ($_ !~ $endRE))
     {
         my $current_file = $fileReader->currentFilename();
 
         # Sanity check, make sure the section is correctly terminated
         if(/^(module\b|options\b)/)
         {
             error ("Invalid configuration file $current_file at line $.\nAdd an 'end $endWord' before " .
                    "starting a new module.\n");
             die make_exception('Config', "Invalid file $current_file");
         }
 
         my ($option, $value) = _splitOptionAndValue($ctx, $_);
 
         eval { $module->setOption($option, $value); };
         if (my $err = $@) {
             if (blessed($err) && $err->isa('ksb::BuildException::Config'))
             {
                 my $msg = "$current_file:$.: " . $err->message();
                 my $explanation = $err->optionUsageExplanation();
                 $msg = $msg . "\n" . $explanation if $explanation;
                 $err->setMessage($msg);
             }
 
             die; # re-throw
         }
     }
 
     return $module;
 }
 
 # Marks the given OptionsBase subclass (i.e. Module or ModuleSet) as being
 # read in from the given string (filename:line). An OptionsBase can be
 # tagged under multiple files.
 sub _markModuleSource
 {
     my ($optionsBase, $configSource) = @_;
     my $key = '#defined-at';
 
     my $sourcesRef = $optionsBase->hasOption($key)
         ? $optionsBase->getOption($key)
         : [];
 
     push @$sourcesRef, $configSource;
     $optionsBase->setOption($key, $sourcesRef);
 }
 
 # Returns rcfile sources for given OptionsBase (comma-separated).
 sub _getModuleSources
 {
     my $optionsBase = shift;
     my $key = '#defined-at';
 
     my $sourcesRef = $optionsBase->getOption($key) || [];
 
     return join(', ', @$sourcesRef);
 }
 
 # Reads in a "moduleset".
 #
 # First parameter is the build context.
 # Second parameter is the filehandle to the config file to read from.
 # Third parameter is the ksb::ModuleSet to use.
 #
 # Returns the ksb::ModuleSet passed in with read-in options set, which may need
 # to be further expanded (see ksb::ModuleSet::convertToModules).
 sub _parseModuleSetOptions
 {
     my ($ctx, $fileReader, $moduleSet) = @_;
 
     $moduleSet = _parseModuleOptions($ctx, $fileReader, $moduleSet, qr/^end\s+module(-?set)?$/);
 
     if ($moduleSet->getOption('repository') eq KDE_PROJECT_ID &&
         !$moduleSet->isa('ksb::ModuleSet::KDEProjects'))
     {
         # Perl-specific note! re-blessing the module set into the right 'class'
         # You'd probably have to construct an entirely new object and copy the
         # members over in other languages.
         bless $moduleSet, 'ksb::ModuleSet::KDEProjects';
     }
 
     return $moduleSet;
 }
 
 # Function: _readConfigurationOptions
 #
 # Reads in the settings from the configuration, passed in as an open
 # filehandle.
 #
 # Phase:
 #  initialization - Do not call <finish> from this function.
 #
 # Parameters:
 #  ctx - The <BuildContext> to update based on the configuration read and
 #  any pending command-line options (see cmdlineGlobalOptions).
 #
 #  filehandle - The I/O object to read from. Must handle _eof_ and _readline_
 #  methods (e.g. <IO::Handle> subclass).
 #
 #  deferredOptions - An out parameter: a hashref holding the options set by any
 #  'options' blocks read in by this function. Each key (identified by the name
 #  of the 'options' block) will point to a hashref value holding the options to
 #  apply.
 #
 # Returns:
 #  @module - Heterogenous list of <Modules> and <ModuleSets> defined in the
 #  configuration file. No module sets will have been expanded out (either
 #  kde-projects or standard sets).
 #
 # Throws:
 #  - Config exceptions.
 sub _readConfigurationOptions
 {
     my $ctx = assert_isa(shift, 'ksb::BuildContext');
     my $fh = shift;
     my $deferredOptionsRef = shift;
     my @module_list;
     my $rcfile = $ctx->rcFile();
     my ($option, %readModules);
 
     my $fileReader = ksb::RecursiveFH->new($rcfile);
     $fileReader->addFile($fh, $rcfile);
 
     # Read in global settings
     while ($_ = $fileReader->readLine())
     {
         s/#.*$//;       # Remove comments
         s/^\s*//;       # Remove leading whitespace
         next if (/^\s*$/); # Skip blank lines
 
         # First command in .kdesrc-buildrc should be a global
         # options declaration, even if none are defined.
         if (not /^global\s*$/)
         {
             error ("Invalid configuration file: $rcfile.");
             error ("Expecting global settings section at b[r[line $.]!");
             die make_exception('Config', 'Missing global section');
         }
 
         # Now read in each global option.
         _parseModuleOptions($ctx, $fileReader, $ctx);
 
         last;
     }
 
     my $using_default = 1;
     my %seenModules; # NOTE! *not* module-sets, *just* modules.
     my %seenModuleSets; # and vice versa -- named sets only though!
     my %seenModuleSetItems; # To track option override modules.
 
     # Now read in module settings
     while ($_ = $fileReader->readLine())
     {
         s/#.*$//;          # Remove comments
         s/^\s*//;          # Remove leading whitespace
         next if (/^\s*$/); # Skip blank lines
 
         # Get modulename (has dash, dots, slashes, or letters/numbers)
         my ($type, $modulename) = /^(options|module)\s+([-\/\.\w]+)\s*$/;
         my $newModule;
 
         # 'include' directives can change the current file, so check where we're at
         $rcfile = $fileReader->currentFilename();
 
         # Module-set?
         if (not $modulename) {
             my $moduleSetRE = qr/^module-set\s*([-\/\.\w]+)?\s*$/;
             ($modulename) = m/$moduleSetRE/;
 
             # modulename may be blank -- use the regex directly to match
             if (not /$moduleSetRE/) {
                 error ("Invalid configuration file $rcfile!");
                 error ("Expecting a start of module section at r[b[line $.].");
                 die make_exception('Config', 'Ungrouped/Unknown option');
             }
 
             if ($modulename && exists $seenModuleSets{$modulename}) {
                 error ("Duplicate module-set $modulename at $rcfile:$.");
                 die make_exception('Config', "Duplicate module-set $modulename defined at $rcfile:$.");
             }
 
             if ($modulename && exists $seenModules{$modulename}) {
                 error ("Name $modulename for module-set at $rcfile:$. is already in use on a module");
                 die make_exception('Config', "Can't re-use name $modulename for module-set defined at $rcfile:$.");
             }
 
             # A moduleset can give us more than one module to add.
             $newModule = _parseModuleSetOptions($ctx, $fileReader,
                 ksb::ModuleSet->new($ctx, $modulename || "<module-set at line $.>"));
 
             # Save 'use-modules' entries so we can see if later module decls
             # are overriding/overlaying their options.
             my @moduleSetItems = $newModule->moduleNamesToFind();
             @seenModuleSetItems{@moduleSetItems} = ($newModule) x scalar @moduleSetItems;
 
             $seenModuleSets{$modulename} = $newModule if $modulename;
         }
         # Duplicate module entry? (Note, this must be checked before the check
         # below for 'options' sets)
         elsif (exists $seenModules{$modulename} && $type ne 'options') {
             error ("Duplicate module declaration b[r[$modulename] on line $. of $rcfile");
             die make_exception('Config', "Duplicate module $modulename declared at $rcfile:$.");
         }
         # Module/module-set options overrides
         elsif ($type eq 'options') {
             my $options = _parseModuleOptions($ctx, $fileReader,
                 ksb::OptionsBase->new());
 
             $deferredOptionsRef->{$modulename} = $options->{options};
 
             next; # Don't add to module list
         }
         # Must follow 'options' handling
         elsif (exists $seenModuleSets{$modulename}) {
             error ("Name $modulename for module at $rcfile:$. is already in use on a module-set");
             die make_exception('Config', "Can't re-use name $modulename for module defined at $rcfile:$.");
         }
         else {
             $newModule = _parseModuleOptions($ctx, $fileReader,
                 ksb::Module->new($ctx, $modulename));
             $seenModules{$modulename} = $newModule;
         }
 
         push @module_list, $newModule;
 
         $using_default = 0;
     }
 
     while (my ($name, $moduleSet) = each %seenModuleSets) {
         _validateModuleSet($ctx, $moduleSet);
     }
 
     # If the user doesn't ask to build any modules, build a default set.
     # The good question is what exactly should be built, but oh well.
     if ($using_default) {
         warning (" b[y[*] There do not seem to be any modules to build in your configuration.");
         return ();
     }
 
     return @module_list;
 }
 
 # Exits out of kdesrc-build, executing the user's preferred shell instead.  The
 # difference is that the environment variables should be as set in kdesrc-build
 # instead of as read from .bashrc and friends.
 #
 # You should pass in the options to run the program with as a list.
 #
 # Meant to implement the --run command line option.
 sub _executeCommandLineProgram
 {
     my ($program, @args) = @_;
 
     if (!$program)
     {
         error ("You need to specify a program with the --run option.");
         exit 1; # Can't use finish here.
     }
 
     if (($< != $>) && ($> == 0))
     {
         error ("kdesrc-build will not run a program as root unless you really are root.");
         exit 1;
     }
 
     debug ("Executing b[r[$program] ", join(' ', @args));
 
     exit 0 if pretending();
 
     exec $program, @args or do {
         # If we get to here, that sucks, but don't continue.
         error ("Error executing $program: $!");
         exit 1;
     };
 }
 
 # Function: _split_url
 #
 # Subroutine to split a url into a protocol and host
 sub _split_url
 {
     my $url = shift;
     my ($proto, $host) = ($url =~ m|([^:]*)://([^/]*)/|);
 
     return ($proto, $host);
 }
 
 # Function: _check_for_ssh_agent
 #
 # Checks if we are supposed to use ssh agent by examining the environment, and
 # if so checks if ssh-agent has a list of identities.  If it doesn't, we run
 # ssh-add (with no arguments) and inform the user.  This can be controlled with
 # the disable-agent-check parameter.
 #
 # Parameters:
 # 1. Build context
 sub _check_for_ssh_agent
 {
     my $ctx = assert_isa(shift, 'ksb::BuildContext');
 
     # Don't bother with all this if the user isn't even using SSH.
     return 1 if pretending();
 
     my @svnServers = grep {
         $_->scmType() eq 'svn'
     } ($ctx->modulesInPhase('update'));
 
     my @gitServers = grep {
         $_->scmType() eq 'git'
     } ($ctx->modulesInPhase('update'));
 
     my @sshServers = grep {
         my ($proto, $host) = _split_url($_->getOption('svn-server'));
 
         # Check if ssh is explicitly used in the proto, or if the host is the
         # developer main svn.
         (defined $proto && $proto =~ /ssh/) || (defined $host && $host =~ /^svn\.kde\.org/);
     } @svnServers;
 
     push @sshServers, grep {
         # Check for git+ssh:// or git@git.kde.org:/path/etc.
         my $repo = $_->getOption('repository');
         ($repo =~ /^git\+ssh:\/\//) || ($repo =~ /^[a-zA-Z0-9_.]+@.*:\//);
     } @gitServers;
 
     return 1 if (not @sshServers) or $ctx->getOption('disable-agent-check');
     whisper ("\tChecking for SSH Agent") if (scalar @sshServers);
 
     # We're using ssh to download, see if ssh-agent is running.
     return 1 unless exists $ENV{'SSH_AGENT_PID'};
 
     my $pid = $ENV{'SSH_AGENT_PID'};
 
     # It's supposed to be running, let's see if there exists the program with
     # that pid (this check is linux-specific at the moment).
     if (-d "/proc" and not -e "/proc/$pid")
     {
         warning ("r[ *] SSH Agent is enabled, but y[doesn't seem to be running].");
         warning ("Since SSH is used to download from Subversion you may want to see why");
         warning ("SSH Agent is not working, or correct the environment variable settings.");
 
         return 0;
     }
 
     # The agent is running, but does it have any keys?  We can't be more specific
     # with this check because we don't know what key is required.
     my $noKeys = 0;
 
     filter_program_output(sub { $noKeys ||= /no identities/ }, 'ssh-add', '-l');
 
     if ($noKeys)
     {
         # Use print so user can't inadvertently keep us quiet about this.
         print ksb::Debug::colorize (<<EOF);
 b[y[*] SSH Agent does not appear to be managing any keys.  This will lead to you
   being prompted for every module update for your SSH passphrase.  So, we're
   running g[ssh-add] for you.  Please type your passphrase at the prompt when
   requested, (or simply Ctrl-C to abort the script).
 EOF
         my @commandLine = ('ssh-add');
         my $identFile = $ctx->getOption('ssh-identity-file');
         push (@commandLine, $identFile) if $identFile;
 
         my $result = system (@commandLine);
         if ($result) # Run this code for both death-by-signal and nonzero return
         {
             my $rcfile = $ctx->rcFile();
 
             print "\nUnable to add SSH identity, aborting.\n";
             print "If you don't want kdesrc-build to check in the future,\n";
             print ksb::Debug::colorize ("Set the g[disable-agent-check] option to g[true] in your $rcfile.\n\n");
 
             return 0;
         }
     }
 
     return 1;
 }
 
 # Function: _handle_updates
 #
 # Subroutine to update a list of modules.  Uses a Mojolicious event loop
 # to run each update in a subprocess to avoid blocking the script.  Only
 # one update process will exist at a given time.
 #
 # Parameters:
 # 1. Build Context, which will be used to determine the module update list.
 # 2. A PromiseChain for adding work items and dependencies.
 # 3. A "start promise" that can be waited on for pre-update steps.
 #
 # This function accounts for every module in $ctx's update phase.
 #
 # Returns an updated start promise and can also throw exception on error
 sub _handle_updates
 {
     my ($ctx, $promiseChain, $start_promise) = @_;
     my $kdesrc = $ctx->getSourceDir();
     my @update_list = $ctx->modulesInPhase('update');
 
     return $start_promise unless @update_list;
 
     croak_runtime("SSH agent is not running but should be")
         unless _check_for_ssh_agent($ctx);
 
     # TODO: Extract this to a setup function that all updates/build depend upon
     whisper ("Creating source directory") unless -e $kdesrc;
     croak_runtime ("Unable to make directory r[$kdesrc]! $!")
         if (! -e $kdesrc && !super_mkdir ($kdesrc));
 
     for my $module (@update_list) {
         # sub must be defined here to capture $module in the loop
         my $updateSub = sub {
             return $module->runPhase_p('update',
                 # called in child process, can block
                 sub { return $module->update($ctx) },
                 # called in this process, with results
                 sub {
-                    my (undef, $numUpdates) = @_;
-                    $module->setOption('#numUpdates', $numUpdates + 0);
-                    1; # Declare victory
+                    my (undef, $was_successful, $extras) = @_;
+                    $module->setOption('#numUpdates', $extras->{update_count});
+                    return $was_successful;
                 }
             );
         };
 
         $promiseChain->addItem("$module/update", "network-queue", $updateSub);
     }
 
     return $start_promise;
 }
 
 # Throws an exception if essential build programs are missing as a sanity check.
 sub _checkForEarlyBuildExit
 {
     my $ctx = shift;
     my @modules = $ctx->modulesInPhase('build');
 
     # Check for absolutely essential programs now.
     if (!_checkForEssentialBuildPrograms($ctx) &&
         !exists $ENV{KDESRC_BUILD_IGNORE_MISSING_PROGRAMS})
     {
         error (" r[b[*] Aborting now to save a lot of wasted time.");
         error (" y[b[*] export KDESRC_BUILD_IGNORE_MISSING_PROGRAMS=1 and re-run (perhaps with --no-src)");
         error (" r[b[*] to continue anyways. If this check was in error please report a bug against");
         error (" y[b[*] kdesrc-build at https://bugs.kde.org/");
 
         croak_runtime ("Essential build programs are missing!");
     }
 }
 
 sub _openStatusFileHandle
 {
     my $ctx = shift;
     my $outfile = pretending() ? '/dev/null'
                                : $ctx->getLogDir() . '/build-status';
 
     my $statusFile;
     open $statusFile, '>', $outfile or do {
         error (<<EOF);
 	Unable to open output status file r[b[$outfile]
 	You won't be able to use the g[--resume] switch next run.\n";
 EOF
         $statusFile = undef;
     };
 
     return ($statusFile, $outfile);
 }
 
 # Function: _handle_build
 #
 # Subroutine to handle the build process.
 #
 # Parameters:
 # 1. Build Context, which is used to determine list of modules to build.
 # 2. A PromiseChain, which will have build items inserted and dependencies
 #    added to the update phase as necessary.
 # 3. A "start promise" that can be waited on for pre-build steps
 #
 # Assumes basic directory layout setup and updates completed
 #
 # If $builddir/$module/.refresh-me exists, the subroutine will completely
 # rebuild the module (as if --refresh-build were passed for that module).
 #
 # Returns a new start promise, and can also throw exceptions on error
 sub _handle_build
 {
     my ($ctx, $promiseChain, $start_promise) = @_;
     my @modules = $ctx->modulesInPhase('build');
     my $result = 0;
 
     _checkForEarlyBuildExit($ctx); # exception-thrower
 
     my $num_modules = scalar @modules;
     my ($statusFile, $outfile) = _openStatusFileHandle($ctx);
     my $everFailed = 0;
 
     # This generates a bunch of subs but doesn't call them yet
     foreach my $module (@modules) {
         # Needs to happen in this loop to capture $module
         my $buildSub = sub {
             return if ($everFailed && $module->getOption('stop-on-failure'));
 
             my $fail_count = $module->getPersistentOption('failure-count') // 0;
             my $num_updates = int ($module->getOption('#numUpdates', 'module') // 1);
 
             # check for skipped updates, --no-src forces build-when-unchanged
             # even when ordinarily disabled
             if ($num_updates == 0
                 && !$module->getOption('build-when-unchanged')
                 && $fail_count == 0)
             {
                 # TODO: Why is the param order reversed for these two?
                 $ctx->statusMonitor()->markPhaseStart("$module", 'build');
                 $ctx->markModulePhaseSucceeded('build', $module);
 
                 return 'skipped';
             }
 
             # Can't build w/out blocking so return a promise instead, which ->build
             # already supplies
             return $module->build()->catch(sub {
                 my $failureReason = shift;
 
                 if (!$everFailed) {
                     # No failures yet, mark this as resume point
                     $everFailed = 1;
                     my $moduleList = join(', ', map { "$_" } ($module, @modules));
                     $ctx->setPersistentOption('global', 'resume-list', $moduleList);
                 }
 
                 ++$fail_count;
 
                 # Force this promise chain to stay dead
                 return Mojo::Promise->new->reject('build');
             })->then(sub {
                 $fail_count = 0;
             })->finally(sub {
                 $module->setPersistentOption('failure-count', $fail_count);
             });
         };
 
         $promiseChain->addItem("$module/build", 'cpu-queue', $buildSub);
 
         # If there's an update phase we need to depend on it and show status
         if (my $updatePromise = $promiseChain->promiseFor("$module/update")) {
             $promiseChain->addDep("$module/build", "$module/update");
         }
     };
 
     # Add to the build 'queue' for promise chain so that this runs only after all
     # other build jobs
     $promiseChain->addDep('@postBuild', 'cpu-queue', sub {
         if ($statusFile)
         {
             close $statusFile;
 
             # Update the symlink in latest to point to this file.
             my $logdir = $ctx->getSubdirPath('log-dir');
             if (-l "$logdir/latest/build-status") {
                 safe_unlink("$logdir/latest/build-status");
             }
             symlink($outfile, "$logdir/latest/build-status");
         }
 
         return Mojo::Promise->new->reject if $everFailed;
         return 0;
     });
 
     return $start_promise->then(
         sub { $ctx->unsetPersistentOption('global', 'resume-list') });
 }
 
 # Function: _handle_async_build
 #
 # This subroutine special-cases the handling of the update and build phases, by
 # performing them concurrently using forked processes and non-blocking I/O.
 # See Mojo::Promise and Mojo::IOLoop::Subprocess
 #
 # This procedure will use multiple processes (the main process and separate
 # processes for each update or build as they occur).
 #
 # Parameters:
 # 1. Build Context to use, from which the module lists will be determined.
 #
 # Returns 0 on success, non-zero on failure.
 sub _handle_async_build
 {
     my ($ctx) = @_;
     my $result = 0;
 
     $ctx->statusMonitor()->createBuildPlan($ctx);
 
     my $promiseChain = ksb::PromiseChain->new;
     my $start_promise = Mojo::Promise->new;
 
     # These succeed or die outright
     eval {
         $start_promise = _handle_updates ($ctx, $promiseChain, $start_promise);
         $start_promise = _handle_build   ($ctx, $promiseChain, $start_promise);
     };
 
     if ($@) {
         error ("Caught an error $@ setting up to build");
         return 1;
     }
 
     my $chain = $promiseChain->makePromiseChain($start_promise)
         ->finally(sub {
             # Fail if we had a zero-valued result (indicates error)
             my @results = @_;
 
             # Must use ! here to make '0 but true' hack work
             $result = 1 if defined first { !($_->[0] // 1) } @results;
 
             $ctx->statusMonitor()->markBuildDone();
         });
 
     # Start the update/build process
     $start_promise->resolve;
 
     Mojo::IOLoop->stop; # Force the wait below to block
     $chain->wait;
 
     return $result;
 }
 
 # Function: _handle_install
 #
 # Handles the installation process.  Simply calls 'make install' in the build
 # directory, though there is also provision for cleaning the build directory
 # afterwards, or stopping immediately if there is a build failure (normally
 # every built module is attempted to be installed).
 #
 # Parameters:
 # 1. Build Context, from which the install list is generated.
 #
 # Return value is a shell-style success code (0 == success)
 sub _handle_install
 {
     my $ctx = assert_isa(shift, 'ksb::BuildContext');
     my @modules = $ctx->modulesInPhase('install');
 
     @modules = grep { $_->buildSystem()->needsInstalled() } (@modules);
     my $result = 0;
 
     for my $module (@modules)
     {
         $ctx->resetEnvironment();
         $result = $module->install() || $result;
 
         if ($result && $module->getOption('stop-on-failure')) {
             note ("y[Stopping here].");
             return 1; # Error
         }
     }
 
     return $result;
 }
 
 # Function: _handle_uninstall
 #
 # Handles the uninstal process.  Simply calls 'make uninstall' in the build
 # directory, while assuming that Qt or CMake actually handles it.
 #
 # The order of the modules is often significant, and it may work better to
 # uninstall modules in reverse order from how they were installed. However this
 # code does not automatically reverse the order; modules are uninstalled in the
 # order determined by the build context.
 #
 # This function obeys the 'stop-on-failure' option supported by _handle_install.
 #
 # Parameters:
 # 1. Build Context, from which the uninstall list is generated.
 #
 # Return value is a shell-style success code (0 == success)
 sub _handle_uninstall
 {
     my $ctx = assert_isa(shift, 'ksb::BuildContext');
     my @modules = $ctx->modulesInPhase('uninstall');
 
     @modules = grep { $_->buildSystem()->needsInstalled() } (@modules);
     my $result = 0;
 
     for my $module (@modules)
     {
         $ctx->resetEnvironment();
         $result = $module->uninstall() || $result;
 
         if ($result && $module->getOption('stop-on-failure'))
         {
             note ("y[Stopping here].");
             return 1; # Error
         }
     }
 
     return $result;
 }
 
 # Function: _applyModuleFilters
 #
 # Applies any module-specific filtering that is necessary after reading command
 # line and rc-file options. (This is as opposed to phase filters, which leave
 # each module as-is but change the phases they operate as part of, this
 # function could remove a module entirely from the build).
 #
 # Used for --resume-{from,after} and --stop-{before,after}, but more could be
 # added in theory.
 # This subroutine supports --{resume,stop}-* for both modules and module-sets.
 #
 # Parameters:
 #  ctx - <BuildContext> in use.
 #  @modules - List of <Modules> or <ModuleSets> to apply filters on.
 #
 # Returns:
 #  list of <Modules> or <ModuleSets> with any inclusion/exclusion filters
 #  applied. Do not assume this list will be a strict subset of the input list,
 #  however the order will not change amongst the input modules.
 sub _applyModuleFilters
 {
     my $ctx = assert_isa(shift, 'ksb::BuildContext');
     my @moduleList = @_;
 
     if (!$ctx->getOption('resume-from') && !$ctx->getOption('resume-after') &&
         !$ctx->getOption('stop-before') && !$ctx->getOption('stop-after'))
     {
         debug ("No command-line filter seems to be present.");
         return @moduleList;
     }
 
     if ($ctx->getOption('resume-from') && $ctx->getOption('resume-after'))
     {
         # This one's an error.
         error (<<EOF);
 You specified both r[b[--resume-from] and r[b[--resume-after] but you can only
 use one.
 EOF
 
         croak_runtime("Both --resume-after and --resume-from specified.");
     }
 
     if ($ctx->getOption('stop-before') && $ctx->getOption('stop-after'))
     {
         # This one's an error.
         error (<<EOF);
 You specified both r[b[--stop-before] and r[b[--stop-after] but you can only
 use one.
 EOF
 
         croak_runtime("Both --stop-before and --stop-from specified.");
     }
 
     return unless @moduleList; # Empty input?
 
     my $resumePoint = $ctx->getOption('resume-from') ||
                       $ctx->getOption('resume-after');
 
     my $startIndex = scalar @moduleList;
 
     if ($resumePoint) {
         debug ("Looking for $resumePoint for --resume-* option");
 
         # || 0 is a hack to force Boolean context.
         my $filterInclusive = $ctx->getOption('resume-from') || 0;
         my $found = 0;
 
         for (my $i = 0; $i < scalar @moduleList; $i++) {
             my $module = $moduleList[$i];
 
             $found = $module->name() eq $resumePoint;
             if ($found) {
                 $startIndex = $filterInclusive ? $i : $i + 1;
                 $startIndex = min($startIndex, scalar @moduleList - 1);
                 last;
             }
         }
     }
     else {
         $startIndex = 0;
     }
 
     my $stopPoint = $ctx->getOption('stop-before') ||
                     $ctx->getOption('stop-after');
 
     my $stopIndex = 0;
 
     if ($stopPoint) {
         debug ("Looking for $stopPoint for --stop-* option");
 
         # || 0 is a hack to force Boolean context.
         my $filterInclusive = $ctx->getOption('stop-before') || 0;
         my $found = 0;
 
         for (my $i = $startIndex; $i < scalar @moduleList; $i++) {
             my $module = $moduleList[$i];
 
             $found = $module->name() eq $stopPoint;
             if ($found) {
                 $stopIndex = $i - ($filterInclusive ? 1 : 0);
                 last;
             }
         }
     }
     else {
         $stopIndex = scalar @moduleList - 1;
     }
 
     if ($startIndex > $stopIndex || scalar @moduleList == 0) {
         # Lost all modules somehow.
         croak_runtime("Unknown resume -> stop point $resumePoint -> $stopPoint.");
     }
 
     return @moduleList[$startIndex .. $stopIndex];
 }
 
 # Updates the built-in phase list for all Modules passed into this function in
 # accordance with the options set by the user.
 sub _updateModulePhases
 {
     whisper ("Filtering out module phases.");
     for my $module (@_) {
         if ($module->getOption('manual-update') ||
             $module->getOption('no-svn') || $module->getOption('no-src'))
         {
             $module->phases()->clear();
             next;
         }
 
         if ($module->getOption('manual-build')) {
             $module->phases()->filterOutPhase('build');
             $module->phases()->filterOutPhase('test');
             $module->phases()->filterOutPhase('install');
         }
 
         $module->phases()->filterOutPhase('install') unless $module->getOption('install-after-build');
         $module->phases()->addPhase('test') if $module->getOption('run-tests');
     }
 
     return @_;
 }
 
 # This subroutine extract the value from options of the form --option=value,
 # which can also be expressed as --option value.
 #
 # The first parameter is the option that the user passed to the cmd line (e.g.
 # --prefix=/opt/foo).
 # The second parameter is a reference to the list of command line options.
 #
 # The return value is the value of the option (the list of options might be
 # shorter by 1, copy it if you don't want it to change), or undef if no value
 # was provided.
 sub _extractOptionValue
 {
     my ($option, $options_ref) = @_;
 
     if ($option =~ /=/)
     {
         my @value = split(/=/, $option);
         shift @value; # We don't need the first one, that the --option part.
 
         return if (scalar @value == 0);
 
         # If we have more than one element left in @value it's because the
         # option itself has an = in it, make sure it goes back in the answer.
         return join('=', @value);
     }
 
     return if scalar @{$options_ref} == 0;
     return shift @{$options_ref};
 }
 
 # Like _extractOptionValue, but throws an exception if the value is not
 # actually present, so you don't have to check for it yourself. If you do get a
 # return value, it will be defined to something.
 sub _extractOptionValueRequired
 {
     my ($option, $options_ref) = @_;
     my $returnValue = _extractOptionValue($option, $options_ref);
 
     if (not defined $returnValue) {
         croak_runtime("Option $option needs to be set to some value instead of left blank");
     }
 
     return $returnValue;
 }
 
 # Function: _cleanup_log_directory
 #
 # This function removes log directories from old kdesrc-build runs.  All log
 # directories not referenced by $log_dir/latest somehow are made to go away.
 #
 # Parameters:
 # 1. Build context.
 #
 # No return value.
 sub _cleanup_log_directory
 {
     my $ctx = assert_isa(shift, 'ksb::BuildContext');
     my $logdir = $ctx->getSubdirPath('log-dir');
 
     return 0 if ! -e "$logdir/latest"; # Could happen for error on first run...
 
     # This glob relies on the date being in the specific format YYYY-MM-DD-ID
     my @dirs = bsd_glob("$logdir/????-??-??-??/", GLOB_NOSORT);
     my @needed = _reachableModuleLogs("$logdir/latest");
 
     # Convert a list to a hash lookup since Perl lacks a "list-has"
     my %needed_table;
     @needed_table{@needed} = (1) x @needed;
 
     for my $dir (@dirs) {
         my ($id) = ($dir =~ m/(\d\d\d\d-\d\d-\d\d-\d\d)/);
         safe_rmtree($dir) unless $needed_table{$id};
     }
 }
 
 # Function: _output_failed_module_list
 #
 # Print out an error message, and a list of modules that match that error
 # message.  It will also display the log file name if one can be determined.
 # The message will be displayed all in uppercase, with PACKAGES prepended, so
 # all you have to do is give a descriptive message of what this list of
 # packages failed at doing.
 #
 # No message is printed out if the list of failed modules is empty, so this
 # function can be called unconditionally.
 #
 # Parameters:
 # 1. Build Context
 # 2. Message to print (e.g. 'failed to foo')
 # 3. List of ksb::Modules that had failed to foo
 #
 # No return value.
 sub _output_failed_module_list
 {
     my ($ctx, $message, @fail_list) = @_;
     assert_isa($ctx, 'ksb::BuildContext');
 
     $message = uc $message; # Be annoying
 
     if (@fail_list)
     {
         debug ("Message is $message");
         debug ("\tfor ", join(', ', @fail_list));
     }
 
     if (scalar @fail_list > 0)
     {
         my $homedir = $ENV{'HOME'};
         my $logfile;
 
         warning ("\nr[b[<<<  PACKAGES $message  >>>]");
 
         for my $module (@fail_list)
         {
             $logfile = $module->getOption('#error-log-file');
 
             # async updates may cause us not to have a error log file stored
             # (though this should now only happen due to other bugs). Since
             # there's only one place it should be, take advantage of
             # side-effect of log_command() to find it.
             if (not $logfile) {
                 my $logdir = $module->getLogDir() . "/error.log";
                 $logfile = $logdir if -e $logdir;
             }
 
             $logfile = "No log file" unless $logfile;
             $logfile =~ s|$homedir|~|;
 
             warning ("r[$module]") if pretending();
             warning ("r[$module] - g[$logfile]") if not pretending();
         }
     }
 }
 
 # Function: _output_failed_module_lists
 #
 # This subroutine reads the list of failed modules for each phase in the build
 # context and calls _output_failed_module_list for all the module failures.
 #
 # Parameters:
 # 1. Build context
 #
 # Return value:
 # None
 sub _output_failed_module_lists
 {
     my $ctx = assert_isa(shift, 'ksb::BuildContext');
 
     # This list should correspond to the possible phase names (although
     # it doesn't yet since the old code didn't, TODO)
     for my $phase ($ctx->phases()->phases())
     {
         my @failures = $ctx->failedModulesInPhase($phase);
         _output_failed_module_list($ctx, "failed to $phase", @failures);
     }
 
     # See if any modules fail continuously and warn specifically for them.
     my @super_fail = grep {
         ($_->getPersistentOption('failure-count') // 0) > 3
     } (@{$ctx->moduleList()});
 
     if (@super_fail)
     {
         warning ("\nThe following modules have failed to build 3 or more times in a row:");
         warning ("\tr[b[$_]") foreach @super_fail;
         warning ("\nThere is probably a local error causing this kind of consistent failure, it");
         warning ("is recommended to verify no issues on the system.\n");
     }
 }
 
 # Function: _installTemplatedFile
 #
 # This function takes a given file and a build context, and installs it to a
 # given location while expanding out template entries within the source file.
 #
 # The template language is *extremely* simple: <% foo %> is replaced entirely
 # with the result of $ctx->getOption(foo, 'no-inherit'). If the result
 # evaluates false for any reason than an exception is thrown. No quoting of
 # any sort is used in the result, and there is no way to prevent expansion of
 # something that resembles the template format.
 #
 # Multiple template entries on a line will be replaced.
 #
 # The destination file will be created if it does not exist. If the file
 # already exists then an exception will be thrown.
 #
 # Error handling: Any errors will result in an exception being thrown.
 #
 # Parameters:
 # 1. Pathname to the source file (use absolute paths)
 # 2. Pathname to the destination file (use absolute paths)
 # 3. Build context to use for looking up template values
 #
 # Return value: There is no return value.
 sub _installTemplatedFile
 {
     my ($sourcePath, $destinationPath, $ctx) = @_;
     assert_isa($ctx, 'ksb::BuildContext');
 
     open (my $input,  '<', $sourcePath) or
         croak_runtime("Unable to open template source $sourcePath: $!");
     open (my $output, '>', $destinationPath) or
         croak_runtime("Unable to open template output $destinationPath: $!");
 
     while (!eof ($input)) {
         my $line = readline($input);
         if (!defined ($line)) {
             croak_runtime("Failed to read from $sourcePath at line $.: $!");
             unlink($destinationPath);
         }
 
         # Some lines should only be present in the source as they aid with testing.
         next if $line =~ /kdesrc-build: filter/;
 
         $line =~
             s {
                 <% \s*    # Template bracket and whitespace
                 ([^\s%]+) # Capture variable name
                 \s*%>     # remaining whitespace and closing bracket
               }
               {
                   $ctx->getOption($1, 'module') //
                       croak_runtime("Invalid variable $1")
               }gxe;
               # Replace all matching expressions, use extended regexp w/
               # comments, and replacement is Perl code to execute.
 
         (print $output $line) or
             croak_runtime("Unable to write line to $destinationPath at line $.: $!");
     }
 }
 
 # Function: _installCustomFile
 #
 # This function installs a source file to a destination path, assuming the
 # source file is a "templated" source file (see also _installTemplatedFile), and
 # records a digest of the file actually installed. This function will overwrite
 # a destination if the destination is identical to the last-installed file.
 #
 # Error handling: Any errors will result in an exception being thrown.
 #
 # Parameters:
 # 1. Build context to use for looking up template values,
 # 2. The full path to the source file.
 # 3. The full path to the destination file (incl. name)
 # 4. The key name to use for searching/recording installed MD5 digest.
 #
 # Return value: There is no return value.
 sub _installCustomFile
 {
     use File::Copy qw(copy);
 
     my $ctx = assert_isa(shift, 'ksb::BuildContext');
     my ($sourceFilePath, $destFilePath, $md5KeyName) = @_;
     my $baseName = basename($sourceFilePath);
 
     if (-e $destFilePath) {
         my $existingMD5 = $ctx->getPersistentOption('/digests', $md5KeyName) // '';
 
         if (fileDigestMD5($destFilePath) ne $existingMD5) {
             if (!$ctx->getOption('#delete-my-settings')) {
                 error ("\tr[*] Installing \"b[$baseName]\" would overwrite an existing file:");
                 error ("\tr[*]  y[b[$destFilePath]");
                 error ("\tr[*] If this is acceptable, please delete the existing file and re-run,");
                 error ("\tr[*] or pass b[--delete-my-settings] and re-run.");
 
                 return;
             }
             elsif (!pretending()) {
                 copy ($destFilePath, "$destFilePath.kdesrc-build-backup");
             }
         }
     }
 
     if (!pretending()) {
         _installTemplatedFile($sourceFilePath, $destFilePath, $ctx);
         $ctx->setPersistentOption('/digests', $md5KeyName, fileDigestMD5($destFilePath));
     }
 }
 
 # Function: _installCustomSessionDriver
 #
 # This function installs the included sample .xsession and environment variable
 # setup files, and records the md5sum of the installed results.
 #
 # If a file already exists, then its md5sum is taken and if the same as what
 # was previously installed, is overwritten. If not the same, the original file
 # is left in place and the .xsession is instead installed to
 # .xsession-kdesrc-build
 #
 # Error handling: Any errors will result in an exception being thrown.
 #
 # Parameters:
 # 1. Build context to use for looking up template values,
 #
 # Return value: There is no return value.
 sub _installCustomSessionDriver
 {
     use FindBin qw($RealBin);
     use List::Util qw(first);
     use File::Copy qw(copy);
 
     my $ctx = assert_isa(shift, 'ksb::BuildContext');
     my @xdgDataDirs = split(':', $ENV{XDG_DATA_DIRS} || '/usr/local/share/:/usr/share/');
     my $xdgDataHome = $ENV{XDG_DATA_HOME} || "$ENV{HOME}/.local/share";
 
     # First we have to find the source
     my @searchPaths = ($RealBin, map { "$_/apps/kdesrc-build" } ($xdgDataHome, @xdgDataDirs));
 
     s{/+$}{}   foreach @searchPaths; # Remove trailing slashes
     s{//+}{/}g foreach @searchPaths; # Remove duplicate slashes
 
     my $envScript = first { -f $_ } (
         map { "$_/sample-kde-env-master.sh" } @searchPaths
     );
     my $sessionScript = first { -f $_ } (
         map { "$_/sample-xsession.sh" } @searchPaths
     );
 
     if (!$envScript || !$sessionScript) {
         warning ("b[*] Unable to find helper files to setup a login session.");
         warning ("b[*] You will have to setup login yourself, or install kdesrc-build properly.");
         return;
     }
 
     my $destDir = $ENV{XDG_CONFIG_HOME} || "$ENV{HOME}/.config";
     super_mkdir($destDir) unless -d $destDir;
 
     _installCustomFile($ctx, $envScript, "$destDir/kde-env-master.sh",
         'kde-env-master-digest');
     _installCustomFile($ctx, $sessionScript, "$ENV{HOME}/.xsession",
         'xsession-digest') if $ctx->getOption('install-session-driver');
 
     if (!pretending()) {
         if ($ctx->getOption('install-session-driver') && !chmod (0744, "$ENV{HOME}/.xsession")) {
             error ("\tb[r[*] Error making b[~/.xsession] executable: $!");
             error ("\tb[r[*] If this file is not executable you may not be able to login!");
         };
     }
 }
 
 # Function: _checkForEssentialBuildPrograms
 #
 # This subroutine checks for programs which are absolutely essential to the
 # *build* process and returns false if they are not all present. Right now this
 # just means qmake and cmake (although this depends on what modules are
 # actually present in the build context).
 #
 # Parameters:
 # 1. Build context
 #
 # Return value:
 # None
 sub _checkForEssentialBuildPrograms
 {
     my $ctx = assert_isa(shift, 'ksb::BuildContext');
 
     return 1 if pretending();
 
     my @buildModules = $ctx->modulesInPhase('build');
     my %requiredPrograms;
     my %modulesRequiringProgram;
 
     foreach my $module ($ctx->modulesInPhase('build')) {
         my @progs = $module->buildSystem()->requiredPrograms();
 
         # Deliberately used @, since requiredPrograms can return a list.
         @requiredPrograms{@progs} = 1;
 
         foreach my $prog (@progs) {
             $modulesRequiringProgram{$prog} //= { };
             $modulesRequiringProgram{$prog}->{$module->name()} = 1;
         }
     }
 
     my $wasError = 0;
     for my $prog (keys %requiredPrograms) {
         my %requiredPackages = (
             qmake => 'Qt',
             cmake => 'CMake',
         );
 
         my $programPath = absPathToExecutable($prog);
 
         # qmake is not necessarily named 'qmake'
         if (!$programPath && $prog eq 'qmake') {
             $programPath = ksb::BuildSystem::QMake::absPathToQMake();
         }
 
         if (!$programPath) {
             # Don't complain about Qt if we're building it...
             if ($prog eq 'qmake' && (
                     grep { $_->buildSystemType() eq 'Qt' } (@buildModules)) ||
                     pretending()
                 )
             {
                 next;
             }
 
             $wasError = 1;
             my $reqPackage = $requiredPackages{$prog} || $prog;
 
             my @modulesNeeding = keys %{$modulesRequiringProgram{$prog}};
             local $, = ', '; # List separator in output
 
             error (<<"EOF");
 
 Unable to find r[b[$prog]. This program is absolutely essential for building
 the modules: y[@modulesNeeding].
 Please ensure the development packages for
 $reqPackage are installed by using your distribution's package manager.
 
 You can also see the
 https://techbase.kde.org/Getting_Started/Build/Distributions page for
 information specific to your distribution (although watch for outdated
 information :( ).
 EOF
         }
     }
 
     return !$wasError;
 }
 
 # Function: _reachableModuleLogs
 #
 # Returns a list of module directory IDs that must be kept due to being
 # referenced from the "latest" symlink.
 #
 # This function may call itself recursively if needed.
 #
 # Parameters:
 # 1. The log directory under which to search for symlinks, including the "/latest"
 #    part of the path.
 sub _reachableModuleLogs
 {
     my $logdir = shift;
     my @dirs;
 
     # A lexicalized var (my $foo) is required in face of recursiveness.
     opendir(my $fh, $logdir) or croak_runtime("Can't opendir $logdir: $!");
     my $dir = readdir($fh);
 
     while(defined $dir) {
         if (-l "$logdir/$dir") {
             my $link = readlink("$logdir/$dir");
             push @dirs, $link;
         }
         elsif ($dir !~ /^\.{1,2}$/) {
             # Skip . and .. directories (this is a great idea, trust me)
             push @dirs, _reachableModuleLogs("$logdir/$dir");
         }
         $dir = readdir $fh;
     }
 
     closedir $fh;
 
     # Extract numeric IDs from directory names.
     @dirs = map { m/(\d{4}-\d\d-\d\d-\d\d)/ } (@dirs);
 
     # Convert to unique list by abusing hash keys.
     my %tempHash;
     @tempHash{@dirs} = ();
 
     return keys %tempHash;
 }
 
 # Installs the given subroutine as a signal handler for a set of signals which
 # could kill the program.
 #
 # First parameter is a reference to the sub to act as the handler.
 sub _installSignalHandlers
 {
     my $handlerRef = shift;
     my @signals = qw/HUP INT QUIT ABRT TERM PIPE/;
 
     @SIG{@signals} = ($handlerRef) x scalar @signals;
 }
 
 # Shows a help message and version. Does not exit.
 sub _showHelpMessage
 {
     my $scriptVersion = scriptVersion();
     print <<DONE;
 kdesrc-build $scriptVersion
 https://kdesrc-build.kde.org/
 
 This script automates the download, build, and install process for KDE software
 using the latest available source code.
 
 You should first setup a configuration file (~/.kdesrc-buildrc). You can do
 this by running the kdesrc-build-setup program, which should be included with
 this one.  You can also copy the kdesrc-buildrc-sample file (which should be
 included) to ~/.kdesrc-buildrc.
 
 Basic synopsis, after setting up .kdesrc-buildrc:
 \$ $0 [--options] [module names]
 
 The module names can be either the name of an individual module (as set in your
 configuration with a module declaration, or a use-modules declaration), or of a
 module set (as set with a module-set declaration).
 
 If you don\'t specify any particular module names, then every module you have
 listed in your configuration will be built, in the order listed.
 
 Copyright (c) 2003 - 2018 Michael Pyne <mpyne\@kde.org>, and others.
 
 The script is distributed under the terms of the GNU General Public License
 v2, and includes ABSOLUTELY NO WARRANTY!!!
 
 Options:
     --no-src             Skip contacting the source server.
     --no-build           Skip the build process.
     --no-install         Don't automatically install after build.
 
     --pretend            Don't actually take major actions, instead describe
                          what would be done.
 
     --src-only           Only update the source code (Identical to --no-build
                          at this point).
     --build-only         Build only, don't perform updates or install.
 
     --install-only       Only install the already compiled code, this is equivalent
     --install            to make install/fast in CMake. Useful for example when we
                          want to clean the install directory but we do not want to
                          re-compile everything.
 
     --rc-file=<filename> Read configuration from filename instead of default.
 
     --resume-from=<pkg>  Skips modules until just before the given package,
                          then operates as normal.
     --resume-after=<pkg> Skips modules up to and including the given package,
                          then operates as normal.
 
     --stop-before=<pkg>  Skips the given package and all later packages.
     --stop-after=<pkg>   Skips all packages after the given package.
     --stop-on-failure    Stops the build as soon as a package fails to build.
 
     --reconfigure        Run CMake/configure again, but don't clean the build
                          directory.
     --build-system-only  Create the build infrastructure, but don't actually
                          perform the build.
 
     --<option>=          Any unrecognized options override an existing global
                          configuration value, if present.
 
     --set-module-option-value=<module>,<option>,<value>
         This option allows you to override an option for a given module, so
         that you don't have to change it in the configuration file temporarily.
         Use a module name of 'global' for the global configuration.
 
     --pretend (or -p)    Don't actually contact the source server, run make,
                          or create/delete files and directories.  Instead,
                          output what the script would have done.
     --refresh-build      Start the build from scratch.
 
     --include-dependencies Also try to build known dependencies of the modules
                            to be built.
 
     --verbose            Print verbose output
 
     --help               You\'re reading it. :-)
     --version            Output the program version.
 
 You can get more help by going online to
 https://docs.kde.org/trunk5/en/extragear-utils/kdesrc-build/
 to view the online documentation.
 
 If you have installed kdesrc-build you may also be able to view the
 documentation using KHelpCenter or Konqueror at the URL help:/kdesrc-build, or
 using the man page by typing "man kdesrc-build".
 
 The man page can also be found online at
 https://kdesrc-build.kde.org/documentation/kdesrc-build.1.html
 
 This help is not comprehensive, to see a listing of all options please visit:
 https://docs.kde.org/trunk5/en/extragear-utils/kdesrc-build/conf-options-table.html
 
 For all command line options, please visit:
 https://docs.kde.org/trunk5/en/extragear-utils/kdesrc-build/supported-cmdline-params.html
 DONE
 }
 
 # Accessors
 
 sub context
 {
     my $self = shift;
     return $self->{context};
 }
 
 sub metadataModule
 {
     my $self = shift;
     return $self->{metadata_module};
 }
 
 sub runMode
 {
     my $self = shift;
     return $self->{run_mode};
 }
 
 sub modules
 {
     my $self = shift;
     return @{$self->{modules}};
 }
 
 1;
diff --git a/modules/ksb/BuildContext.pm b/modules/ksb/BuildContext.pm
index 7da3501..c0b28f1 100644
--- a/modules/ksb/BuildContext.pm
+++ b/modules/ksb/BuildContext.pm
@@ -1,1049 +1,1050 @@
 package ksb::BuildContext 0.36;
 
 # Class: BuildContext
 #
 # This contains the information needed about the build context, e.g.  list of
 # modules, what phases each module is in, the various options, etc.
 
 use 5.014;
 use warnings;
 no if $] >= 5.018, 'warnings', 'experimental::smartmatch';
 
 use Carp 'confess';
 use File::Basename; # dirname
 use IO::File;
 use POSIX qw(strftime);
 use Errno qw(:POSIX);
 
 use Mojo::JSON qw(encode_json decode_json);
 
 # We derive from ksb::Module so that BuildContext acts like the 'global'
 # ksb::Module, with some extra functionality.
 # TODO: Derive from OptionsBase directly and remove getOption override
 use parent qw(ksb::Module);
 
 use ksb::Debug;
 use ksb::Util;
 use ksb::PhaseList;
 use ksb::Module;
 use ksb::Module::BranchGroupResolver;
 use ksb::Updater::KDEProjectMetadata 0.20;
 use ksb::Version qw(scriptVersion);
 use ksb::StatusView 0.30;
 use ksb::StatusMonitor;
 use ksb::KDEProjectsReader 0.50;
 
 use File::Temp qw(tempfile);
 use File::Spec; # rel2abs
 
 my @DefaultPhases = qw/update build install/;
 my @rcfiles = ("./kdesrc-buildrc", "$ENV{HOME}/.kdesrc-buildrc");
 my $LOCKFILE_NAME = '.kdesrc-lock';
 
 # The # will be replaced by the directory the rc File is stored in.
 my $PERSISTENT_FILE_NAME = '#/.kdesrc-build-data';
 
 my $SCRIPT_VERSION = scriptVersion();
 
 # Should be used for internal state that shouldn't be exposed as a hidden
 # cmdline option, or has other cmdline switches (e.g. debug/verbose handling).
 my %internalGlobalOptions = (
     "async"                => 1,
     "build-system-only"    => "",
     "build-when-unchanged" => 1, # Safe default
     "colorful-output"      => 1, # Use color by default.
     "debug-level"          => ksb::Debug::INFO,
     "filter-out-phases"    => '',
     "git-desired-protocol" => 'git', # protocol to grab from kde-projects
     "git-repository-base"  => {}, # Base path template for use multiple times.
     "ignore-modules"       => '', # See also: use-modules, kde-projects
     "include-dependencies" => 0,  # Recursively include kde-projects module deps?
     "manual-build"         => "",
     "manual-update"        => "",
     "niceness"             => "10",
     "no-svn"               => "",  # TODO: Rename to no-src
     "prefix"               => "", # Override installation prefix.
     "pretend"              => "",
     "reconfigure"          => "",
     "refresh-build"        => "",
     "repository"           => '',     # module's git repo
     "revision"             => '', # Only useful for Subversion modules at cmdline
     "set-env"              => { }, # Hash of environment vars to set
     "ssh-identity-file"    => '', # If set, is passed to ssh-add.
     "use-modules"          => "",
 );
 
 # Holds boolean flags that could be altered from cmdline.
 our %defaultGlobalFlags = (
     "delete-my-patches"          => 0, # Should only be set from cmdline
     "delete-my-settings"         => 0, # Should only be set from cmdline
     "disable-agent-check"        => 0, # If true we don't check on ssh-agent
     "disable-snapshots"          => 1, # 2016-07-31 Temp. disabled until kde.org fixed to supply snapshots
     "ignore-kde-structure"       => 0, # Whether to use kde dir structure like extragear/network
     "install-after-build"        => 1,
     "install-environment-driver" => 1, # Setup ~/.config/kde-env-*.sh for login scripts
     "install-session-driver"     => 0, # Above, + ~/.xsession
     "purge-old-logs"             => 1,
     "run-tests"                  => 0,  # 1 = make test, upload = make Experimental
     "stop-on-failure"            => 0,
     "use-clean-install"          => 0,
     "use-idle-io-priority"       => 0,
     "use-stable-kde"             => 0,
 );
 
 # Holds other cmdline-accessible options that aren't simply binary flags.
 our %defaultGlobalOptions = (
     "binpath"              => '',
     "branch"               => "",
     "branch-group"         => "", # Overrides branch, uses JSON data.
     "build-dir"            => "build",
     "cmake-options"        => "",
     "configure-flags"      => "",
     "custom-build-command" => '',
     "cxxflags"             => "-pipe",
     "dest-dir"             => '${MODULE}', # single quotes used on purpose!
     "do-not-compile"       => "",
     "http-proxy"           => '', # Proxy server to use for HTTP.
     "kdedir"               => "$ENV{HOME}/kde",
     "libpath"              => "",
     "log-dir"              => "log",
     "make-install-prefix"  => "",  # Some people need sudo
     "make-options"         => "",
     "module-base-path"     => "",  # Used for tags and branches
     "override-build-system"=> "",
     "override-url"         => "",
     "persistent-data-file" => "",
     "qtdir"                => "",
     "remove-after-install" => "none", # { none, builddir, all }
     "source-dir"           => "$ENV{HOME}/kdesrc",
     "svn-server"           => "svn://anonsvn.kde.org/home/kde",
     "tag"                  => "",
 );
 
 sub new
 {
     my ($class, @args) = @_;
 
     # It is very important to use the ksb::Module:: syntax instead of ksb::Module->,
     # otherwise you can't pass $class and have it used as the classname.
     my $self = ksb::Module::new($class, undef, 'global');
     my %newOpts = (
         modules => [],
         context => $self, # Fix link to buildContext (i.e. $self)
         build_options => {
             global => {
                 %internalGlobalOptions,
                 %defaultGlobalFlags,
                 %defaultGlobalOptions,
             },
             # Module options are stored under here as well, keyed by module->name()
         },
         # This one replaces ksb::Module::{phases}
         phases  => ksb::PhaseList->new(@DefaultPhases),
         errors  => {
             # A map from module *names* (as in modules[] above) to the
             # phase name at which they failed.
         },
         logPaths=> {
             # Holds a hash table of log path bases as expanded by
             # getSubdirPath (e.g. [source-dir]/log) to the actual log dir
             # *this run*, with the date and unique id added. You must still
             # add the module name to use.
         },
         rcFiles => [@rcfiles],
         rcFile  => undef,
         env     => { },
         persistent_options => { }, # These are kept across multiple script runs
         ignore_list => [ ], # List of KDE project paths to ignore completely
         kde_projects_metadata     => undef, # Enumeration of kde-projects
         kde_dependencies_metadata => undef, # Dependency resolution of kde-projects
         logical_module_resolver   => undef, # For branch-group option
         status_monitor => ksb::StatusMonitor->new(),
         projects_db => undef, # See getProjectDataReader
     );
 
     # Merge all new options into our self-hash.
     @{$self}{keys %newOpts} = values %newOpts;
     $self->{options} = $self->{build_options}{global};
 
     assert_isa($self, 'ksb::Module');
     assert_isa($self, 'ksb::BuildContext');
 
     return $self;
 }
 
 # Gets the ksb::PhaseList for this context, and optionally sets it first to
 # the ksb::PhaseList passed in.
 sub phases
 {
     my ($self, $phases) = @_;
 
     if ($phases) {
         confess("Invalid type, expected PhaseList")
             unless $phases->isa('ksb::PhaseList');
         $self->{phases} = $phases;
     }
     return $self->{phases};
 }
 
 sub addModule
 {
     my ($self, $module) = @_;
     Carp::confess("No module to push") unless $module;
 
     my $path;
     if (list_has($self->{modules}, $module)) {
         debug("Skipping duplicate module ", $module->name());
     }
     # TODO: Shouldn't this support all modules, not just 'proj' modules?
     elsif ($module->scmType() eq 'proj' &&
            ($path = $module->fullProjectPath()) &&
         # See if the name matches any given in the ignore list.
            any(sub { $path =~ /(^|\/)$_($|\/)/ }, $self->{ignore_list}))
     {
         debug("Skipping ignored module $module");
     }
     else {
         debug("Adding $module to module list");
         push @{$self->{modules}}, $module;
     }
 }
 
 # Returns a listref of the modules to build
 sub moduleList
 {
     my $self = shift;
     return $self->{modules};
 }
 
 # Adds a list of modules to ignore processing on completely.
 # Parameters should simply be a list of KDE project paths to ignore,
 # e.g. 'extragear/utils/kdesrc-build'. Partial paths are acceptable, matches
 # are determined by comparing the path provided to the suffix of the full path
 # of modules being compared.  See KDEProjectsReader::_projectPathMatchesWildcardSearch
 #
 # Existing items on the ignore list are not removed.
 sub addToIgnoreList
 {
     my $self = shift;
     push @{$self->{ignore_list}}, @_;
 }
 
 sub setupOperatingEnvironment
 {
     my $self = shift;
     # Set the process priority
     POSIX::nice(int $self->getOption('niceness'));
 
     # Set the IO priority if available.
     if ($self->getOption('use-idle-io-priority')) {
         # -p $$ is our PID, -c3 is idle priority
         # 0 return value means success
         if (safe_system('ionice', '-c3', '-p', $$) != 0) {
             warning (" b[y[*] Unable to lower I/O priority, continuing...");
         }
     }
 
     # Get ready for logged output.
     ksb::Debug::setLogFile($self->getLogDirFor($self) . '/build-log');
 
     # Propagate HTTP proxy through environment unless overridden.
     if ((my $proxy = $self->getOption('http-proxy')) &&
         !defined $ENV{'http_proxy'})
     {
         $self->queueEnvironmentVariable('http_proxy', $proxy);
     }
 }
 
 # Clears the list of environment variables to set for log_command runs.
 sub resetEnvironment
 {
     my $self = assert_isa(shift, 'ksb::BuildContext');
     $self->{env} = { };
 }
 
 # Adds an environment variable and value to the list of environment
 # variables to apply for the next subprocess execution.
 #
 # Note that these changes are /not/ reflected in the current environment,
 # so if you are doing something that requires that kind of update you
 # should do that yourself (but remember to have some way to restore the old
 # value if necessary).
 #
 # In order to keep compatibility with the old 'setenv' sub, no action is
 # taken if the value is not equivalent to boolean true.
 sub queueEnvironmentVariable
 {
     my $self = assert_isa(shift, 'ksb::BuildContext');
     my ($key, $value) = @_;
 
     return unless $value;
 
     debug ("\tQueueing g[$key] to be set to y[$value]");
     $self->{env}->{$key} = $value;
 }
 
 # Applies all changes queued by queueEnvironmentVariable to the actual
 # environment irretrievably. Use this before exec()'ing another child, for
 # instance.
 sub commitEnvironmentChanges
 {
     my $self = assert_isa(shift, 'ksb::BuildContext');
 
     while (my ($key, $value) = each %{$self->{env}}) {
         $ENV{$key} = $value;
         debug ("\tSetting environment variable g[$key] to g[b[$value]");
     }
 }
 
 # Adds the given library paths to the path already given in an environment
 # variable. In addition, detected "system paths" are stripped to ensure
 # that we don't inadvertently re-add a system path to be promoted over the
 # custom code we're compiling (for instance, when a system Qt is used and
 # installed to /usr).
 #
 # If the environment variable to be modified has already been queued using
 # queueEnvironmentVariable, then that (queued) value will be modified and
 # will take effect with the next forked subprocess.
 #
 # Otherwise, the current environment variable value will be used, and then
 # queued. Either way the current environment will be unmodified afterward.
 #
 # First parameter is the name of the environment variable to modify
 # All remaining parameters are prepended to the current environment path, in
 # the order given. (i.e. param1, param2, param3 ->
 # param1:param2:param3:existing)
 sub prependEnvironmentValue
 {
     my $self = assert_isa(shift, 'ksb::BuildContext');
     my ($envName, @items) = @_;
     my @curPaths = split(':', $self->{env}->{$envName} // $ENV{$envName} // '');
 
     # Filter out entries to add that are already in the environment from
     # the system.
     for my $path (grep { list_has(\@curPaths, $_) } (@items) ) {
         debug ("\tNot prepending y[$path] to y[$envName] as it appears " .
               "to already be defined in y[$envName].");
     }
 
     @items = grep { not list_has(\@curPaths, $_); } (@items);
 
     my $envValue = join(':', @items, @curPaths);
 
     $envValue =~ s/^:*//;
     $envValue =~ s/:*$//; # Remove leading/trailing colons
     $envValue =~ s/:+/:/; # Remove duplicate colons
 
     $self->queueEnvironmentVariable($envName, $envValue);
 }
 
 # Tries to take the lock for our current base directory, which currently is
 # what passes for preventing people from accidentally running kdesrc-build
 # multiple times at once.  The lock is based on the base directory instead
 # of being global to allow for motivated and/or brave users to properly
 # configure kdesrc-build to run simultaneously with different
 # configurations.
 #
 # Return value is a boolean success flag.
 sub takeLock
 {
     my $self = assert_isa(shift, 'ksb::BuildContext');
     my $baseDir = $self->baseConfigDirectory();
     my $lockfile = "$baseDir/$LOCKFILE_NAME";
 
     $! = 0; # Force reset to non-error status
     sysopen LOCKFILE, $lockfile, O_WRONLY | O_CREAT | O_EXCL;
     my $errorCode = $!; # Save for later testing.
 
     if ($errorCode == EEXIST)
     {
         # Path already exists, read the PID and see if it belongs to a
         # running process.
         open (my $pidFile, "<", $lockfile) or do
         {
             # Lockfile is there but we can't open it?!?  Maybe a race
             # condition but I have to give up somewhere.
             warning (" WARNING: Can't open or create lockfile r[$lockfile]");
             return 1;
         };
 
         my $pid = <$pidFile>;
         close $pidFile;
 
         if ($pid)
         {
             # Recent kdesrc-build; we wrote a PID in there.
             chomp $pid;
 
             # See if something's running with this PID.
             if (kill(0, $pid) == 1)
             {
                 # Something *is* running, likely kdesrc-build.  Don't use error,
                 # it'll scan for $!
                 print ksb::Debug::colorize(" r[*y[*r[*] kdesrc-build appears to be running.  Do you want to:\n");
                 print ksb::Debug::colorize("  (b[Q])uit, (b[P])roceed anyways?: ");
 
                 my $choice = <STDIN> // '';
                 chomp $choice;
 
                 if (lc $choice ne 'p')
                 {
                     say ksb::Debug::colorize(" y[*] kdesrc-build run canceled.");
                     return 0;
                 }
 
                 # We still can't grab the lockfile, let's just hope things
                 # work out.
                 note (" y[*] kdesrc-build run in progress by user request.");
                 return 1;
             }
 
             # If we get here, then the program isn't running (or at least not
             # as the current user), so allow the flow of execution to fall
             # through below and unlink the lockfile.
         } # pid
 
         # No pid found, optimistically assume the user isn't running
         # twice.
         warning (" y[WARNING]: stale kdesrc-build lockfile found, deleting.");
         unlink $lockfile;
 
         sysopen (LOCKFILE, $lockfile, O_WRONLY | O_CREAT | O_EXCL) or do {
             error (" r[*] Still unable to lock $lockfile, proceeding anyways...");
             return 1;
         };
 
         # Hope the sysopen worked... fall-through
     }
     elsif ($errorCode == ENOTTY)
     {
         # Stupid bugs... normally sysopen will return ENOTTY, not sure who's to blame between
         # glibc and Perl but I know that setting PERLIO=:stdio in the environment "fixes" things.
         ; # pass
     }
     elsif ($errorCode != 0) # Some other error occurred.
     {
         warning (" r[*]: Error $errorCode while creating lock file (is $baseDir available?)");
         warning (" r[*]: Continuing the script for now...");
 
         # Even if we fail it's generally better to allow the script to proceed
         # without being a jerk about things, especially as more non-CLI-skilled
         # users start using kdesrc-build to build KDE.
         return 1;
     }
 
     say LOCKFILE "$$";
     close LOCKFILE;
 
     return 1;
 }
 
 # Releases the lock obtained by takeLock.
 sub closeLock
 {
     my $self = assert_isa(shift, 'ksb::BuildContext');
     my $baseDir = $self->baseConfigDirectory();
     my $lockFile = "$baseDir/$LOCKFILE_NAME";
 
     unlink ($lockFile) or warning(" y[*] Failed to close lock: $!");
 }
 
 # This subroutine accepts a Module parameter, and returns the log directory
 # for it. You can also pass a BuildContext (including this one) to get the
 # default log directory.
 #
 # As part of setting up what path to use for the log directory, the
 # 'latest' symlink will also be setup to point to the returned log
 # directory.
 sub getLogDirFor
 {
     my ($self, $module) = @_;
 
     my $baseLogPath = $module->getSubdirPath('log-dir');
     my $logDir;
 
     if (!exists $self->{logPaths}{$baseLogPath}) {
         # No log dir made for this base, do so now.
         my $id = '01';
         my $date = strftime "%F", localtime; # ISO 8601 date
         $id++ while -e "$baseLogPath/$date-$id";
         $self->{logPaths}{$baseLogPath} = "$baseLogPath/$date-$id";
     }
 
     $logDir = $self->{logPaths}{$baseLogPath};
     super_mkdir($logDir);
 
     # global logs go to basedir directly
     $logDir .= "/$module" unless $module->isa('ksb::BuildContext');
 
     return $logDir;
 }
 
 # Constructs the appropriate full path to a log file based on the given
 # basename (including extensions). Use this instead of getLogDirFor when you
 # actually intend to create a log, as this function will also adjust the
 # 'latest' symlink properly.
 sub getLogPathFor
 {
     my ($self, $module, $path) = @_;
 
     my $baseLogPath = $module->getSubdirPath('log-dir');
     my $logDir = $self->getLogDirFor($module);
 
     # We create this here to avoid needless empty module directories everywhere
     super_mkdir($logDir);
 
     # Add a symlink to the latest run for this module. 'latest' itself is
     # a directory under the base log directory that holds symlinks mapping
     # each module name to the specific log directory most recently used.
 
     my $latestPath = "$baseLogPath/latest";
 
     # Handle stuff like playground/utils or KDE/kdelibs
     my ($moduleName, $modulePath) = fileparse($module->name());
     $latestPath .= "/$modulePath" if $module->name() =~ m(/);
 
     super_mkdir($latestPath);
 
     my $symlink = "$latestPath/$moduleName";
 
     if (-l $symlink and readlink($symlink) ne $logDir)
     {
         unlink($symlink);
         symlink($logDir, $symlink);
     }
     elsif(not -e $symlink)
     {
         # Create symlink initially if we've never done it before.
         symlink($logDir, $symlink);
     }
 
     return "$logDir/$path";
 }
 
 # Returns rc file in use. Call loadRcFile first.
 sub rcFile
 {
     my $self = shift;
     return $self->{rcFile};
 }
 
 # Forces the rc file to be read from to be that given by the first
 # parameter.
 sub setRcFile
 {
     my ($self, $file) = @_;
     $self->{rcFiles} = [$file];
     $self->{rcFile} = undef;
 }
 
 # Returns an open filehandle to the user's chosen rc file.  Use setRcFile
 # to choose a file to load before calling this function, otherwise
 # loadRcFile will search the default search path.  After this function is
 # called, rcFile() can be used to determine which file was loaded.
 #
 # If unable to find or open the rc file an exception is raised. Empty rc
 # files are supported however.
 sub loadRcFile
 {
     my $self = shift;
     my @rcFiles = @{$self->{rcFiles}};
     my $fh;
 
     for my $file (@rcFiles)
     {
         if (open ($fh, '<', "$file"))
         {
             $self->{rcFile} = File::Spec->rel2abs($file);
             return $fh;
         }
     }
 
     # No rc found, check if we can use default.
     if (scalar @rcFiles == 1)
     {
         # This can only happen if the user uses --rc-file, so if we fail to
         # load the file, we need to fail to load at all.
         my $failedFile = $rcFiles[0];
 
         error (<<EOM);
 Unable to open config file $failedFile
 
 Script stopping here since you specified --rc-file on the command line to
 load $failedFile manually.  If you wish to run the script with no configuration
 file, leave the --rc-file option out of the command line.
 
 If you want to force an empty rc file, use --rc-file /dev/null
 
 EOM
         croak_runtime("Missing $failedFile");
     }
 
     # If no configuration but no --rc-file option was used, warn the user
     # and fail, as there are too many possible modes of using kdesrc-build
     # for kdesrc-buildrc-sample to be appropriate.
 
     error (<<EOM);
 b[No configuration file is present.]
 
 kdesrc-build requires a configuration file to select which KDE software modules
 to build, what options to build them with, the path to install to, etc.
 
 kdesrc-build looks for its configuration in the file `kdesrc-buildrc' in
 whatever directory kdesrc-build is run from.
 
 If no such file exists, kdesrc-build tries to use `~/.kdesrc-buildrc' (note the
 leading `.')
 
 A sample configuration suitable for KDE 4 software is included at the file
 `kdesrc-buildrc-sample' which can be copied to the correct location and then
 edited.
 
 KDE Frameworks 5 users can use the `kdesrc-buildrc-kf5-sample' file which can
 be copied to the correct location and then edited.
 
 In either case b[once the configuration file is setup to your liking], you
 should run:
 b[kdesrc-build --metadata-only]
 
 to download needed information about the KDE source repositories and then:
 b[kdesrc-build --pretend]
 
 to preview what kdesrc-build will do.
 EOM
     croak_runtime("No configuration available");
 }
 
 # Returns the base directory that holds the configuration file. This is
 # typically used as the directory base for other necessary kdesrc-build
 # execution files, such as the persistent data store and lock file.
 #
 # The RC file must have been found and loaded first, obviously.
 sub baseConfigDirectory
 {
     my $self = assert_isa(shift, 'ksb::BuildContext');
     my $rcfile = $self->rcFile() or
         croak_internal("Call to baseConfigDirectory before loadRcFile");
 
     return dirname($rcfile);
 }
 
 sub modulesInPhase
 {
     my ($self, $phase) = @_;
     my @list = grep { list_has([$_->phases()->phases()], $phase) } (@{$self->moduleList()});
     return @list;
 }
 
 # Searches for a module with a name that matches the provided parameter,
 # and returns its ksb::Module object. Returns undef if no match was found.
 # As a special-case, returns the BuildContext itself if the name passed is
 # 'global', since the BuildContext also is a (in the "is-a" OOP sense)
 # ksb::Module, specifically the 'global' one.
 sub lookupModule
 {
     my ($self, $moduleName) = @_;
 
     return $self if $moduleName eq 'global';
 
     my @options = grep { $_->name() eq $moduleName } (@{$self->moduleList()});
     return undef unless @options;
 
     if (scalar @options > 1) {
         croak_internal("Detected 2 or more $moduleName ksb::Module objects");
     }
 
     return $options[0];
 }
 
 sub markModulePhaseSucceeded
 {
-    my ($self, $phase, $module) = @_;
+    my ($self, $phase, $module, $extras) = @_;
     assert_isa($module, 'ksb::Module');
 
     my $name = $module->name();
-    $self->{status_monitor}->markPhaseComplete($name, $phase, 'success');
+    $extras //= { };
+    $self->{status_monitor}->markPhaseComplete($name, $phase, 'success', %{$extras});
 }
 
 sub markModulePhaseFailed
 {
     my ($self, $phase, $module) = @_;
     assert_isa($module, 'ksb::Module');
 
     my $name = $module->name();
     my %details;
 
     if ((my $log = $module->getOption('#error-log-file', 'module'))) {
         $details{error_log}  = "/error_log/$name";
         $details{error_file} = $log;
     }
 
     $self->{status_monitor}->markPhaseComplete($name, $phase, 'error', %details);
     $self->{errors}->{$name} = $phase;
 }
 
 # Returns a list (i.e. not a reference to, but a real list) of Modules that failed to
 # complete the given phase.
 sub failedModulesInPhase
 {
     my ($self, $phase) = @_;
 
     my @failures = grep {
         ($self->{errors}->{$_->name()} // '') eq $phase
     } (@{$self->moduleList()});
 
     return @failures;
 }
 
 # Returns true if the given module had a failure in any phase
 sub hasModuleFailed
 {
     my ($self, $module) = @_;
 
     return exists $self->{errors}->{$module->name()};
 }
 
 # Returns a list of modules that had a failure of some sort, in the order the modules
 # are listed in our current module list.
 sub listFailedModules
 {
     my $self = shift;
     my @modules = @{$self->moduleList()};
 
     # grepping for failures instead of returning error list directly maintains ordering
     @modules = grep {
         exists $self->{errors}->{$_->name()}
     } (@modules);
 
     return @modules;
 }
 
 # OVERRIDE: Our immediate parent class Module overrides this, but we actually
 # want the OptionsBase version to be used instead, until we break the recursive
 # use of Module's own getOption calls on our getOption.
 sub getOption
 {
     &ksb::OptionsBase::getOption;
 }
 
 # OVERRIDE: Overrides OptionsBase::setOption to handle some global-only options.
 sub setOption
 {
     my ($self, %options) = @_;
 
     # Special-case handling
     my $repoOption = 'git-repository-base';
     if (exists $options{$repoOption}) {
         my $value = $options{$repoOption};
         my ($repo, $url) = ($value =~ /^([a-zA-Z0-9_-]+)\s+(.+)$/);
 
         # This will be a hash reference instead of a scalar
         $value = $self->getOption($repoOption) || { };
 
         if (!$repo || !$url) {
             die ksb::BuildException::Config->new($repoOption,
                 "Invalid git-repository-base setting: $value");
         }
 
         $value->{$repo} = $url;
         delete $options{$repoOption};
     }
 
     # Actually set options.
     $self->SUPER::setOption(%options);
 
     # Automatically respond to various global option changes.
     while (my ($key, $value) = each %options) {
         my $normalizedKey = $key;
         $normalizedKey =~ s/^#//; # Remove sticky key modifier.
         given ($normalizedKey) {
             when ('colorful-output') { ksb::Debug::setColorfulOutput($value); }
             when ('debug-level')     { ksb::Debug::setDebugLevel($value); }
             when ('pretend')         { ksb::Debug::setPretending($value); }
         }
     }
 }
 
 #
 # Persistent option handling
 #
 
 # Returns the name of the file to use for persistent data.
 # Supports expanding '#' at the beginning of the filename to the directory
 # containing the rc-file in use, but only for the default name at this
 # point.
 sub persistentOptionFileName
 {
     my $self = shift;
     my $filename = $self->getOption('persistent-data-file');
 
     if (!$filename) {
         $filename = $PERSISTENT_FILE_NAME;
         my $dir = $self->baseConfigDirectory();
         $filename =~ s/^#/$dir/;
     }
     else {
         # Tilde-expand
         $filename =~ s/^~\//$ENV{HOME}\//;
     }
 
     return $filename;
 }
 
 # Reads in all persistent options from the file where they are kept
 # (.kdesrc-build-data) for use in the program.
 #
 # The directory used is the same directory that contains the rc file in use.
 sub loadPersistentOptions
 {
     my $self = assert_isa(shift, 'ksb::BuildContext');
     my $fh = IO::File->new($self->persistentOptionFileName(), '<');
 
     return unless $fh;
 
     # $persistent_data should be a JSON object which we can store directly as a
     # hash.
     my $persistent_data;
     {
         local $/ = undef; # Read in whole file with <> operator.
         $persistent_data = <$fh>;
     }
 
     my $persistent_options = decode_json($persistent_data);
 
     # We need to keep persistent data with the context instead of with the
     # applicable modules since otherwise we might forget to write out
     # persistent data for modules we didn't build in this run. So, we just
     # store it all.
     # Layout of this data:
     #  $self->persistent_options = {
     #    'module-name' => {
     #      option => value,
     #      # foreach option/value pair
     #    },
     #    # foreach module
     #  }
     $persistent_options = {} if ref $persistent_options ne 'HASH';
     $self->{persistent_options} = $persistent_options;
 }
 
 # Writes out the persistent options to the file .kdesrc-build-data.
 #
 # The directory used is the same directory that contains the rc file in use.
 sub storePersistentOptions
 {
     my $self = assert_isa(shift, 'ksb::BuildContext');
     return if pretending();
 
     my $fh = IO::File->new($self->persistentOptionFileName(), '>');
 
     if (!$fh)
     {
         error ("Unable to save persistent module data: b[r[$!]");
         return;
     }
 
     my $encodedJSON = encode_json ($self->{persistent_options});
     print $fh $encodedJSON;
     undef $fh; # Closes the file
 }
 
 # Returns the value of a "persistent" option (normally read in as part of
 # startup), or undef if there is no value stored.
 #
 # First parameter is the module name to get the option for, or 'global' if
 # not for a module.
 #     Note that unlike setOption/getOption, no inheritance is done at this
 #     point so if an option is present globally but not for a module you
 #     must check both if that's what you want.
 # Second parameter is the name of the value to retrieve (i.e. the key)
 sub getPersistentOption
 {
     my ($self, $moduleName, $key) = @_;
     my $persistent_opts = $self->{persistent_options};
 
     # We must check at each level of indirection to avoid
     # "autovivification"
     return unless exists $persistent_opts->{$moduleName};
     return unless exists $persistent_opts->{$moduleName}{$key};
 
     return $persistent_opts->{$moduleName}{$key};
 }
 
 # Clears a persistent option if set (for a given module and option-name).
 #
 # First parameter is the module name to get the option for, or 'global' for
 # the global options.
 # Second parameter is the name of the value to clear.
 # No return value.
 sub unsetPersistentOption
 {
     my ($self, $moduleName, $key) = @_;
     my $persistent_opts = $self->{persistent_options};
 
     if (exists $persistent_opts->{$moduleName} &&
         exists $persistent_opts->{$moduleName}->{$key})
     {
         delete $persistent_opts->{$moduleName}->{$key};
     }
 }
 
 # Sets a "persistent" option which will be read in for a module when
 # kdesrc-build starts up and written back out at (normal) program exit.
 #
 # First parameter is the module name to set the option for, or 'global'.
 # Second parameter is the name of the value to set (i.e. key)
 # Third parameter is the value to store, which must be a scalar.
 sub setPersistentOption
 {
     my ($self, $moduleName, $key, $value) = @_;
     my $persistent_opts = $self->{persistent_options};
 
     # Initialize empty hash ref if nothing defined for this module.
     $persistent_opts->{$moduleName} //= { };
 
     $persistent_opts->{$moduleName}{$key} = $value;
 }
 
 # Returns the ksb::Module (which has a 'metadata' scm type) that is used for
 # kde-build-metadata, so that other modules that need it can call into it if
 # necessary.
 #
 # Also may return undef if the metadata is unavailable or has not yet
 # been set by setKDEDependenciesMetadataModule (this method does not
 # automatically create the needed module).
 sub getKDEDependenciesMetadataModule
 {
     my $self = shift;
     return $self->{kde_dependencies_metadata};
 }
 
 # Returns the ksb::Module (which has a 'metadata' scm type) that is used for
 # kde-project metadata, so that other modules that need it can call into it if
 # necessary.
 #
 # Also may return undef if the metadata is unavailable or has not yet
 # been set by setKDEProjectsMetadataModule (this method does not
 # automatically create the needed module).
 sub getKDEProjectsMetadataModule
 {
     my $self = shift;
     return $self->{kde_projects_metadata};
 }
 
 # Call this method to force this build context to pull in the kde-build-metadata
 # module. This is a one-time action, subsequent calls to this method
 # are ignored. Use getKDEDependenciesMetadataModule to see if this build context is
 # using a metadata module.
 #
 # This method should be called before setModuleList.
 sub setKDEDependenciesMetadataModuleNeeded
 {
     my $self = assert_isa(shift, 'ksb::BuildContext');
 
     return if defined $self->{kde_dependencies_metadata};
 
     my $metadata = ksb::ModuleSet::KDEProjects::getDependenciesModule($self);
 
     debug ("Introducing dependency metadata into the build");
     assert_isa($metadata->scm(), 'ksb::Updater::KDEProjectMetadata');
 
     $self->{kde_dependencies_metadata} = $metadata;
     return;
 }
 
 # Call this method to force this build context to pull in the
 # sysadmin/repo-metadata module. This is a one-time action,
 # subsequent calls to this method are ignored. Use
 # getKDEProjectsMetadataModule to see if this build context is using
 # a metadata module.
 #
 # This method should be called before setModuleList.
 sub setKDEProjectsMetadataModuleNeeded
 {
     my $self = assert_isa(shift, 'ksb::BuildContext');
 
     return if defined $self->{kde_projects_metadata};
 
     my $metadata = ksb::ModuleSet::KDEProjects::getProjectMetadataModule($self);
 
     debug ("Introducing project enumeration metadata into the build");
     assert_isa($metadata->scm(), 'ksb::Updater::KDEProjectMetadata');
 
     $self->{kde_projects_metadata} = $metadata;
     return;
 }
 
 # Returns a KDEProjectsReader module, which has already read in the database and
 # is ready to be queried. Note that exceptions can be thrown in the process
 # of downloading and parsing the database information, so be ready for that.
 sub getProjectDataReader
 {
     my $self = shift;
 
     return $self->{projects_db} if $self->{projects_db};
 
     my $projectDatabaseModule = $self->getKDEProjectsMetadataModule() or
         croak_runtime("kde-projects repository information could not be downloaded: $!");
 
     my $protocol = $self->getOption('git-desired-protocol') || 'git';
     if (!list_has(['git', 'http', 'https'], $protocol)) {
         error (" b[y[*] Invalid b[git-desired-protocol] $protocol");
         error (" b[y[*] Try setting this option to 'git' if you're not using a proxy");
         croak_runtime ("Invalid git-desired-protocol: $protocol");
     }
 
     $self->{projects_db} = ksb::KDEProjectsReader->new($projectDatabaseModule, $protocol);
     return $self->{projects_db};
 }
 
 # Returns the effective branch group to use for modules. You should not call
 # this unless kde-build-metadata is also in use (see
 # setKDEDependenciesMetadataModule and moduleBranchGroupResolver).
 sub effectiveBranchGroup
 {
     my $self = shift;
     my $branchGroup = $self->getOption('branch-group', 'module') // '';
 
     if (!$branchGroup) {
         $branchGroup = $self->getOption('use-stable-kde')
             ? 'latest-qt4'
             : ($self->hasOption('use-stable-kde') # Could also be false if unset
                 ? 'kf5-qt5'      # Really set to false
                 : 'latest-qt4'); # Unset / this is default branch group if no option set
     }
 
     return $branchGroup;
 }
 
 # Returns a ksb::Module::BranchGroupResolver which can be used to efficiently
 # determine a git branch to use for a given kde-projects module (when the
 # branch-group option is in use), as specified at
 # https://community.kde.org/Infrastructure/Project_Metadata.
 sub moduleBranchGroupResolver
 {
     my $self = shift;
 
     if (!$self->{logical_module_resolver}) {
         my $metadataModule = $self->getKDEDependenciesMetadataModule();
 
         croak_internal("Tried to use branch-group, but needed data wasn't loaded!")
             unless $metadataModule;
 
         my $resolver = ksb::Module::BranchGroupResolver->new(
             $metadataModule->scm()->logicalModuleGroups());
         $self->{logical_module_resolver} = $resolver;
     }
 
     return $self->{logical_module_resolver};
 }
 
 # An event-based aggregator for update events, to be used by user interfaces,
 # including remote interfaces.
 sub statusMonitor
 {
     my $self = shift;
     return $self->{status_monitor};
 }
 
 1;
diff --git a/modules/ksb/BuildSystem.pm b/modules/ksb/BuildSystem.pm
index 9660d6f..dae89dc 100644
--- a/modules/ksb/BuildSystem.pm
+++ b/modules/ksb/BuildSystem.pm
@@ -1,442 +1,442 @@
 package ksb::BuildSystem 0.30;
 
 # Base module for the various build systems, includes built-in implementations of
 # generic functions and supports hooks for subclasses to provide needed detailed
 # functionality.
 
 use strict;
 use warnings;
 use 5.014;
 
 use ksb::Debug 0.30;
 use ksb::Util;
 use ksb::StatusView;
 
 use List::Util qw(first);
 
 sub new
 {
     my ($class, $module) = @_;
     my $self = bless { module => $module }, $class;
 
     # This is simply the 'default' build system at this point, also used for
     # KF5.
     if ($class ne 'ksb::BuildSystem::KDE4') {
         _maskGlobalBuildSystemOptions($self);
     }
 
     return $self;
 }
 
 # Removes or masks global build system-related options, so that they aren't
 # accidentally picked up for use with our non-default build system.
 # Module-specific options are left intact.
 sub _maskGlobalBuildSystemOptions
 {
     my $self = shift;
     my $module = $self->module();
     my $ctx = $module->buildContext();
     my @buildSystemOptions = qw(
         cmake-options configure-flags custom-build-command cxxflags
         make-options run-tests use-clean-install
     );
 
     for my $opt (@buildSystemOptions) {
         # If an option is present, and not set at module-level, it must be
         # global. Can't use getOption() method due to recursion.
         if ($ctx->{options}->{$opt} && !$module->{options}->{$opt}) {
             $module->{options}->{$opt} = '';
         }
     }
 }
 
 sub module
 {
     my $self = shift;
     return $self->{module};
 }
 
 # Subroutine to determine if a given module needs to have the build system
 # recreated from scratch.
 # If so, it returns a non empty string
 sub needsRefreshed
 {
     my $self = assert_isa(shift, 'ksb::BuildSystem');
     my $module = $self->module();
     my $builddir = $module->fullpath('build');
     my $confFileKey = $self->configuredModuleFileName();
 
     if (not -e "$builddir") {
        return "the build directory doesn't exist";
    }
    if (-e "$builddir/.refresh-me") {
        return "the last configure failed"; # see Module.pm
    }
    if ($module->getOption("refresh-build")) {
        return "the option refresh-build was set";
    }
    if (($module->getPersistentOption('failure-count') // 0) > 1) {
        return "the module has failed to build " . $module->getPersistentOption('failure-count') . " times in a row";
    }
    if (not -e "$builddir/$confFileKey") {
        return "$builddir/$confFileKey is missing";
    }
 
     return "";
 }
 
 # Called by the module being built before it runs its build/install process. Should
 # setup any needed environment variables, build context settings, etc., in preparation
 # for the build and install phases.
 sub prepareModuleBuildEnvironment
 {
     my ($self, $ctx, $module, $prefix) = @_;
 }
 
 # Returns true if the module should have make install run in order to be
 # used, or false if installation is not required or possible.
 sub needsInstalled
 {
     return 1;
 }
 
 # This should return a list of executable names that must be present to
 # even bother attempting to use this build system. An empty list should be
 # returned if there's no required programs.
 sub requiredPrograms
 {
     return;
 }
 
 sub name
 {
     return 'generic';
 }
 
 # Returns a list of possible build commands to run, any one of which should
 # be supported by the build system.
 sub buildCommands
 {
     # Non Linux systems can sometimes fail to build when GNU Make would work,
     # so prefer GNU Make if present, otherwise try regular make.
     return 'gmake', 'make';
 }
 
-# Return value style: boolean
+# Return value style: hashref {was_successful => bool, warnings => int, ...}
 sub buildInternal
 {
     my $self = shift;
 
     return $self->safe_make({
         target => undef,
         message => 'Compiling...',
         'make-options' => [
             split(' ', $self->module()->getOption('make-options')),
         ],
         logbase => 'build',
-    })->{was_successful};
+    });
 }
 
 # Return value style: boolean
 sub configureInternal
 {
     # It is possible to make it here if there's no source dir and if we're
     # pretending. If we're not actually pretending then this should be a
     # bug...
     return 1 if pretending();
 
     croak_internal('We were not supposed to get to this point...');
 }
 
 # Returns name of file that should exist (relative to the module's build directory)
 # if the module has been configured.
 sub configuredModuleFileName
 {
     my $self = shift;
     return 'Makefile';
 }
 
 # Runs the testsuite for the given module.
 # Returns true if a testsuite is present and all tests passed, false otherwise.
 sub runTestsuite
 {
     my $self = shift;
     my $module = $self->module();
 
     whisper ("\ty[$module] does not support the b[run-tests] option");
     return 0;
 }
 
 # Used to install a module (that has already been built, tested, etc.)
 # All options passed are prefixed to the eventual command to be run.
 # Returns boolean false if unable to install, true otherwise.
 sub installInternal
 {
     my $self = shift;
     my $module = $self->module();
     my @cmdPrefix = @_;
 
     return $self->safe_make ({
             target => 'install',
             message => 'Installing..',
             'prefix-options' => [@cmdPrefix],
            })->{was_successful};
 }
 
 # Used to uninstall a previously installed module.
 # All options passed are prefixed to the eventual command to be run.
 # Returns boolean false if unable to uninstall, true otherwise.
 sub uninstallInternal
 {
     my $self = shift;
     my $module = $self->module();
     my @cmdPrefix = @_;
 
     return $self->safe_make ({
             target => 'uninstall',
             message => "Uninstalling g[$module]",
             'prefix-options' => [@cmdPrefix],
            })->{was_successful};
 }
 
 # Subroutine to clean the build system for the given module.  Works by
 # recursively deleting the directory and then recreating it.
 # Returns 0 for failure, non-zero for success.
 sub cleanBuildSystem
 {
     my $self = assert_isa(shift, 'ksb::BuildSystem');
     my $module = $self->module();
     my $srcdir = $module->fullpath('source');
     my $builddir = $module->fullpath('build');
 
     if (pretending())
     {
         pretend ("\tWould have cleaned build system for g[$module]");
         return 1;
     }
 
     # Use an existing directory
     if (-e $builddir && $builddir ne $srcdir)
     {
         whisper ("\tCleaning out build directory");
 
         # This variant of log_command runs the sub prune_under_directory($builddir)
         # in a forked child, so that we can log its output.
         if (log_command($module, 'clean-builddir', [ 'kdesrc-build', 'main::prune_under_directory', $builddir ]))
         {
             error (" r[b[*]\tFailed to clean build directory.  Verify the permissions are correct.");
             return 0; # False for this function.
         }
 
         # Let users know we're done so they don't wonder why rm -rf is taking so
         # long and oh yeah, why's my HD so active?...
         whisper ("\tOld build system cleaned, starting new build system.");
     }
     # or create the directory
     elsif (!super_mkdir ($builddir))
     {
         error ("\tUnable to create directory r[$builddir].");
         return 0;
     }
 
     return 1;
 }
 
 sub needsBuilddirHack
 {
     return 0; # By default all build systems are assumed to be sane
 }
 
 # Return convention: boolean
 sub createBuildSystem
 {
     my $self = assert_isa(shift, 'ksb::BuildSystem');
     my $module = $self->module();
     my $builddir = $module->fullpath('build');
     my $srcdir   = $module->fullpath('source');
 
     if (! -e "$builddir" && !super_mkdir("$builddir"))
     {
         error ("\tUnable to create build directory for r[$module]!!");
         return 0;
     }
 
     if ($builddir ne $srcdir && $self->needsBuilddirHack() && 0 != log_command($module, 'lndir',
             ['kdesrc-build', 'main::safe_lndir', $srcdir, $builddir]))
     {
         error ("\tUnable to setup symlinked build directory for r[$module]!!");
         return 0;
     }
 
     return 1;
 }
 
 # Subroutine to run the build command with the arguments given by the
 # passed hash.
 #
 # Due to the various ways the build command is called by this script, it is
 # required to pass customization options in a hash:
 # {
 #    target         => undef, or a valid build target e.g. 'install',
 #    message        => 'Compiling.../Installing.../etc.'
 #    make-options   => [ list of command line arguments to pass to make. See
 #                        make-options ],
 #    prefix-options => [ list of command line arguments to prefix *before* the
 #                        make command, used for make-install-prefix support for
 #                        e.g. sudo ],
 #    logbase        => 'base-log-filename',
 # }
 #
 # target and message are required. logbase is required if target is left
 # undefined, but otherwise defaults to the same value as target.
 #
 # Note that the make command is based on the results of the 'buildCommands'
 # subroutine which should be overridden if necessary by subclasses. Each
 # command should be the command name (i.e. no path). The user may override
 # the command used (for build only) by using the 'custom-build-command'
 # option.
 #
 # The first command name found which resolves to an executable on the
 # system will be used, if no command this function will fail.
 #
 # The first argument should be the ksb::Module object to be made.
 # The second argument should be the reference to the hash described above.
 #
 # Returns a hashref:
 # {
 #   was_successful => $bool, (if successful)
 # }
 sub safe_make (@)
 {
     my ($self, $optsRef) = @_;
     assert_isa($self, 'ksb::BuildSystem');
     my $module = $self->module();
 
     # Convert the path to an absolute path since I've encountered a sudo
     # that is apparently unable to guess.  Maybe it's better that it
     # doesn't guess anyways from a security point-of-view.
     my $buildCommand = first { absPathToExecutable($_) } $self->buildCommands();
     my @buildCommandLine = $buildCommand;
 
     # Check for custom user command. We support command line options being
     # passed to the command as well.
     my $userCommand = $module->getOption('custom-build-command');
     if ($userCommand) {
         @buildCommandLine = split_quoted_on_whitespace($userCommand);
         $buildCommand = absPathToExecutable($buildCommandLine[0]);
     }
 
     if (!$buildCommand) {
         $buildCommand = $userCommand || $self->buildCommands();
         error (" r[b[*] Unable to find the g[$buildCommand] executable!");
         return { was_successful => 0 };
     }
 
     # Make it prettier if pretending (Remove leading directories).
     $buildCommand =~ s{^/.*/}{} if pretending();
     shift @buildCommandLine; # $buildCommand is already the first entry.
 
     # Simplify code by forcing lists to exist.
     $optsRef->{'prefix-options'} //= [ ];
     $optsRef->{'make-options'} //= [ ];
 
     my @prefixOpts = @{$optsRef->{'prefix-options'}};
 
     # If using sudo ensure that it doesn't wait on tty, but tries to read from
     # stdin (which should fail as we redirect that from /dev/null)
     if (@prefixOpts && $prefixOpts[0] eq 'sudo' && !grep { /^-S$/ } @prefixOpts)
     {
         splice (@prefixOpts, 1, 0, '-S'); # Add -S right after 'sudo'
     }
 
     # Assemble arguments
     my @args = (@prefixOpts, $buildCommand, @buildCommandLine);
     push @args, $optsRef->{target} if $optsRef->{target};
     push @args, @{$optsRef->{'make-options'}};
 
     # Will be output by _runBuildCommand
     my $buildMessage = $optsRef->{message};
     my $logname = $optsRef->{logbase} // $optsRef->{logfile} // $optsRef->{target};
     p_chdir ($module->fullpath('build'));
 
     return $self->_runBuildCommand($buildMessage, $logname, \@args);
 }
 
 # Subroutine to run make and process the build process output in order to
 # provide completion updates.  This procedure takes the same arguments as
 # log_command() (described here as well), except that the callback argument
 # is not used.
 #
 # First parameter is the message to display to the user while the build
 #   happens.
 # Second parameter is the name of the log file to use (relative to the log
 #   directory).
 # Third parameter is a reference to an array with the command and its
 #   arguments.  i.e. ['command', 'arg1', 'arg2']
 #
 # The return value is a hashref as defined by safe_make
 sub _runBuildCommand
 {
     my ($self, $message, $filename, $argRef) = @_;
     my $module = $self->module();
     my $resultRef = { was_successful => 0 };
     my $ctx = $module->buildContext();
 
     # There are situations when we don't want progress output:
     # 1. If we're not printing to a terminal.
     # 2. When we're debugging (we'd interfere with debugging output).
     if (! -t STDERR || debugging())
     {
         $resultRef->{was_successful} = (0 == log_command($module, $filename, $argRef));
         return $resultRef;
     }
 
     # TODO More details
     my $warnings = 0;
 
     my $log_command_callback = sub {
         state $oldX = -1;
         state $oldY = -1;
 
         my $input = shift;
         return if not defined $input;
 
+        $warnings++ if ($input =~ /warning: /);
+
         my ($x, $y);
         my ($percentage) = ($input =~ /^\[\s*([0-9]+)%]/);
         if ($percentage) {
             $x = int $percentage; $y = 100;
         }
         else {
             # ninja-syntax
             my ($newX, $newY) = ($input =~ /^\[([0-9]+)\/([0-9]+)] /);
             return unless ($newX && $newY);
 
             ($x, $y) = (int $newX, int $newY);
         }
 
         if ($x != $oldX || $y != $oldY) {
             ksb::Debug::reportProgressToParent($module, $x, $y);
         }
-
-        $warnings++ if ($input =~ /warning: /);
     };
 
     $resultRef->{was_successful} =
         (0 == log_command($module, $filename, $argRef, {
             callback => $log_command_callback
         }));
     $resultRef->{warnings} = $warnings;
 
     if ($warnings) {
         my $count = ($warnings < 3  ) ? 1 :
                     ($warnings < 10 ) ? 2 :
                     ($warnings < 30 ) ? 3 : 4;
         my $msg = sprintf("%s b[y[$warnings] %s", '-' x $count, '-' x $count);
         note ("\tNote: $msg compile warnings");
         $self->{module}->setPersistentOption('last-compile-warnings', $warnings);
     }
 
     return $resultRef;
 }
 
 1;
diff --git a/modules/ksb/Module.pm b/modules/ksb/Module.pm
index 1391541..2da37c9 100644
--- a/modules/ksb/Module.pm
+++ b/modules/ksb/Module.pm
@@ -1,1168 +1,1174 @@
 package ksb::Module 0.20;
 
 # Class: Module
 #
 # Represents a source code module of some sort, which can be updated, built,
 # and installed. Includes a stringifying overload and can be sorted amongst
 # other ksb::Modules.
 
 use 5.014;
 use warnings;
 no if $] >= 5.018, 'warnings', 'experimental::smartmatch';
 
 use parent qw(ksb::OptionsBase);
 
 use ksb::Debug;
 use ksb::Util;
 
 use ksb::Updater::Svn;
 use ksb::Updater::Git;
 use ksb::Updater::Bzr;
 use ksb::Updater::KDEProject;
 use ksb::Updater::KDEProjectMetadata;
 
 use ksb::BuildException 0.20;
 
 use ksb::BuildSystem 0.30;
 use ksb::BuildSystem::Autotools;
 use ksb::BuildSystem::QMake;
 use ksb::BuildSystem::Qt4;
 use ksb::BuildSystem::KDE4;
 use ksb::BuildSystem::CMakeBootstrap;
 
 use ksb::ModuleSet::Null;
 
 use Mojo::Promise;
 use Mojo::IOLoop;
 
 use POSIX qw(_exit :errno_h);
 use Storable qw(dclone thaw);
 use Carp 'confess';
 use Scalar::Util 'blessed';
 use overload
     '""' => 'toString', # Add stringify operator.
     '<=>' => 'compare',
     ;
 
 my $ModuleSource = 'config';
 
 sub new
 {
     my ($class, $ctx, $name) = @_;
 
     croak_internal ("Empty ksb::Module constructed") unless $name;
 
     my $self = ksb::OptionsBase::new($class);
 
     # If building a BuildContext instead of a ksb::Module, then the context
     # can't have been setup yet...
     my $contextClass = 'ksb::BuildContext';
     if ($class ne $contextClass &&
         (!blessed($ctx) || !$ctx->isa($contextClass)))
     {
         croak_internal ("Invalid context $ctx");
     }
 
     # Clone the passed-in phases so we can be different.
     my $phases = dclone($ctx->phases()) if $ctx;
 
     my %newOptions = (
         name         => $name,
         scm_obj      => undef,
         build_obj    => undef,
         phases       => $phases,
         context      => $ctx,
         'module-set' => undef,
     );
 
     $self->installPhasePromises() if $class eq 'ksb::Module';
 
     # alias our options into the build context for global vis
     $ctx->{build_options}->{$name} = $self->{options};
 
     @{$self}{keys %newOptions} = values %newOptions;
 
     return $self;
 }
 
 sub phases
 {
     my $self = shift;
     return $self->{phases};
 }
 
 sub moduleSet
 {
     my ($self) = @_;
     $self->{'module-set'} //= ksb::ModuleSet::Null->new();
     return $self->{'module-set'};
 }
 
 sub setModuleSet
 {
     my ($self, $moduleSetName) = @_;
     $self->{'module-set'} = $moduleSetName;
 }
 
 sub setModuleSource
 {
     my ($class, $source) = @_;
     $ModuleSource = $source;
 }
 
 sub moduleSource
 {
     my $class = shift;
     # Should be 'config' or 'cmdline';
     return $ModuleSource;
 }
 
 # Subroutine to retrieve a subdirectory path with tilde-expansion and
 # relative path handling.
 # The parameter is the option key (e.g. build-dir or log-dir) to read and
 # interpret.
 sub getSubdirPath
 {
     my ($self, $subdirOption) = @_;
     my $dir = $self->getOption($subdirOption);
 
     # If build-dir starts with a slash, it is an absolute path.
     return $dir if $dir =~ /^\//;
 
     # Make sure we got a valid option result.
     if (!$dir) {
         confess ("Reading option for $subdirOption gave empty \$dir!");
     }
 
     # If it starts with a tilde, expand it out.
     if ($dir =~ /^~/)
     {
         $dir =~ s/^~/$ENV{'HOME'}/;
     }
     else
     {
         # Relative directory, tack it on to the end of $kdesrcdir.
         my $kdesrcdir = $self->getOption('source-dir');
         $dir = "$kdesrcdir/$dir";
     }
 
     return $dir;
 }
 
 # Method: getInstallPathComponents
 #
 # Returns the directory that a module should be installed in.
 #
 # NOTE: The return value is a hash. The key 'module' will return the final
 # module name, the key 'path' will return the full path to the module. The
 # key 'fullpath' will return their concatenation.
 #
 # For example, with $module == 'KDE/kdelibs', and no change in the dest-dir
 # option, you'd get something like:
 #
 # > {
 # >   'path'     => '/home/user/kdesrc/KDE',
 # >   'module'   => 'kdelibs',
 # >   'fullpath' => '/home/user/kdesrc/KDE/kdelibs'
 # > }
 #
 # If dest-dir were changed to e.g. extragear-multimedia, you'd get:
 #
 # > {
 # >   'path'     => '/home/user/kdesrc',
 # >   'module'   => 'extragear-multimedia',
 # >   'fullpath' => '/home/user/kdesrc/extragear-multimedia'
 # > }
 #
 # Parameters:
 #   pathType - Either 'source' or 'build'.
 #
 # Returns:
 #   hash (Not a hashref; See description).
 sub getInstallPathComponents
 {
     my $module = assert_isa(shift, 'ksb::Module');
     my $type = shift;
     my $destdir = $module->destDir();
     my $srcbase = $module->getSourceDir();
     $srcbase = $module->getSubdirPath('build-dir') if $type eq 'build';
 
     my $combined = "$srcbase/$destdir";
 
     # Remove dup //
     $combined =~ s/\/+/\//;
 
     my @parts = split(/\//, $combined);
     my %result = ();
     $result{'module'} = pop @parts;
     $result{'path'} = join('/', @parts);
     $result{'fullpath'} = "$result{path}/$result{module}";
 
     my $compatDestDir = $module->destDir($module->name());
     my $fullCompatPath = "$srcbase/$compatDestDir";
 
     # We used to have code here to migrate very old directory layouts. It was
     # removed as of about 2013-09-29.
 
     return %result;
 }
 
 # Do note that this returns the *base* path to the source directory,
 # without the module name or kde_projects stuff appended. If you want that
 # use subroutine fullpath().
 sub getSourceDir
 {
     my $self = shift;
     return $self->getSubdirPath('source-dir');
 }
 
 sub name
 {
     my $self = shift;
     return $self->{name};
 }
 
 sub scm
 {
     my $self = shift;
 
     return $self->{scm_obj} if $self->{scm_obj};
 
     # Look for specific setting of repository and svn-server. If both is
     # set it's a bug, if one is set, that's the type (because the user says
     # so...). Don't use getOption($key) as it will try to fallback to
     # global options.
 
     my $svn_status = $self->getOption('svn-server', 'module');
     my $repository = $self->getOption('repository', 'module') // '';
     my $rcfile = $self->buildContext()->rcFile();
 
     if ($svn_status && $repository) {
         error (<<EOF);
 You have specified both y[b[svn-server] and y[b[repository] options for the
 b[$self] module in $rcfile.
 
 You should only specify one or the other -- a module cannot be both types
 - svn-server uses Subversion.
 - repository uses git.
 EOF
         die (make_exception('Config', 'svn-server and repository both set'));
     }
 
     # Overload repository to allow bzr URLs?
     if ($repository =~ /^bzr:\/\//) {
         $self->{scm_obj} = ksb::Updater::Bzr->new($self);
     }
 
     # If it needs a repo it's git. Everything else is svn for now.
     $self->{scm_obj} //=
         $repository
             ? ksb::Updater::Git->new($self)
             : ksb::Updater::Svn->new($self);
 
     return $self->{scm_obj};
 }
 
 sub setScmType
 {
     my ($self, $scmType) = @_;
 
     my $newType;
 
     given($scmType) {
         when('git')  { $newType = ksb::Updater::Git->new($self); }
         when('proj') { $newType = ksb::Updater::KDEProject->new($self); }
         when('metadata') { $newType = ksb::Updater::KDEProjectMetadata->new($self); }
 #       when('l10n') { $newType = ksb::l10nSystem->new($self); }
         when('svn')  { $newType = ksb::Updater::Svn->new($self); }
         when('bzr')  { $newType = ksb::Updater::Bzr->new($self); }
         default      { $newType = undef; }
     }
 
     $self->{scm_obj} = $newType;
 }
 
 # Returns a string describing the scm platform of the given module.
 # Return value: 'git' or 'svn' at this point, as appropriate.
 sub scmType
 {
     my $self = shift;
     return $self->scm()->name();
 }
 
 sub currentScmRevision
 {
     my $self = shift;
 
     return $self->scm()->currentRevisionInternal();
 }
 
 # Returns a new build system object, given the appropriate name.
 # This is a sub-optimal way to fix the problem of allowing users to override
 # the detected build system (we could instead use introspection to figure out
 # available build systems at runtime). However, KISS...
 sub buildSystemFromName
 {
     my ($self, $name) = @_;
     my %buildSystemClasses = (
         'generic'         => 'ksb::BuildSystem',
         'qmake'           => 'ksb::BuildSystem::QMake',
         'cmake-bootstrap' => 'ksb::BuildSystem::CMakeBootstrap',
         'kde'             => 'ksb::BuildSystem::KDE4',
         'qt'              => 'ksb::BuildSystem::Qt4',
         'autotools'       => 'ksb::BuildSystem::Autotools',
     );
 
     my $class = $buildSystemClasses{lc $name} // undef;
     return $class->new($self) if ($class);
 
     # Past here, no class found
     croak_runtime("Invalid build system $name requested");
 }
 
 sub buildSystem
 {
     my $self = shift;
 
     if ($self->{build_obj} && $self->{build_obj}->name() ne 'generic') {
         return $self->{build_obj};
     }
 
     if (my $userBuildSystem = $self->getOption('override-build-system')) {
         $self->{build_obj} = $self->buildSystemFromName($userBuildSystem);
         return $self->{build_obj};
     }
 
     # If not set, let's guess.
     my $buildType;
     my $sourceDir = $self->fullpath('source');
 
     if (($self->getOption('repository') =~ /gitorious\.org\/qt\//) ||
         ($self->getOption('repository') =~ /^kde:qt$/) ||
         (-e "$sourceDir/bin/syncqt"))
     {
         $buildType = ksb::BuildSystem::Qt4->new($self);
     }
 
     # This test must come before the KDE buildsystem's as cmake's own
     # bootstrap system also has CMakeLists.txt
     if (!$buildType && (-e "$sourceDir/CMakeLists.txt") &&
         (-e "$sourceDir/bootstrap"))
     {
         $buildType = ksb::BuildSystem::CMakeBootstrap->new($self);
     }
 
     if (!$buildType && (-e "$sourceDir/CMakeLists.txt" ||
             $self->getOption('#xml-full-path')))
     {
         $buildType = ksb::BuildSystem::KDE4->new($self);
     }
 
     # We have to assign to an array to force glob to return all results,
     # otherwise it acts like a non-reentrant generator whose output depends on
     # how many times it's been called...
     if (!$buildType && (my @files = glob ("$sourceDir/*.pro"))) {
         $buildType = ksb::BuildSystem::QMake->new($self);
     }
 
     # 'configure' is a popular fall-back option even for other build
     # systems so ensure we check last for autotools.
     if (!$buildType &&
         (-e "$sourceDir/configure" || -e "$sourceDir/autogen.sh"))
     {
         $buildType = ksb::BuildSystem::Autotools->new($self);
     }
 
     # Don't just assume the build system is KDE-based...
     $buildType //= ksb::BuildSystem->new($self);
 
     $self->{build_obj} = $buildType;
 
     return $self->{build_obj};
 }
 
 # Sets the build system **object**, although you can find the build system
 # type afterwards (see buildSystemType).
 sub setBuildSystem
 {
     my ($self, $obj) = @_;
 
     assert_isa($obj, 'ksb::BuildSystem');
     $self->{build_obj} = $obj;
 }
 
 # Current possible build system types:
 # KDE (i.e. cmake), Qt, l10n (KDE language buildsystem), autotools (either
 # configure or autogen.sh). A final possibility is 'pendingSource' which
 # simply means that we don't know yet.
 #
 # If the build system type is not set ('pendingSource' counts as being
 # set!) when this function is called then it will be autodetected if
 # possible, but note that not all possible types will be detected this way.
 # If in doubt use setBuildSystemType
 sub buildSystemType
 {
     my $self = shift;
     return $self->buildSystem()->name();
 }
 
 # Creates the Mojo::Promises corresponding to each named phase.
 # E.g. the 'update' phase would be mapped to a sequence of subs to be executed
 # for the update.
 sub installPhasePromises
 {
     # Make our normal "self" a name unlikely to be used in a closure
     # below by mistake
     my $misnamedSelf = shift;
 
     # Each phase either maps directly to a subroutine which can
     # block (and whose return value will have a default handler),
     # or can map to an array of exactly 2 subroutines. The first
     # sub would be the blocking handler, the second sub is a
     # custom handler for the result.
     # Both subs are passed the module as the first param
     my %phaseBuilders = (
         # Always runs, always first, the appropriate subsequent phase will
         # be linked to this one (based on --no-src, --install-only, etc.)
         start => sub {
             my $self = shift;
             my %pathinfo = $self->getInstallPathComponents('build');
             super_mkdir($pathinfo{'path'});
-            return 1;
+            return { was_successful => 1 };
         },
 
         # update => [
         # See Application.pm for its custom runPhase_p
         # ],
 
         buildsystem => [
             sub {
                 my $self = shift;
-                return $self->setupBuildSystem();
+                return { was_successful => $self->setupBuildSystem() };
             },
             sub {
                 my ($self, $was_successful) = @_;
 
                 return Mojo::Promise->new->reject('Unable to setup build system')
                     unless $was_successful;
 
                 return $was_successful;
             }
         ],
 
         build => [
             sub {
                 # called in child process, can block
                 my $self = shift;
+                # already returns a hashref in proper schema
                 return $self->buildSystem()->buildInternal();
             },
             sub {
                 # called in this process, with results
-                my ($self, $was_successful) = @_;
+                my ($self, $was_successful, $extras) = @_;
                 $self->setPersistentOption('last-build-rev', $self->currentScmRevision());
 
+                # $extras has metadata on number of warnings, but it's already
+                # been reported by the time we get here.
+
                 return 1 if $was_successful;
                 return Mojo::Promise->new->reject('Build failed');
             },
         ],
 
         test => sub {
             my $self = shift;
-            if ($self->getOption('run-tests')) {
-                # TODO: Make test failure a blocker for install?
-                $self->buildSystem()->runTestsuite();
-            }
-            return 1;
+
+            $self->buildSystem()->runTestsuite()
+                if $self->getOption('run-tests');
+
+            # TODO: Make test failure a blocker for install?
+            return { was_successful => 1 };
         },
 
         install => sub {
             my $self = shift;
-            if ($self->getOption('install-after-build')) {
-                return 0 if !$self->install();
-            }
+            my $success = 1;
 
-            return 1;
+            $success = 0
+                if $self->getOption('install-after-build') and !$self->install();
+
+            return { was_successful => $success };
         },
     );
 
     $misnamedSelf->{builders} = \%phaseBuilders;
 }
 
 # Subroutine to build this module.
 # Returns a promise that resolves to true (on success) or rejects with a error
 # string
 sub build
 {
     my $self = assert_isa(shift, 'ksb::Module');
     my $moduleName = $self->name();
     my %pathinfo = $self->getInstallPathComponents('build');
     my $builddir = $pathinfo{'fullpath'};
     my $buildSystem = $self->buildSystem();
 
     return Mojo::Promise->new->reject('There is no build system to use')
         if ($buildSystem->name() eq 'generic' && !pretending());
 
     # Ensure we're in a known directory before we start; some options remove
     # the old build directory that a previous module might have been using.
     super_mkdir($pathinfo{'path'});
     p_chdir($pathinfo{'path'});
 
     my $buildSystemPromise = $self->runPhase_p('buildsystem');
 
     return $buildSystemPromise
         if $self->getOption('build-system-only');
 
     # If we don't stop with the build system only, then keep extending that
     # promise chain to complete the build, test, and install
 
     return $buildSystemPromise->then(sub {
         return $self->runPhase_p('build');
     })->then(sub {
         return $self->runPhase_p('test');
     })->then(sub {
         return $self->runPhase_p('install');
     });
 }
 
 # Subroutine to setup the build system in a directory.
 # Returns boolean true on success, boolean false (0) on failure.
 sub setupBuildSystem
 {
     my $self = assert_isa(shift, 'ksb::Module');
     my $moduleName = $self->name();
 
     my $buildSystem = $self->buildSystem();
 
     if ($buildSystem->name() eq 'generic' && !pretending()) {
         croak_internal('Build system determination still pending when build attempted.');
     }
 
     my $refreshReason = $buildSystem->needsRefreshed();
     if ($refreshReason ne "")
     {
         # Check to see if we're actually supposed to go through the
         # cleaning process.
         if (!$self->getOption('#cancel-clean') &&
             !$buildSystem->cleanBuildSystem())
         {
             warning ("\tUnable to clean r[$self]!");
             return 0;
         }
     }
 
     if (!$buildSystem->createBuildSystem()) {
         error ("\tError creating r[$self]'s build system!");
         return 0;
     }
 
     # Now we're in the checkout directory
     # So, switch to the build dir.
     # builddir is automatically set to the right value for qt
     p_chdir ($self->fullpath('build'));
 
     if (!$buildSystem->configureInternal()) {
         error ("\tUnable to configure r[$self] with " . $self->buildSystemType());
 
         # Add undocumented ".refresh-me" file to build directory to flag
         # for --refresh-build for this module on next run. See also the
         # "needsRefreshed" subroutine.
         if (open my $fh, '>', '.refresh-me') {
             say $fh "# Build directory will be re-generated next kdesrc-build run";
             say $fh "# due to failing to complete configuration on the last run";
             close $fh;
         };
 
         return 0;
     }
 
     return 1;
 }
 
 # Responsible for installing the module (no update, build, etc.)
 # Return value: Boolean flag indicating whether module installed successfully or
 # not.
 # Exceptions may be thrown for abnormal conditions (e.g. no build dir exists)
 sub install
 {
     my $self = assert_isa(shift, 'ksb::Module');
     my $builddir = $self->fullpath('build');
     my $buildSysFile = $self->buildSystem()->configuredModuleFileName();
 
     if (!pretending() && ! -e "$builddir/$buildSysFile")
     {
         warning ("\tThe build system doesn't exist for r[$self].");
         warning ("\tTherefore, we can't install it. y[:-(].");
         return 0;
     }
 
     $self->setupEnvironment();
 
     my @makeInstallOpts = split(' ', $self->getOption('make-install-prefix'));
 
     # We can optionally uninstall prior to installing
     # to weed out old unused files.
     if ($self->getOption('use-clean-install') &&
         $self->getPersistentOption('last-install-rev'))
     {
         if (!$self->buildSystem()->uninstallInternal(@makeInstallOpts)) {
             warning ("\tUnable to uninstall r[$self] before installing the new build.");
             warning ("\tContinuing anyways...");
         }
         else {
             $self->unsetPersistentOption('last-install-rev');
         }
     }
 
     if (!$self->buildSystem()->installInternal(@makeInstallOpts))
     {
         error ("\tUnable to install r[$self]!");
         $self->buildContext()->markModulePhaseFailed('install', $self);
         return 0;
     }
 
     if (pretending())
     {
         pretend ("\tWould have installed g[$self]");
         return 1;
     }
 
     # Past this point we know we've successfully installed, for real.
 
     $self->setPersistentOption('last-install-rev', $self->currentScmRevision());
 
     my $remove_setting = $self->getOption('remove-after-install');
 
     # Possibly remove the srcdir and builddir after install for users with
     # a little bit of HD space.
     if($remove_setting eq 'all')
     {
         # Remove srcdir
         my $srcdir = $self->fullpath('source');
         note ("\tRemoving b[r[$self source].");
         safe_rmtree($srcdir);
     }
 
     if($remove_setting eq 'builddir' || $remove_setting eq 'all')
     {
         # Remove builddir
         note ("\tRemoving b[r[$self build directory].");
         safe_rmtree($builddir);
 
         # We're likely already in the builddir, so chdir back to the root
         p_chdir('/');
     }
 
     return 1;
 }
 
 # Handles uninstalling this module (or its sub-directories as given by the checkout-only
 # option).
 #
 # Returns boolean false on failure, boolean true otherwise.
 sub uninstall
 {
     my $self = assert_isa(shift, 'ksb::Module');
     my $builddir = $self->fullpath('build');
     my $buildSysFile = $self->buildSystem()->configuredModuleFileName();
 
     if (!pretending() && ! -e "$builddir/$buildSysFile")
     {
         warning ("\tThe build system doesn't exist for r[$self].");
         warning ("\tTherefore, we can't uninstall it.");
         return 0;
     }
 
     $self->setupEnvironment();
 
     my @makeInstallOpts = split(' ', $self->getOption('make-install-prefix'));
 
     if (!$self->buildSystem()->uninstallInternal(@makeInstallOpts))
     {
         error ("\tUnable to uninstall r[$self]!");
         $self->buildContext()->markModulePhaseFailed('install', $self);
         return 0;
     }
 
     if (pretending())
     {
         pretend ("\tWould have uninstalled g[$self]");
         return 1;
     }
 
     $self->unsetPersistentOption('last-install-rev');
     return 1;
 }
 
 sub buildContext
 {
     my $self = shift;
     return $self->{context};
 }
 
 # Integrates 'set-env' option to the build context environment
 sub applyUserEnvironment
 {
     my $self = assert_isa(shift, 'ksb::Module');
     my $ctx = $self->buildContext();
 
     # Let's see if the user has set env vars to be set.
     # Note the global set-env must be checked separately anyways, so
     # we limit inheritance when searching.
     my $env_hash_ref = $self->getOption('set-env', 'module');
 
     while (my ($key, $value) = each %{$env_hash_ref})
     {
         $ctx->queueEnvironmentVariable($key, $value);
     }
 }
 
 # Establishes proper build environment in the build context. Should be run
 # before forking off commands for e.g. updates, builds, installs, etc.
 sub setupEnvironment
 {
     my $self = assert_isa(shift, 'ksb::Module');
     my $ctx = $self->buildContext();
     my $kdedir = $self->getOption('kdedir');
     my $prefix = $self->installationPath();
 
     # Add global set-envs and context
     $self->buildContext()->applyUserEnvironment();
 
     # Avoid moving /usr up in env vars
     if ($kdedir ne '/usr') {
         my @pkg_config_dirs = ("$kdedir/lib/pkgconfig");
         $ctx->prependEnvironmentValue('PKG_CONFIG_PATH', @pkg_config_dirs);
 
         my @ld_dirs = ("$kdedir/lib", $self->getOption('libpath'));
         $ctx->prependEnvironmentValue('LD_LIBRARY_PATH', @ld_dirs);
 
         my @path = ("$kdedir/bin", $self->getOption('binpath'));
         $ctx->prependEnvironmentValue('PATH', @path);
     }
 
     # Build system's environment injection
     my $buildSystem = $self->buildSystem();
     $buildSystem->prepareModuleBuildEnvironment($ctx, $self, $prefix);
 
     # Read in user environment defines
     $self->applyUserEnvironment() unless $self == $ctx;
 }
 
 # Returns the path to the log directory used during this run for this
 # ksb::Module, based on an autogenerated unique id. The id doesn't change
 # once generated within a single run of the script.
 sub getLogDir
 {
     my ($self) = @_;
     return $self->buildContext()->getLogDirFor($self);
 }
 
 # Returns a full path that can be open()'d to write a log
 # file, based on the given basename (with extension).
 # Updates the 'latest' symlink as well, unlike getLogDir
 # Use when you know you're going to create a new log
 sub getLogPath
 {
     my ($self, $path) = @_;
     return $self->buildContext()->getLogPathFor($self, $path);
 }
 
 sub toString
 {
     my $self = shift;
     return $self->name();
 }
 
 sub compare
 {
     my ($self, $other) = @_;
     return $self->name() cmp $other->name();
 }
 
 # Throws an exception on error, otherwise returns number of updates known to
 # have occurred. Only returns 0 if we positively know from the scm that no
 # update occurred.
 sub update
 {
     my ($self, $ctx) = @_;
 
     my $module_src_dir = $self->getSourceDir();
     my $kdesrc = $ctx->getSourceDir();
 
     if ($kdesrc ne $module_src_dir && !super_mkdir($module_src_dir))
     {
         # This module has a different source directory, ensure it exists.
         croak_runtime ("Unable to create separate source directory for $self at $module_src_dir");
     }
 
     # Use 1 as default value to force a rebuild if we can't determine there
     # were truly *no* updates
     my $count = $self->scm()->updateInternal() // 1;
-
-    # Need to help calling code figure out that 0 is an OK return value from this method.
-    # TODO: Consistently use exceptions in runPhase-based code so this isn't needed.
-    # TODO: Require updateInternal to set appropriate msg for scm (files, commits, etc.)
-    return $count ? $count : '0 but true';
+    return { was_successful => 1, update_count => $count };
 }
 
 # OVERRIDE
 #
 # This calls OptionsBase::setOption and performs any Module-specific
 # handling.
 sub setOption
 {
     my ($self, %options) = @_;
 
     # Ensure we don't accidentally get fed module-set options
     for (qw(git-repository-base use-modules ignore-modules)) {
         if (exists $options{$_}) {
             error (" r[b[*] module b[$self] should be declared as module-set to use b[$_]");
             die ksb::BuildException::Config->new($_, "Option $_ can only be used in module-set");
         };
     }
 
     # Special case handling.
     if (exists $options{'filter-out-phases'}) {
         for my $phase (split(' ', $options{'filter-out-phases'})) {
             $self->phases()->filterOutPhase($phase);
         }
         delete $options{'filter-out-phases'};
     }
 
     # When running in a subprocess, option changes will be forgotten unless they are fed
     # back to parent process, so store those in a special array also.
     if (exists $self->buildContext()->{'#pending'}) {
         # Only forward 'plain' options, just a sanity check
         my @keys = grep { !ref($options{$_}) } (keys %options);
         $self->{options}->{'#pending'} //= { };
         @{$self->{options}->{'#pending'}}{@keys} = @options{@keys};
     }
 
     $self->SUPER::setOption(%options);
 }
 
 # OVERRIDE
 #
 # This subroutine returns an option value for a given module.  Some globals
 # can't be overridden by a module's choice (but see 2nd parameter below).
 # If so, the module's choice will be ignored, and a warning will be issued.
 #
 # Option names are case-sensitive!
 #
 # Some options (e.g. cmake-options, configure-flags) have the global value
 # and then the module's own value appended together. To get the actual
 # module setting you must use the level limit parameter set to 'module'.
 #
 # Likewise, some qt module options do not obey the previous proviso since
 # Qt options are not likely to agree nicely with generic KDE buildsystem
 # options.
 #
 # 1st parameter: Name of option
 # 2nd parameter: Level limit (optional). If not present, then the value
 # 'allow-inherit' is used. Options:
 #   - allow-inherit: Module value is used if present (with exceptions),
 #     otherwise global is used.
 #   - module: Only module value is used (if you want only global then use the
 #     buildContext) NOTE: This overrides global "sticky" options as well!
 sub getOption
 {
     my ($self, $key, $levelLimit) = @_;
     my $ctx = $self->buildContext();
     $levelLimit //= 'allow-inherit';
 
     # Some global options would probably make no sense applied to Qt.
     my @qtCopyOverrides = qw(branch configure-flags tag cxxflags);
     if (list_has(\@qtCopyOverrides, $key) && $self->buildSystemType() eq 'Qt') {
         $levelLimit = 'module';
     }
 
     assert_in($levelLimit, [qw(allow-inherit module)]);
 
     # If module-only, check that first.
     return $self->{options}{$key} if $levelLimit eq 'module';
 
     # Some global options always override module options.
     return $ctx->getOption($key) if $ctx->hasStickyOption($key);
 
     # Some options append to the global (e.g. conf flags)
     my @confFlags = qw(cmake-options configure-flags cxxflags);
     if (list_has(\@confFlags, $key) && $ctx->hasOption($key)) {
         return $ctx->getOption($key) . " " . ($self->{options}{$key} || '');
     }
 
     # Everything else overrides the global option, unless it's simply not
     # set at all.
     return $self->{options}{$key} // $ctx->getOption($key);
 }
 
 # Gets persistent options set for this module. First parameter is the name
 # of the option to lookup. Undef is returned if the option is not set,
 # although even if the option is set, the value returned might be empty.
 # Note that ksb::BuildContext also has this function, with a slightly
 # different signature, which OVERRIDEs this function since Perl does not
 # have parameter-based method overloading.
 sub getPersistentOption
 {
     my ($self, $key) = @_;
     return $self->buildContext()->getPersistentOption($self->name(), $key);
 }
 
 # Sets a persistent option (i.e. survives between processes) for this module.
 # First parameter is the name of the persistent option.
 # Second parameter is its actual value.
 # See the warning for getPersistentOption above, it also applies for this
 # method vs. ksb::BuildContext::setPersistentOption
 sub setPersistentOption
 {
     my ($self, $key, $value) = @_;
     return $self->buildContext()->setPersistentOption($self->name(), $key, $value);
 }
 
 # Unsets a persistent option for this module.
 # Only parameter is the name of the option to unset.
 sub unsetPersistentOption
 {
     my ($self, $key) = @_;
     $self->buildContext()->unsetPersistentOption($self->name(), $key);
 }
 
 # Returns the path to the desired directory type (source or build),
 # including the module destination directory itself.
 sub fullpath
 {
     my ($self, $type) = @_;
     assert_in($type, [qw/build source/]);
 
     my %pathinfo = $self->getInstallPathComponents($type);
     return $pathinfo{'fullpath'};
 }
 
 # Returns the "full kde-projects path" for the module. As should be obvious by
 # the description, this only works for modules with an scm type that is a
 # Updater::KDEProject (or its subclasses).
 sub fullProjectPath
 {
     my $self = shift;
     my $path = $self->getOption('#xml-full-path', 'module') ||
         croak_internal("Tried to ask for full path of a module $self that doesn't have one!");
 
     return $path;
 }
 
 # Returns true if this module is (or was derived from) a kde-projects module.
 sub isKDEProject
 {
     my $self = shift;
     return $self->hasOption('#xml-full-path');
 }
 
 # Subroutine to return the name of the destination directory for the
 # checkout and build routines.  Based on the dest-dir option.  The return
 # value will be relative to the src/build dir.  The user may use the
 # '$MODULE' or '${MODULE}' sequences, which will be replaced by the name of
 # the module in question.
 #
 # The first parameter is optional, but if provided will be used as the base
 # path to replace $MODULE entries in dest-dir.
 sub destDir
 {
     my $self = assert_isa(shift, 'ksb::Module');
     my $destDir = $self->getOption('dest-dir');
 
     my $basePath = "";
 
     if ($self->getOption('ignore-kde-structure')) {
         $basePath = $self->name();
     } else {
         $basePath = shift // $self->getOption('#xml-full-path');
         $basePath ||= $self->name(); # Default if not provided in repo-metadata
     }
 
     $destDir =~ s/(\$\{MODULE})|(\$MODULE\b)/$basePath/g;
 
     return $destDir;
 }
 
 # Subroutine to return the installation path of a given module (the value
 # that is passed to the CMAKE_INSTALL_PREFIX CMake option).
 # It is based on the "prefix" and, if it is not set, the "kdedir" option.
 # The user may use '$MODULE' or '${MODULE}' in the "prefix" option to have
 # them replaced by the name of the module in question.
 sub installationPath
 {
     my $self = assert_isa(shift, 'ksb::Module');
     my $path = $self->getOption('prefix');
 
     if (!$path)
     {
         return $self->getOption('kdedir');
     }
 
     my $moduleName = $self->name();
     $path =~ s/(\$\{MODULE})|(\$MODULE\b)/$moduleName/g;
 
     return $path;
 }
 
 # Supports the subprocess handler in runPhase_p by reading messages that were
 # generated by the child process and sent back to us, and dispatching to
 # handler for real-time updates. Messages that can wait until the subprocess is
 # complete are handled separately.
 sub _readAndDispatchInProcessMessages
 {
     my ($self, $frozen_message, $monitor, $phaseName) = @_;
 
     my $linesRef = eval { thaw($frozen_message) };
     croak_internal("Failed to read msg from child handler: $@")
         unless $linesRef;
 
     if (exists $linesRef->{message}) {
         $monitor->noteLogEvents("$self", $phaseName, [$linesRef->{message}]);
     } elsif (exists $linesRef->{progress}) {
         my ($x, $y) = @{$linesRef->{progress}};
         $monitor->markPhaseProgress("$self", $phaseName, $x / $y)
             if $y > 0;
     } else {
         croak_internal("Couldn't handle message $frozen_message from child.");
     }
 }
 
 # Runs the given phase in a separate subprocess, using provided sub references.
 # Assumes use of promises for the provided sub references -- if launching the
 # subprocess fails, then a rejected promise is returned in the completion sub
 # reference
 # Returns a promise that yields the return value of the completion sub
 # reference.
 sub runPhase_p
 {
     my ($self, $phaseName, $blocking_coderef, $completion_coderef) = @_;
     my $phaseSubs = $self->{builders}->{$phaseName};
 
     if (ref($phaseSubs) eq 'CODE') {
         $blocking_coderef //= $phaseSubs;
     }
     elsif (ref($phaseSubs) eq 'ARRAY') {
         ($blocking_coderef, $completion_coderef) = @{$phaseSubs};
         croak_internal("Missing subs for $phaseName")
             unless ($blocking_coderef && $completion_coderef);
     }
     else {
         croak_internal("self->builders->{$phaseName} should not be set")
             if defined $phaseSubs;
     }
 
     # Default handler
     $completion_coderef //= sub {
-        my ($module, $result) = (@_);
+        my ($module, $result, $extras) = (@_);
         return Mojo::Promise->new->reject unless $result;
         return $result;
     };
 
     my $promise = Mojo::Promise->new;
     my $ctx = $self->buildContext();
 
     pipe (my $reader, my $writer)
         or croak_runtime("Couldn't open pipe to subprocess for $phaseName: $!");
 
     # Setup a pipe from child to parent so we can get updates as the phase
     # progresses, logs, etc.
     my $reactor = Mojo::IOLoop->singleton->reactor;
     my $monitor = $self->buildContext()->statusMonitor();
     my $reactorPromise = Mojo::Promise->new;
 
     $reactor->io($reader => sub {
         my ($reactor) = @_;
         my $buffer;
 
         if ((my $lengthRead = $reader->sysread($buffer, 8192)) == 0) {
             # eof
             $reactor->remove($reader);
             close $reader;
             $reactorPromise->resolve;
         }
         elsif ($lengthRead > 0) {
             $self->_readAndDispatchInProcessMessages($buffer, $monitor, $phaseName);
         }
         else {
             croak_runtime("Error reading from child pipe: $!");
             $reactorPromise->reject;
         }
     });
     $reactor->watch($reader, 1, 0); # watch for pipe readability only
 
     $monitor->markPhaseStart($self->name(), $phaseName);
 
     Mojo::IOLoop->subprocess(
         sub {
             # blocks, runs in separate process
             $SIG{INT} = sub { POSIX::_exit(EINTR); };
             $0 = "kdesrc-build[$phaseName]";
 
             # This causes setOption to record changes, and is deliberately not
             # within ctx->{options}
             $ctx->{'#pending'} = { };
 
             $writer->autoflush(1);
             close $reader; # we can't use this anyways
             ksb::Debug::setOutputHandle($writer);
 
             $self->buildContext->resetEnvironment();
             $self->setupEnvironment();
 
-            # This coderef should return a normal value (something you could
-            # stick in a plain JSON object)
-            my $result = $blocking_coderef->($self);
+            # This coderef should return a hashref: {
+            #   was_successful => bool,
+            #   ... (other details)
+            # }
+            my $resultRef = $blocking_coderef->($self);
+            my $result = $resultRef->{was_successful};
             my %newOptions;
 
             # Grab any newly-set options to feed back to parent
             my @affectedMods = grep {
                 exists $ctx->{build_options}->{$_}->{'#pending'};
             } (keys %{$ctx->{build_options}});
 
             foreach my $affected (@affectedMods) {
                 $newOptions{$affected} = $ctx->{build_options}->{$affected}->{'#pending'};
             }
 
             return {
                 result     => $result,
                 newOptions => \%newOptions,
+                extras     => $resultRef,
             };
         },
 
         sub {
             # runs in this process once subprocess is done
             my ($subprocess, $err, $resultsRef) = @_;
 
             close $writer; # can't close it earlier because must be open at fork
 
             # Apply options that may have changed during child proc execution.
             if (%{$resultsRef->{newOptions}}) {
                 while(my ($k, $v) = each %{$resultsRef->{newOptions}}) {
                     my %modulesNewOptions = %{$v};
                     @{$ctx->{build_options}->{$k}}{keys %modulesNewOptions} = values %modulesNewOptions;
                 }
             }
 
             if ($err) {
                 $ctx->markModulePhaseFailed($phaseName, $self);
                 return $promise->reject($err);
             }
 
             my $result = $resultsRef->{result};
             if ($result) {
-                $ctx->markModulePhaseSucceeded($phaseName, $self);
+                $ctx->markModulePhaseSucceeded($phaseName, $self, $resultsRef->{extras});
             } else {
                 $ctx->markModulePhaseFailed($phaseName, $self);
             }
 
             return $reactorPromise->then(sub {
                 # This coderef should resolve or reject the promise, if used
-                $promise->resolve($completion_coderef->($self, $result));
+                $promise->resolve($completion_coderef->($self, $result, $resultsRef));
             });
         }
     );
 
     return $promise;
 }
 
 1;