fun_ci 2.2.0 → 2.3.0

data/lib/fun_ci/pipeline/slot_run.rb

@@ -34,22 +34,36 @@ module FunCi
 
       def recorder = @seams.recorder
       def progress = ProgressReporter.new(stdout: @io.stdout)
-      def stage_runner = StageRunner.new(commit: @commit, stdout: @io.stdout, seams: @seams, dir: @slot.path)
+
+      def stage_runner(seams = @seams)
+        StageRunner.new(commit: @commit, stdout: @io.stdout, seams: seams, dir: @slot.path)
+      end
 
       # This process's part is over; the slow suite may still be running.
       def released(exit_code)
         @slot.release
-        recorder.foreground_done
         exit_code
       end
 
       def phase_one_passed?(config)
-        results = %w[lint build].to_h { |stage| [stage, Thread.new { stage_runner.passes?(config, stage) }] }
+        runner = stage_runner(phase_one_seams)
+        results = %w[lint build].to_h { |stage| [stage, Thread.new { runner.passes?(config, stage) }] }
                                 .transform_values(&:value)
         progress.phase_one_result(results)
         results.values.all?
       end
 
+      # A worktree just made has no caches, so its lint and build are no
+      # measure of the project's: they get the slow suite's budget, this once.
+      def phase_one_seams
+        return @seams unless @slot.cold?
+
+        cold = @seams.budgets["slow"]
+        progress.cold_slot(cold)
+        longer = %w[lint build].to_h { |stage| [stage, [@seams.budgets[stage], cold].max] }
+        @seams.with(time_budgets: @seams.time_budgets.merge(longer))
+      end
+
       def fast_passed?(config)
         passed = stage_runner.passes?(config, "fast")
         progress.fast_result(passed)
@@ -65,7 +79,8 @@ module FunCi
       # Called with the recorder and job to record the slow suite with, in
       # whichever process runs it; the slot is let go once it is recorded.
       def slow_suite(config, slot)
-        execution = StageExecution.new(seams: @seams, dir: slot.path, commit: @commit)
+        execution = StageExecution.new(seams: @seams, dir: slot.path, commit: @commit,
+                                       launching: { priority: @seams.priorities.slow })
         command = config.stage_command("slow", @commit.sha)
         ->(recorder, job_id) { holding(slot) { execution.run("slow", command, recorder, job_id) } }
       end

data/lib/fun_ci/pipeline/trigger.rb

@@ -29,9 +29,12 @@ module FunCi
       def run
         config = Setup::ProjectConfig.new(@project)
         return handle_config_errors(config) if config.validate.any?
-        return unknown_commit unless known_commit?
 
-        start_run
+        full = full_sha
+        return unknown_commit unless full
+
+        @commit = @commit.with(sha: full)
+        start_run(config)
         checking_the_trunk { run_in(workspace.acquire(@commit.sha)) }
       end
 
@@ -44,7 +47,8 @@ module FunCi
       private
 
       def recorder = @seams.recorder
-      def known_commit? = @commit.sha == NULL_SHA || @seams.commit_validator.call(@commit.sha)
+      # Runs are kept under the full SHA, whatever revision named the commit.
+      def full_sha = @commit.sha == NULL_SHA ? NULL_SHA : @seams.commit_resolver.call(@commit.sha)
 
       def workspace = @seams.workspace || Workspaces.for(@project, @commit.sha)
       def branch = Persistence::Branch.new(project: @project, name: @commit.branch)
@@ -56,11 +60,16 @@ module FunCi
         committed.folder_exists? ? committed : Setup::ProjectConfig.new(@project)
       end
 
-      # The check is recorded by the recorder the run holds once its stages are done.
+      # The check is recorded by the recorder the run holds once its stages are
+      # done, and before the run says its foreground is: until then, a reader
+      # takes a check not yet recorded to be still going.
       def checking_the_trunk
         trunk = TrunkRun.start(@seams.trunk || Trunk::Checker.for(@project), @commit.sha, recorder)
         @io.stdout.puts(trunk.notice) if trunk.notice
-        yield.tap { trunk.finish(recorder) }
+        yield.tap do
+          trunk.finish(recorder)
+          recorder.foreground_done
+        end
       end
 
       def handle_config_errors(config)
@@ -77,7 +86,9 @@ module FunCi
         1
       end
 
