fun_ci 2.2.0-aarch64-linux → 2.4.0-aarch64-linux

data/lib/fun_ci/pipeline/stage_end.rb

@@ -58,7 +58,8 @@ module FunCi
         status = finished.status
         Evidence::Outcome.new(state: STATES.fetch(outcome(finished)), exit_status: status&.exitstatus,
                               signal: status&.termsig && Signal.signame(status.termsig),
-                              alongside: @recorder.alongside(@job_id), overrun: finished.overrun)
+                              alongside: @recorder.alongside(@job_id),
+                              elsewhere: @recorder.alongside_elsewhere(@job_id), overrun: finished.overrun)
       end
 
       def keep_exit(status)

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/workspaces.rb

@@ -15,7 +15,8 @@ module FunCi
       def self.for(project, sha)
         return InPlace.new(project) if sha == NULL_SHA
 
-        WorktreePool.new(Worktrees.new(project), size: Setup::ProjectConfig.new(project).worktree_slots)
+        config = Setup::ProjectConfig.new(project)
+        WorktreePool.new(Worktrees.new(project), size: config.worktree_slots, clean: config.clean)
       end
     end
   end

data/lib/fun_ci/pipeline/worktree_pool.rb

@@ -7,23 +7,33 @@ require_relative "worktrees"
 module FunCi
   module Pipeline
     # Hands each pipeline a worktree slot of its own under
-    # <git-common-dir>/fun-ci/worktrees, checked out at its commit, waiting
+    # Worktrees#root, checked out at its commit, waiting
     # while every slot is taken.
     class WorktreePool
       DEFAULT_SIZE = 2
+      # A slot nobody took for longer is cold: its caches are as warm as a
+      # run long ago left them, as a slot taken only when runs overlap is.
+      IDLE_SECONDS = 86_400
 
       attr_reader :size
 
-      def initialize(worktrees, size: DEFAULT_SIZE, waiter: -> { sleep 0.25 })
+      # Whether a slot last taken at `last_taken` has gone untaken too long.
+      def self.idle?(last_taken, now:) = now - last_taken > IDLE_SECONDS
+
+      # clean: the paths whose ignored files a slot loses when it moves off its
+      # line of history (Worktrees#check_out).
+      def initialize(worktrees, size: DEFAULT_SIZE, clean: [], waiter: -> { sleep 0.25 })
         @worktrees = worktrees
         @size = size
+        @clean = clean
         @waiter = waiter
       end
 
+      # A ColdSlot when the slot's worktree had to be made, or was cleaned, or
+      # nobody took the slot for a day.
       def acquire(sha)
         slot = wait_for_free_slot
-        @worktrees.check_out(slot.path, sha)
-        slot
+        @worktrees.check_out(slot.path, sha, clean: @clean) ? slot.as_cold : slot
       rescue StandardError
         slot&.release
         raise
@@ -49,12 +59,19 @@ module FunCi
       # The lock stays open for as long as the slot is held, so no block.
       def try_lock(path)
         lock = File.new("#{path}.lock", File::RDWR | File::CREAT, 0o644)
-        return Slot.new(path, stamped(lock), lock.path) if lock.flock(File::LOCK_EX | File::LOCK_NB)
+        return taken(path, lock) if lock.flock(File::LOCK_EX | File::LOCK_NB)
 
         lock.close
         nil
       end
 
+      # Each taker stamps the lock, so its last change is when the slot was last taken.
+      def taken(path, lock)
+        idle = WorktreePool.idle?(lock.mtime, now: Time.now)
+        slot = Slot.new(path, stamped(lock), lock.path)
+        idle ? slot.as_cold : slot
+      end
+
       def stamped(lock)
         lock.truncate(0)
         lock.write(Process.pid.to_s)

data/lib/fun_ci/pipeline/worktree_prune.rb

@@ -6,8 +6,8 @@ require_relative "worktrees"
 module FunCi
   module Pipeline
     # Removes every slot of a project's worktree pool and every daily or