-      def start_run
+      # A mistake in the config is named, and its defaults used.
+      def start_run(config)
+        config.settings_errors.each { |e| @io.stdout.puts "fun-ci: #{e}" }
         recorder.report_trouble_to(@io.stdout)
         cancel_stale_pipelines
         recorder.create_run(commit_hash: @commit.sha, branch: @commit.branch, project_path: @project)

data/lib/fun_ci/pipeline/trigger_command.rb

@@ -60,13 +60,17 @@ module FunCi
         0
       end
 
-      # The first fetch's notice, and on stderr, why the jobs didn't start.
+      # The config's mistakes and the first fetch's notice, and on stderr, why
+      # the jobs didn't start; the run itself prints nowhere.
       def say(forked)
+        Setup::ProjectConfig.new(@project).settings_errors.each { |e| @io.stdout.puts "fun-ci: #{e}" }
         @io.stdout.puts(forked.notice) if forked.notice
         @io.stderr.puts(forked.jobs) if forked.jobs
       end
 
-      def say_how_to_wait(sha) = @io.stdout.puts("fun-ci: testing #{sha}. Verdict: fun-ci wait #{sha} --need all")
+      def say_how_to_wait(sha)
+        @io.stdout.puts("fun-ci: testing #{sha}. Verdict: fun-ci wait #{sha} --need all --follow-branch")
+      end
     end
   end
 end

data/lib/fun_ci/pipeline/trigger_params.rb

@@ -5,13 +5,13 @@ require_relative "../persistence/pipeline_recorder"
 require_relative "command_executor"
 require_relative "stage_dir"
 require_relative "git_environment"
+require_relative "priorities"
+require_relative "budgets"
 require_relative "../evidence/command_runner"
 require_relative "../evidence/process_table"
 
 module FunCi
   module Pipeline
-    DEFAULT_BUDGETS = { "lint" => 30, "build" => 30, "fast" => 10, "slow" => 300 }.freeze
-
     Commit = Data.define(:sha, :branch)
 
     # On a detached HEAD git names no branch, and the hooks pass "": the run
@@ -33,22 +33,33 @@ module FunCi
     # own extractors (`run:` entries), given dir:, env: and scratch:;
     # `process_table` answers what ps lists, for a stage over budget; `trunk`
     # checks a commit against the trunk (#check(sha) answers a Trunk::Check,
-    # or nil for no check), nil for the project's own.
-    Seams = Data.define(:command_runner, :time_budgets, :commit_validator, :recorder, :background_launcher, :workspace,
-                        :stage_dir, :environment, :clock, :extractor_runner, :process_table, :trunk)
+    # or nil for no check), nil for the project's own; `priorities` what jobs
+    # and the slow suite start under.
+    Seams = Data.define(:command_runner, :time_budgets, :commit_resolver, :recorder, :background_launcher, :workspace,
+                        :stage_dir, :environment, :clock, :extractor_runner, :process_table, :trunk, :priorities)
 
     # Reopened rather than given as a block to Data.define, so tools that read
     # the source (mutineer) see these as Seams' methods.
     class Seams
+      # Seconds, for the evidence budget. Kept out of `defaults`' hash: a block
+      # on a line the hash continues onto gives that line the block's count,
+      # and the mutation lane then runs the hash's later lines' mutants only
+      # against tests that call it (test/support/statement_coverage.rb).
+      MONOTONIC = -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
+
       def self.defaults
         { command_runner: nil, time_budgets: {}, recorder: Persistence::NullRecorder.new, background_launcher: nil,
-          workspace: nil, commit_validator: method(:commit_exists?), stage_dir: StageDir.method(:create),
-          environment: ENV.to_h, clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) },
+          workspace: nil, commit_resolver: method(:full_sha), stage_dir: StageDir.method(:create),
+          environment: ENV.to_h, clock: MONOTONIC,
           extractor_runner: Evidence::CommandRunner.method(:new),
-          process_table: Evidence::ProcessTable.method(:now), trunk: nil }
+          process_table: Evidence::ProcessTable.method(:now), trunk: nil, priorities: Priorities.for(RUBY_PLATFORM) }
       end
 
-      def self.commit_exists?(sha) = Open3.capture2e(GitEnvironment::CLEAN, "git", "cat-file", "-t", sha).last.success?
+      # The full SHA of the commit `rev` names, or nil when the repository has none.
+      def self.full_sha(rev)
+        out, status = Open3.capture2(GitEnvironment::CLEAN, "git", "rev-parse", "--verify", "-q", "#{rev}^{commit}")
+        out.strip if status.success?
+      end
 
       def initialize(**given) = super(**self.class.defaults.merge(given))
       def budgets = DEFAULT_BUDGETS.merge(time_budgets)

data/lib/fun_ci/pipeline/worktree_pool.rb

@@ -20,10 +20,10 @@ module FunCi
         @waiter = waiter
       end
 
+      # A ColdSlot when the slot's worktree had to be made.
       def acquire(sha)
         slot = wait_for_free_slot
-        @worktrees.check_out(slot.path, sha)
-        slot
+        @worktrees.check_out(slot.path, sha) ? slot.as_cold : slot
       rescue StandardError
         slot&.release
         raise

data/lib/fun_ci/pipeline/worktrees.rb

@@ -20,11 +20,13 @@ module FunCi
 
       # Leaves +path+ as a clean detached checkout of +sha+. Ignored files stay,
       # so caches such as vendor/bundle survive between runs in the same slot.
+      # Answers whether it made the worktree, which then has no caches.
       def check_out(path, sha)
-        return add(path, sha) unless File.exist?(File.join(path, ".git"))
+        return add(path, sha).then { true } unless File.exist?(File.join(path, ".git"))
 
         git(path, "checkout", "--detach", "--force", sha)
         git(path, "clean", "-fd")
+        false
       end
 
       # Has git forget the worktrees whose directories are gone.

data/lib/fun_ci/setup/agent_instructions.rb

@@ -4,7 +4,8 @@ module FunCi
   module Setup
     # What `fun-ci init` tells a coding agent working in the project, in the
     # instructions file agents read (acceptance-tests.md, AT-9.15): AGENTS.md,
-    # or CLAUDE.md when that is the only one. The marker keeps it to once.
+    # or CLAUDE.md when that is the only one. The marker keeps it to once, and
+    # finds a section an older fun-ci wrote, to bring it up to date.
     module AgentInstructions
       MARKER = "<!-- fun-ci: agent instructions -->"
       SECTION = <<~MD.freeze
@@ -13,7 +14,8 @@ module FunCi
         #{MARKER}
         This project runs fun-ci on every commit. After each commit, run the
         `fun-ci wait` command it prints, in the background, and act on its exit
-        code: 0 passed, 1 failed, 2 over budget, 3 undecided, 4 superseded.
+        code: 0 passed, 1 failed, 2 over budget, 3 undecided. A newer commit on
+        the branch cancels the run and the wait moves on to the newer one's.
         `fun-ci wait --need all` must exit 0 before the work is called done.
         Before calling work done, run `fun-ci wait --need all --trunk`; 6 means
         the commit conflicts with the trunk, which has to be integrated first,
@@ -24,14 +26,28 @@ module FunCi
         why one failed.
       MD
 