-    # weekly job's worktree, and git's entries for them, when no run or job
-    # holds one. It takes each slot's lock first, so a run
+    # weekly job's worktree, those an older fun-ci kept under the git
+    # directory too, and git's entries for them, when no run or job holds one. It takes each slot's lock first, so a run
     # starting meanwhile waits until the slot is gone and then checks it out
     # afresh.
     class WorktreePrune
@@ -43,8 +43,13 @@ module FunCi
       end
 
       def slot_paths
-        (Dir.glob(File.join(@worktrees.root, "slot-*")) + Dir.glob(File.join(@worktrees.jobs_root, "*")))
-          .map { |path| path.delete_suffix(".lock") }.uniq
+        patterns.flat_map { |pattern| Dir.glob(pattern) }.map { |path| path.delete_suffix(".lock") }.uniq
+      end
+
+      def patterns
+        legacy = @worktrees.legacy_dir
+        [File.join(@worktrees.root, "slot-*"), File.join(@worktrees.jobs_root, "*"),
+         File.join(legacy, "worktrees", "slot-*"), File.join(legacy, "jobs", "*")]
       end
     end
   end

data/lib/fun_ci/pipeline/worktrees.rb

@@ -1,16 +1,23 @@
 # frozen_string_literal: true
 
 require "open3"
+require "digest"
 require_relative "git_environment"
+require_relative "../persistence/state_dir"
 
 module FunCi
   module Pipeline
-    # The git commands a worktree slot needs, run against the project's repository.
+    # The git commands a worktree slot needs, run against the project's
+    # repository. The worktrees live in fun-ci's state directory, one place
+    # per repository (all its git worktrees share it), and not under .git/,
+    # which tools such as Vite refuse to serve files from.
     class Worktrees
       class GitError < StandardError; end
 
-      def initialize(project_root)
+      # state_dir: fun-ci's own (Persistence::StateDir).
+      def initialize(project_root, state_dir: Persistence::StateDir.path(ENV))
         @project_root = project_root
+        @state_dir = state_dir
       end
 
       def root = File.join(fun_ci_dir, "worktrees")
@@ -18,13 +25,25 @@ module FunCi
       # Where each daily and weekly job has a worktree of its own (Jobs::Locks).
       def jobs_root = File.join(fun_ci_dir, "jobs")
 
+      # Where fun-ci before 2.4 kept the worktrees: under the git directory.
+      def legacy_dir = File.join(common_dir, "fun-ci")
+
       # 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.
-      def check_out(path, sha)
-        return add(path, sha) unless File.exist?(File.join(path, ".git"))
+      # so caches such as vendor/bundle survive between runs in the same slot,
+      # except under the +clean+ paths when +sha+ doesn't descend from the
+      # slot's last commit: those are outputs only as right as the commit that
+      # made them. Answers whether the slot is cold: a worktree it made, which
+      # has no caches, or one it cleaned.
+      def check_out(path, sha, clean: [])
+        return add(path, sha).then { true } unless File.exist?(File.join(path, ".git"))
 
+        moved_off = clean.any? && !descends?(path, sha)
         git(path, "checkout", "--detach", "--force", sha)
         git(path, "clean", "-fd")
+        return false unless moved_off
+
+        git(path, "clean", "-fdX", "--", *clean)
+        true
       end
 
       # Has git forget the worktrees whose directories are gone.
@@ -32,8 +51,22 @@ module FunCi
 
       private
 
+      # <state>/projects/<repository's name>-<digest of its git directory>.
       def fun_ci_dir
-        File.join(File.expand_path(git(@project_root, "rev-parse", "--git-common-dir").strip, @project_root), "fun-ci")
+        common = common_dir
+        name = File.basename(File.dirname(common))
+        File.join(@state_dir, "projects", "#{name}-#{Digest::SHA256.hexdigest(common)[0, 12]}")
+      end
+
+      def common_dir
+        File.realpath(File.expand_path(git(@project_root, "rev-parse", "--git-common-dir").strip, @project_root))
+      end
+
+      # Whether +sha+ descends from the commit checked out at +path+.
+      def descends?(path, sha)
+        last = git(path, "rev-parse", "HEAD").strip
+        _, status = Open3.capture2e(GitEnvironment::CLEAN, "git", "merge-base", "--is-ancestor", last, sha, chdir: path)
+        status.success?
       end
 
       def add(path, sha) = git(@project_root, "worktree", "add", "--detach", "--force", path, sha)

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