+      # A section in the text: from the heading over the marker, if it has
+      # one, to the next heading or the end.
+      WRITTEN = /^(?:## fun-ci\n\s*)?#{Regexp.escape(MARKER)}\n.*?(?=^#|\z)/m
+
       def self.file_for(names) = names.include?("CLAUDE.md") && !names.include?("AGENTS.md") ? "CLAUDE.md" : "AGENTS.md"
 
-      # The text with the section added, or nil when it has it already.
+      # The text with the section added, or brought up to date; nil when it
+      # has this one already.
       def self.merged(text)
-        return nil if text.include?(MARKER)
+        merged = text.include?(MARKER) ? replaced(text) : added(text)
+        merged unless merged == text
+      end
 
-        text.strip.empty? ? SECTION : "#{text.rstrip}\n\n#{SECTION}"
+      def self.said(text, file)
+        return "Told agents what to do after a commit, in #{file}." unless text.include?(MARKER)
+
+        "Brought the fun-ci section of #{file} up to date."
       end
+
+      def self.added(text) = text.strip.empty? ? SECTION : "#{text.rstrip}\n\n#{SECTION}"
+      def self.replaced(text) = text.sub(WRITTEN) { Regexp.last_match.post_match.empty? ? SECTION : "#{SECTION}\n" }
+      private_class_method :added, :replaced
     end
   end
 end

data/lib/fun_ci/setup/commands.rb

@@ -32,7 +32,9 @@ module FunCi
         install(args.any? ? [args.first] : HookScript.types)
       end
 
-      def check(_args) = SetupChecker.run(project_root: @project_root, stdout: @stdout)
+      def check(_args)
+        SetupChecker.run(project_root: @project_root, stdout: @stdout, hooks_dir: @hooks_dir.call(@project_root))
+      end
 
       private
 

data/lib/fun_ci/setup/hook_script.rb

@@ -7,11 +7,15 @@ module FunCi
       MARKER = "# fun-ci-managed-hook"
       NULL_SHA = "0" * 40
 
+      NOT_INSTALLED = %(echo "fun-ci is not installed or not on PATH, so this runs without CI. ) +
+                      %(Install it with: gem install fun_ci" >&2)
+      INSTALLED = "command -v fun-ci >/dev/null 2>&1"
+
       GUARD = <<~SH.freeze
         #!/bin/sh
         #{MARKER}
-        if ! command -v fun-ci >/dev/null 2>&1; then
-          echo "fun-ci is not installed or not on PATH, so this runs without CI. Install it with: gem install fun_ci" >&2
+        if ! #{INSTALLED}; then
+          #{NOT_INSTALLED}
           exit 0
         fi
       SH
@@ -26,7 +30,7 @@ module FunCi
       # Before a push: the fast verdict of each commit git says it pushes
       # (acceptance-tests.md, AT-9.13). A deleted ref pushes the null SHA, and
       # exit 5 is a project not set up for fun-ci, which pushes without CI.
-      PRE_PUSH = <<~SH.freeze
+      PRE_PUSH_WAITS = <<~SH.freeze
         status=0
         while read -r local_ref local_sha remote_ref remote_sha; do
           [ "$local_sha" = "#{NULL_SHA}" ] && continue
@@ -34,9 +38,10 @@ module FunCi
           code=$?
           [ "$code" -eq 0 ] || [ "$code" -eq 5 ] || status=1
         done
-        exit $status
       SH
 
+      PRE_PUSH = "#{PRE_PUSH_WAITS}exit $status\n".freeze
+
       BODIES = { "post-commit" => POST_COMMIT, "pre-push" => PRE_PUSH }.freeze
 
       def self.types = BODIES.keys

data/lib/fun_ci/setup/hook_writer.rb

@@ -2,6 +2,7 @@
 
 require "fileutils"
 require_relative "hook_script"
+require_relative "lfs_hook"
 
 module FunCi
   module Setup
@@ -23,8 +24,9 @@ module FunCi
         return reject("Unknown hook type: #{@hook_type}") unless HookScript.types.include?(@hook_type)
         return skip("Hook #{@hook_type} already exists from another tool, so it was left alone.") if foreign_hook?
 
-        write_hook
-        @stdout.puts "Installed #{@hook_type} hook."
+        lfs = lfs?
+        write_hook(lfs ? LfsHook.script(@hook_type) : HookScript.for(@hook_type))
+        @stdout.puts "Installed #{@hook_type} hook#{", which runs git-lfs's too" if lfs}."
         0
       end
 
@@ -33,13 +35,19 @@ module FunCi
       def git_repo? = !@hooks_dir.nil?
       def hook_path = File.join(@hooks_dir, @hook_type)
 
+      def existing = File.exist?(hook_path) ? File.read(hook_path) : ""
+
+      # git-lfs's own hook is not left alone: fun-ci's runs it.
       def foreign_hook?
-        File.exist?(hook_path) && !HookScript.managed?(File.read(hook_path))
+        script = existing
+        !script.empty? && !HookScript.managed?(script) && !LfsHook.stock?(script, @hook_type)
       end
 
-      def write_hook
+      def lfs? = LfsHook.runs_lfs?(existing, @hook_type)
+
+      def write_hook(script)
         FileUtils.mkdir_p(@hooks_dir)
-        File.write(hook_path, HookScript.for(@hook_type))
+        File.write(hook_path, script)
         File.chmod(0o755, hook_path)
       end
 

data/lib/fun_ci/setup/installed_hooks.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "lfs_hook"
+
+module FunCi
+  module Setup
+    # The post-commit and pre-push hooks git runs, as `fun-ci check` warns of
+    # them: one that doesn't run fun-ci tests no commit, or lets a push
+    # through without a verdict. `fun-ci install-hooks` writes either when it
+    # is missing or git-lfs's own; another tool's has to call fun-ci itself.
+    class InstalledHooks
+      WHAT = { "post-commit" => "No commit is tested", "pre-push" => "No push waits for a verdict" }.freeze
+      INSTALL = "Run `fun-ci install-hooks`"
+      CALL = { "post-commit" => "`fun-ci trigger --background <commit> <branch>`",
+               "pre-push" => "`fun-ci wait <commit> --need fast` for each commit pushed" }.freeze
+
+      # hooks_dir: where git runs the project's hooks from; nil outside a git repository.
+      def initialize(hooks_dir)
+        @hooks_dir = hooks_dir
+      end
+
+      def warnings
+        return [] unless @hooks_dir
+
+        WHAT.keys.map { |type| warning(type, script(type)) }.compact
+      end
+
+      private
+
+      def script(type)
+        path = File.join(@hooks_dir, type)
+        File.exist?(path) ? File.read(path) : ""
+      end
+
+      def warning(type, script)
+        return nil if script.include?("fun-ci")
+        return "#{WHAT[type]}: the #{type} hook doesn't run fun-ci. #{INSTALL}" if install_fixes?(script, type)
+
+        "#{WHAT[type]}: the #{type} hook is another tool's and doesn't run fun-ci. Have it run #{CALL[type]}"
+      end
+
+      def install_fixes?(script, type) = script.empty? || LfsHook.stock?(script, type)
+    end
+  end
+end

data/lib/fun_ci/setup/installer.rb

@@ -44,11 +44,12 @@ module FunCi
       def tell_agents
         file = AgentInstructions.file_for(Dir.children(@project_root))
         path = File.join(@project_root, file)
-        merged = AgentInstructions.merged(File.exist?(path) ? File.read(path) : "")
+        told = File.exist?(path) ? File.read(path) : ""
+        merged = AgentInstructions.merged(told)
         return unless merged
 
         File.write(path, merged)
-        @stdout.puts "Told agents what to do after a commit, in #{file}."
+        @stdout.puts AgentInstructions.said(told, file)
       end
 
       def initialised?

data/lib/fun_ci/setup/lfs_hook.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "hook_script"
+
+module FunCi
+  module Setup
+    # git-lfs's own post-commit and pre-push hooks, as `git lfs install`
+    # writes them, and the hook fun-ci writes in their place, which runs
+    # fun-ci's, then git-lfs's. A push reads its ref list from git once, so
+    # the pre-push hook keeps it in a file and gives it to both.
+    module LfsHook
+      GUARD = %r{\Acommand -v git-lfs >/dev/null 2>&1 \|\| \{.*; exit 2; \}\z}
+      MISSING = %(command -v git-lfs >/dev/null 2>&1 || { echo "This repository is configured for Git LFS ) +
+                %(but 'git-lfs' was not found on your path." >&2; exit 2; })
+
+      RUN = {
+        "post-commit" => "if #{HookScript::INSTALLED}; then fun_ci; else #{HookScript::NOT_INSTALLED}; fi\n",
+        "pre-push" => %(if #{HookScript::INSTALLED}; then fun_ci < "$refs" || exit 1; ) +
+                      "else #{HookScript::NOT_INSTALLED}; fi\n"
+      }.freeze
+
+      KEEP_REFS = { "post-commit" => "", "pre-push" => <<~SH }.freeze
+        refs=$(mktemp) || exit 1
+        trap 'rm -f "$refs"' EXIT
+        cat > "$refs"
+      SH
+
+      FUN_CI = { "post-commit" => HookScript::POST_COMMIT, "pre-push" => "#{HookScript::PRE_PUSH_WAITS}return $status\n" }
+               .freeze
+      LFS_INPUT = { "post-commit" => "", "pre-push" => %( < "$refs") }.freeze
+
+      # Whether `script` is the hook `git lfs install` writes for `hook_type`
+      # and nothing more.
+      def self.stock?(script, hook_type)
+        lines = script.lines(chomp: true).reject { |line| line.strip.empty? }
+        lines.size == 3 && lines.first == "#!/bin/sh" && GUARD.match?(lines[1]) && lines.last == call(hook_type)
+      end
+
+      def self.runs_lfs?(script, hook_type) = script.include?(call(hook_type))
+
+      def self.script(hook_type)
+        "#!/bin/sh\n#{HookScript::MARKER}\n# fun-ci's #{hook_type} hook, then git-lfs's, which it replaced.\n" \
+          "#{KEEP_REFS.fetch(hook_type)}fun_ci() {\n#{FUN_CI.fetch(hook_type)}}\n" \
+          "#{RUN.fetch(hook_type)}#{MISSING}\n#{call(hook_type)}#{LFS_INPUT.fetch(hook_type)}\n"
+      end
+
+      def self.call(hook_type) = %(git lfs #{hook_type} "$@")
+    end
+  end
+end

data/lib/fun_ci/setup/project_config.rb

@@ -20,12 +20,17 @@ module FunCi
         Dir.exist?(@fun_ci_dir)
       end
 
+      # What stops a pipeline: no .fun-ci/, or a stage script it can't run.
       def validate
         return ["No .fun-ci/ folder found in #{@project_root}"] unless folder_exists?
 
-        REQUIRED_SCRIPTS.flat_map { |script| script_errors(script) } + settings.errors
+        REQUIRED_SCRIPTS.flat_map { |script| script_errors(script) }
       end
 
+      # Mistakes in .fun-ci/config, which never stop a pipeline: the setting
+      # takes its default instead.
+      def settings_errors = settings.errors
+
       # Mistakes in the `evidence` key, which `fun-ci check` reports but which
       # never stop a pipeline: the entry with the mistake is left out instead.
       def evidence_errors = Evidence::Settings.load(File.join(@fun_ci_dir, "config")).errors(root: @project_root)
@@ -46,6 +51,7 @@ module FunCi
       def worktree_slots = settings.worktree_slots
       def trunk = settings.trunk
       def trunk_fetch = settings.trunk_fetch
+      def job_spacing = settings.job_spacing
 
       def script_path(stage)
         File.join(@fun_ci_dir, "#{stage}.sh")

data/lib/fun_ci/setup/settings.rb

@@ -6,7 +6,8 @@ module FunCi
   module Setup
     # .fun-ci/config: settings for this machine's runs, as YAML. Each one left
     # out takes its default; one that is wrong is reported and the default used,
-    # as are all of them when the file isn't YAML.
+    # as are all of them when the file can't be read as YAML. Anchors and
+    # aliases are YAML, so they are read.
     class Settings
       DEFAULTS = { "worktree_slots" => 2 }.freeze
       FETCH_EVERY = 300
@@ -20,7 +21,7 @@ module FunCi
         @text = text
       end
 
-      def worktree_slots = errors.empty? ? values.fetch("worktree_slots") : DEFAULTS.fetch("worktree_slots")
+      def worktree_slots = slots || DEFAULTS.fetch("worktree_slots")
 
       # The trunk's name, or nil when none is given or it is no name. A mistake
       # in the trunk settings never stops a pipeline, so none is among `errors`.
@@ -37,22 +38,51 @@ module FunCi
         seconds(given) || FETCH_EVERY
       end
 
-      def errors
-        return [".fun-ci/config must be a mapping such as `worktree_slots: 2`"] unless raw.is_a?(Hash)
+      # Seconds between the starts of the jobs a commit starts, 0 for all at
+      # once (Jobs::Schedule); nil when none is given, or none it can read,
+      # and the jobs share the day evenly (Jobs::DueJobs).
+      def job_spacing = seconds(setting("job_spacing"))
 
-        slots = values["worktree_slots"]
-        return [] if slots.is_a?(Integer) && slots.positive?
-
-        [".fun-ci/config: worktree_slots must be a whole number above 0, not #{slots.inspect}"]
+      def errors
+        setting_errors
       rescue Psych::SyntaxError => e
         [".fun-ci/config is not YAML: #{e.problem} (line #{e.line})"]
+      rescue Psych::DisallowedClass => e
+        [".fun-ci/config can't be read: #{e.message} (quote a value such as a date to read it as text)"]
+      rescue Psych::Exception => e
+        [".fun-ci/config can't be read: #{e.message}"]
       end
 
       private
 
+      def setting_errors
+        return [".fun-ci/config must be a mapping such as `worktree_slots: 2`"] unless raw.is_a?(Hash)
+
+        [slots_error, spacing_error].compact
+      end
+
+      # The slots the file asks for, when that is a whole number above 0.
+      def slots
+        given = setting("worktree_slots")
+        given if given.is_a?(Integer) && given.positive?
+      end
+
+      def slots_error
+        given = setting("worktree_slots")
+        ".fun-ci/config: worktree_slots must be a whole number above 0, not #{given.inspect}" unless given.nil? || slots
+      end
+
+      # Unlike the trunk's, since taking turns is the jobs' whole point (AT-13.28).
+      def spacing_error
+        given = setting("job_spacing")
+        return nil if given.nil? || seconds(given)
+
+        ".fun-ci/config: job_spacing must be seconds, or a number with s, m or h, not #{given.inspect}"
+      end
+
       def setting(key)
         raw.is_a?(Hash) ? raw[key] : nil
-      rescue Psych::SyntaxError
+      rescue Psych::Exception
         nil
       end
 
@@ -61,8 +91,7 @@ module FunCi
         match && (match[1].to_i * UNITS.fetch(match[2]))
       end
 
-      def raw = (@text && YAML.safe_load(@text)) || {}
-      def values = DEFAULTS.merge(raw)
+      def raw = (@text && YAML.safe_load(@text, aliases: true)) || {}
     end
   end
 end

data/lib/fun_ci/setup/setup_checker.rb

@@ -2,13 +2,22 @@
 
 require_relative "project_config"
 require_relative "legacy_hooks"
+require_relative "installed_hooks"
 require_relative "trunk_report"
 
 module FunCi
   module Setup
     class SetupChecker
-      def self.run(project_root:, stdout: $stdout)
-        new(config: ProjectConfig.new(project_root), hooks: LegacyHooks.new(project_root), stdout: stdout,
+      # The hooks it warns of: fun-ci 1.x's, and any in `hooks_dir` that
+      # doesn't run fun-ci.
+      Hooks = Data.define(:sources) do
+        def warnings = sources.flat_map(&:warnings)
+      end
+
+      # hooks_dir: where git runs the project's hooks from; nil outside a git repository.
+      def self.run(project_root:, stdout: $stdout, hooks_dir: nil)
+        hooks = Hooks.new([LegacyHooks.new(project_root), InstalledHooks.new(hooks_dir)])
+        new(config: ProjectConfig.new(project_root), hooks: hooks, stdout: stdout,
             trunk: TrunkReport.new(project_root)).run
       end
 
@@ -22,7 +31,7 @@ module FunCi
 
       # Warnings are printed but don't fail the check.
       def run
-        errors = @config.validate + @config.evidence_errors + @config.job_errors
+        errors = problems
         @stdout.puts(errors.empty? ? "All OK. The project is configured." : errors)
         @stdout.puts(@trunk.lines)
         list_presets
@@ -33,6 +42,8 @@ module FunCi
 
       private
 
+      def problems = @config.validate + @config.settings_errors + @config.evidence_errors + @config.job_errors
+
       def list_presets
         lists = { "this project" => @config.presets, "any project's output" => @config.any_project_presets }
         lists.each { |what, names| @stdout.puts "Evidence presets for #{what}: #{names.join(", ")}" if names.any? }

data/lib/fun_ci/trunk/shown.rb

@@ -8,8 +8,9 @@ module FunCi
     # rather than stored, how many seconds ago its trunk tip was seen (nil
     # when it had none), the project's last fetch (a LastFetch, nil if none), and
     # the SHA the trunk has moved to since, if it has.
-    # A run whose check hasn't been recorded is checking until its fetch and
-    # merge are past their time, and then unknown.
+    # A run whose check hasn't been recorded is checking while its foreground
+    # stages run and until its fetch and merge are past their time, and then
+    # unknown.
     Shown = Data.define(:state, :check, :age, :fetch, :moved_to)
 
     class Shown
@@ -21,8 +22,10 @@ module FunCi
             fetch: fetch, moved_to: moved_to)
       end
 
-      def self.unchecked(started:, now:)
-        if now - started <= FETCH_DEADLINE + CHECK_BUDGET
+      # stages_running: whether the run's foreground stages, which the check
+      # is recorded after, are still going.
+      def self.unchecked(started:, now:, stages_running: false)
+        if stages_running || now - started <= FETCH_DEADLINE + CHECK_BUDGET
           return new(state: "checking", check: nil, age: nil, fetch: nil, moved_to: nil)
         end