@@ -5,6 +5,7 @@ require_relative "hook_writer"
 require_relative "git_hooks"
 require_relative "setup_checker"
 require_relative "legacy_hooks"
+require_relative "init_options"
 
 module FunCi
   module Setup
@@ -18,13 +19,14 @@ module FunCi
       end
 
       def init(args)
-        code = Installer.run(project_root: @project_root, stdout: @stdout)
-        return code if !code.zero? || !args.include?("--everything")
-
-        code = install_hooks([])
-        return code unless code.zero?
-
-        check([])
+        options = InitOptions.parse(args)
+        code = Installer.run(project_root: @project_root, stdout: @stdout, stack: options.stack)
+        return code if !code.zero? || !options.everything
+
+        hooks_then_check
+      rescue InitOptions::Invalid => e
+        @stdout.puts "fun-ci init: #{e.message}"
+        64
       end
 
       def install_hooks(args)
@@ -32,10 +34,19 @@ 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
 
+      def hooks_then_check
+        code = install_hooks([])
+        return code unless code.zero?
+
+        check([])
+      end
+
       def install(types)
         hooks_dir = @hooks_dir.call(@project_root)
         types.each do |type|

data/lib/fun_ci/setup/eslint_detection.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "stage_templates"
+
+module FunCi
+  module Setup
+    # The build init writes for a JavaScript project that configures ESLint:
+    # the template's install, then ESLint, which loads what the install put
+    # in place, so it can't run in lint beside it (StageTemplates). nil keeps
+    # the template's build.
+    module EslintDetection
+      RUNNERS = { node_npm: "npx eslint .", node_pnpm: "pnpm exec eslint .", node_yarn: "yarn eslint .",
+                  bun: "bunx eslint ." }.freeze
+      CONFIGS = %w[eslint.config.js eslint.config.mjs eslint.config.cjs eslint.config.ts eslint.config.mts
+                   eslint.config.cts .eslintrc .eslintrc.js .eslintrc.cjs .eslintrc.json .eslintrc.yml
+                   .eslintrc.yaml].freeze
+
+      # names: the files at the project's top; package_json: its text.
+      def self.build(stack, names, package_json)
+        runner = RUNNERS[stack]
+        return nil unless runner && configured?(names, package_json)
+
+        "#{StageTemplates.scripts(stack)["build.sh"].lines.last.chomp} && #{runner}"
+      end
+
+      def self.configured?(names, package_json) = names.intersect?(CONFIGS) || in_package?(package_json)
+
+      def self.in_package?(text)
+        parsed = JSON.parse(text)
+        parsed.is_a?(Hash) && parsed.key?("eslintConfig")
+      rescue JSON::ParserError
+        false
+      end
+      private_class_method :configured?, :in_package?
+    end
+  end
+end

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/init_options.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module FunCi
+  module Setup
+    # The arguments of `fun-ci init [--everything] [--stack NAME]`.
+    module InitOptions
+      class Invalid < StandardError; end
+
+      Parsed = Data.define(:everything, :stack)
+
+      def self.parse(args)
+        values = { everything: false, stack: nil }
+        left = parser(values).parse(args)
+        raise Invalid, "takes no #{left.join(" ")}" if left.any?
+
+        Parsed.new(**values)
+      rescue OptionParser::ParseError => e
+        raise Invalid, e.message
+      end
+
+      # Long options only, without OptionParser's own --help and --version.
+      def self.parser(values)
+        parser = OptionParser.new
+        parser.base.long.clear
+        parser.on("--everything") { values[:everything] = true }
+        parser.on("--stack NAME") { |name| values[:stack] = name }
+        parser
+      end
+      private_class_method :parser
+    end
+  end
+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