fun_ci 2.1.1-aarch64-linux → 2.3.0-aarch64-linux

data/lib/fun_ci/agent/job_why_text.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "stage_summary"
+require_relative "evidence_text"
+require_relative "span"
+require_relative "starts_in"
+
+module FunCi
+  module Agent
+    # What `fun-ci why --job NAME` prints (acceptance-tests.md, AT-13.21): the
+    # job and the commit its latest run tested, how that run ended, then
+    # everything kept about it.
+    module JobWhyText
+      PASSED = "Nothing is kept about a job that passed."
+      RUNNING = "It is still running; fun-ci wait doesn't wait for jobs, so ask again later."
+      CANCELLED = "It was cancelled; it runs again on the next commit."
+
+      def self.lines(report)
+        summary = StageSummary.line(report.stage, seconds: Span.method(:words))
+        [header(report), summary, *body(report), *raw(report), *only_tail(report)]
+      end
+
+      def self.header(report) = "fun-ci: job #{report.name} (#{report.cadence}) on #{report.branch} #{report.sha[0, 7]}"
+
+      def self.never_ran(report)
+        "fun-ci: job #{report.name} (#{report.cadence}) has not run yet; it runs on the next commit."
+      end
+
+      def self.body(report)
+        stage = report.stage
+        return [waiting(report)] if report.starts_in
+        return [PASSED] if stage.state == "passed"
+        return [RUNNING] if stage.state == "running"
+        return [CANCELLED] if stage.state == "cancelled"
+
+        EvidenceText.lines(stage.evidence)
+      end
+
+      def self.waiting(report)
+        "It waits its turn, and #{StartsIn.words(report.starts_in)}; " \
+          "fun-ci cancel --job #{report.name} cancels it."
+      end
+
+      def self.raw(report)
+        report.stage.raw_bytes ? ["", "The whole output: fun-ci why --job #{report.name} --raw"] : []
+      end
+
+      # So an agent that reads it knows it can write the extractor itself.
+      def self.only_tail(report)
+        excerpts = report.stage.evidence.excerpts
+        return [] if excerpts.empty? || excerpts.any? { |excerpt| excerpt[:extractor] != "output-tail" }
+
+        ["", "Only the output's last lines were kept; extractors under `evidence: jobs: #{report.name}:` " \
+             "in .fun-ci/config keep more."]
+      end
+      private_class_method :body, :waiting, :raw, :only_tail
+    end
+  end
+end

data/lib/fun_ci/agent/jobs_command.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "command_support"
+require_relative "jobs_text"
+require_relative "job_why"
+require_relative "job_json"
+
+module FunCi
+  module Agent
+    # `fun-ci jobs [--json]` (acceptance-tests.md, AT-13.22): the project's
+    # daily and weekly jobs and how each stands.
+    class JobsCommand
+      include CommandSupport
+
+      NAME = "jobs"
+      SCHEMA = 1
+
+      def initialize(context)
+        @context = context
+      end
+
+      def run(args)
+        options = Options.parse(args, takes: %i[json])
+        say(job_reports.all, options.json)
+        0
+      rescue Options::Invalid => e
+        usage(e.message)
+      end
+
+      private
+
+      def say(reports, json)
+        return out.puts(JSON.generate(schema: SCHEMA, jobs: reports.map { |report| JobJson.document(report) })) if json
+        return out.puts("fun-ci: #{JobWhy::NO_JOBS}") if reports.empty?
+
+        JobsText.lines(reports, @context.clock.now).each { |line| out.puts line }
+      end
+
+      def out = @context.io.stdout
+    end
+  end
+end

data/lib/fun_ci/agent/jobs_text.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "age"
+require_relative "due_in"
+require_relative "starts_in"
+require_relative "span"
+
+module FunCi
+  module Agent
+    # One line per daily or weekly job (acceptance-tests.md, AT-13.22), the
+    # names lined up: its cadence, its latest run's state in a word of four
+    # letters at most and how long it took, the branch and commit it tested
+    # and how long ago it started, as `runs` counts ages, and when the job is
+    # due again; then the `why --job`
+    # command of each job that failed or ran over budget.
+    module JobsText
+      WORDS = { "passed" => "ok", "failed" => "FAIL", "lost" => "LOST", "over_budget" => "OVER", "running" => "...",
+                "due" => "due", "cancelled" => "x", "scheduled" => "wait" }.freeze
+
+      # now: the time the ages and due times count from.
+      def self.lines(reports, now)
+        width = reports.map { |report| report.name.size }.max
+        reports.map { |report| line(report, width, now) } + whys(reports)
+      end
+
+      def self.whys(reports)
+        reports.select(&:needs_you?).map { |report| "fun-ci why --job #{report.name}" }
+      end
+
+      def self.line(report, width, now)
+        head = "#{report.name.ljust(width)}  #{report.cadence.ljust(6)}  #{WORDS.fetch(report.state,
+                                                                                       report.state).ljust(4)}"
+        return "#{head}  never ran  runs on the next commit" unless report.stage
+
+        "#{head}  #{seconds(report.stage)}  #{tested(report, now)}  #{due(report, now)}"
+      end
+
+      # `wip/foo 9e0b1d4  1h ago`; a run waiting its turn has not started.
+      def self.tested(report, now)
+        commit = "#{report.branch} #{report.sha[0, 7]}"
+        report.started_at ? "#{commit}  #{Age.words(now - report.started_at)}" : commit
+      end
+
+      def self.seconds(stage) = (stage.seconds ? Span.words(stage.seconds) : "").rjust(6)
+
+      def self.due(report, now)
+        return "running" if report.state == "running"
+        return StartsIn.words(report.starts_in) if report.starts_in
+
+        report.due_at ? "due in #{DueIn.words(report.due_at - now)}" : "runs on the next commit"
+      end
+      private_class_method :whys, :line, :tested, :seconds, :due
+    end
+  end
+end

data/lib/fun_ci/agent/live_pipeline.rb

@@ -6,10 +6,10 @@ require_relative "../setup/project_config"
 
 module FunCi
   module Agent
-    # The project's pipeline, as `wait` starts and watches it: a run starts
-    # the way the post-commit hook starts one, with `fun-ci trigger
-    # --background` in a process of its own, rather than as a fork of the
-    # waiting process and its open database connection.
+    # The project's pipeline, as `wait` starts and watches it and `cancel`
+    # stops a job of it: a run starts the way the post-commit hook starts one,
+    # with `fun-ci trigger --background` in a process of its own, rather than
+    # as a fork of the waiting process and its open database connection.
     class LivePipeline
       FUN_CI = File.expand_path("../../../exe/fun-ci", __dir__)
 
@@ -28,8 +28,16 @@ module FunCi
         Process.detach(pid).join
       end
 
-      # Records failed each slow suite whose process died (acceptance-tests.md, AT-8.3).
-      def watch(db) = Pipeline::RunCanceller.new.record_dead(db)
+      # Records failed each slow suite and each daily or weekly job whose
+      # process died (acceptance-tests.md, AT-8.3, AT-13.6).
+      def watch(db)
+        canceller = Pipeline::RunCanceller.new
+        canceller.record_dead(db)
+        canceller.record_dead_jobs(db)
+      end
+
+      # Stops a daily or weekly job's run and records it cancelled, as the console does.
+      def cancel_job(db, id) = Pipeline::RunCanceller.new.cancel_job(db, id)
     end
   end
 end

data/lib/fun_ci/agent/options.rb

@@ -12,12 +12,12 @@ module FunCi
       class Invalid < StandardError; end
 
       Parsed = Data.define(:rev, :stage, :need, :json, :within, :follow_branch, :limit, :branch, :follow, :only, :raw,
-                           :trunk)
+                           :trunk, :job)
       DEFAULTS = { need: "fast", json: false, within: nil, follow_branch: false, limit: 10, branch: nil,
-                   follow: false, only: nil, raw: false, trunk: false }.freeze
+                   follow: false, only: nil, raw: false, trunk: false, job: nil }.freeze
       SWITCHES = { need: ["--need LEVEL"], json: ["--json"], within: ["--within DURATION"], raw: ["--raw"],
                    follow_branch: ["--follow-branch"], limit: ["-n N", Integer], branch: ["--branch NAME"],
-                   follow: ["--follow"], only: ["--only KIND"], trunk: ["--trunk"] }.freeze
+                   follow: ["--follow"], only: ["--only KIND"], trunk: ["--trunk"], job: ["--job NAME"] }.freeze
       FILTERS = %w[failures].freeze
       MULTIPLIERS = { "" => 1, "s" => 1, "m" => 60 }.freeze
 

data/lib/fun_ci/agent/output.rb

@@ -9,6 +9,8 @@ require_relative "runs_text"
 require_relative "exit_code"
 require_relative "evidence_text"
 require_relative "trunk_why_json"
+require_relative "job_json"
+require_relative "job_report"
 
 module FunCi
   module Agent
@@ -24,8 +26,11 @@ module FunCi
         @trunk = trunk
       end
 
-      def report(report)
-        @json ? print_json(StatusJson.document(report)) : print_lines(StatusText.lines(report, trunk: @trunk))
+      # jobs: the commit's CommitJobs, when asked about.
+      def report(report, jobs: nil)
+        return print_json(with_jobs(StatusJson.document(report), jobs)) if @json
+
+        print_lines(StatusText.lines(report, trunk: @trunk, jobs: jobs || CommitJobs::NONE))
       end
 
       # Everything kept about the stage named, or says no stage decided the verdict.
@@ -87,6 +92,13 @@ module FunCi
 
       private
 
+      def with_jobs(document, jobs)
+        return document unless jobs
+
+        document.merge(jobs: jobs.on_commit.map { |job| JobJson.document(job) },
+                       failing_jobs: jobs.failing.map { |job| JobJson.document(job) })
+      end
+
       def print_json(document) = @stdout.puts(JSON.generate(document))
       def print_lines(lines) = lines.each { |line| @stdout.puts line }
     end

data/lib/fun_ci/agent/snapshots.rb

@@ -6,16 +6,21 @@ require_relative "run_report"
 require_relative "events"
 require_relative "trunk_reading"
 require_relative "trunk_json"
+require_relative "job_events"
+require_relative "../jobs/state"
+require_relative "../persistence/job_runs"
 
 module FunCi
   module Agent
     # Looks at the newest runs of the project git names, as `events` compares
-    # them: { run id => Events::RunState }.
+    # them: { run id => Events::RunState }; and at its newest daily and weekly
+    # job runs: { job run id => JobEvents::JobState }.
     class Snapshots
       def initialize(db, git, clock)
         project = git.toplevel
         @db = db
         @runs = Persistence::ProjectRuns.new(db, project)
+        @job_runs = Persistence::JobRuns.new(db, project)
         @trunk = TrunkReading.new(db, project, clock, TrunkReading::UNREAD)
       end
 
@@ -23,8 +28,22 @@ module FunCi
         @runs.recent(limit: limit, branch: nil).to_h { |run| [run[:id], state_of(run)] }
       end
 
+      def jobs(limit:)
+        @job_runs.recent(limit: limit).to_h { |run| [run[:id], job_state(run)] }
+      end
+
       private
 
+      def job_state(run)
+        JobEvents::JobState.new(id: run[:id], job: run[:job], cadence: run[:cadence], sha: run[:commit_hash],
+                                branch: run[:branch], state: Jobs::State.of(run),
+                                seconds: Persistence::StageJob.elapsed_duration(run)&.round(1),
+                                starts_at: starts_at(run))
+      end
+
+      # When a run waiting its turn starts, as an ISO time; nil for any other.
+      def starts_at(run) = run[:status] == "scheduled" ? Time.parse(run[:started_at]).utc.iso8601 : nil
+
       def state_of(run)
         superseded_by = run[:status] == "cancelled" ? @runs.superseded_by(run) : nil
         Events::RunState.new(id: run[:id], sha: run[:commit_hash], branch: run[:branch], status: run[:status],

data/lib/fun_ci/agent/span.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Agent
+    # How long a daily or weekly job's run took, in the words the console uses
+    # for it: `42s`, `50m`, `3h12m`, `1d`, `1d2h`.
+    module Span
+      def self.words(seconds)
+        whole = seconds.round
+        return "#{whole}s" if whole < 60
+        return "#{whole / 60}m" if whole < 3600
+        return joined(whole / 3600, "h", (whole % 3600 / 60).to_s.rjust(2, "0"), "m") if whole < 86_400
+
+        joined(whole / 86_400, "d", (whole % 86_400 / 3600).to_s, "h")
+      end
+
+      # `3h12m`, or `3h` when there is nothing of the smaller unit.
+      def self.joined(big, big_unit, small, small_unit)
+        small.to_i.zero? ? "#{big}#{big_unit}" : "#{big}#{big_unit}#{small}#{small_unit}"
+      end
+      private_class_method :joined
+    end
+  end
+end

data/lib/fun_ci/agent/stage_summary.rb

@@ -7,8 +7,9 @@ module FunCi
     module StageSummary
       WORDS = { "over_budget" => "ran over budget" }.freeze
 
-      def self.line(stage)
-        "#{stage.name} #{WORDS.fetch(stage.state, stage.state)}#{ending(stage)}#{took(stage)}"
+      # seconds: how a length of time is said; in seconds by default, `1.4s`.
+      def self.line(stage, seconds: ->(time) { "#{time}s" })
+        "#{stage.name} #{WORDS.fetch(stage.state, stage.state)}#{ending(stage)}#{took(stage, seconds)}"
       end
 
       def self.ending(stage)
@@ -18,13 +19,16 @@ module FunCi
         ""
       end
 
-      def self.took(stage)
+      def self.took(stage, seconds)
         return "" unless stage.seconds
 
-        budget = stage.budget ? ", budget #{stage.budget}s" : ""
-        " after #{stage.seconds}s#{budget}"
+        budget = stage.budget ? ", budget #{budget(stage.budget)}" : ""
+        " after #{seconds.call(stage.seconds)}#{budget}"
       end
-      private_class_method :ending, :took
+
+      # In hours when it is whole hours, as a job's day is: `24h`; else in seconds, `10s`.
+      def self.budget(seconds) = seconds >= 3600 && (seconds % 3600).zero? ? "#{seconds / 3600}h" : "#{seconds}s"
+      private_class_method :ending, :took, :budget
     end
   end
 end

data/lib/fun_ci/agent/starts_in.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "due_in"
+
+module FunCi
+  module Agent
+    # When a job waiting its turn (Jobs::Schedule) starts, as agents are
+    # told it: `starts in 6h`, or `starts now` once its time has come and its
+    # process has yet to start it.
+    module StartsIn
+      def self.words(seconds) = seconds.positive? ? "starts in #{DueIn.words(seconds)}" : "starts now"
+    end
+  end
+end

data/lib/fun_ci/agent/status_command.rb

@@ -5,7 +5,8 @@ require_relative "output"
 
 module FunCi
   module Agent
-    # `fun-ci status [REV] [--need LEVEL] [--json]` (acceptance-tests.md, AT-9.2).
+    # `fun-ci status [REV] [--need LEVEL] [--json]` (acceptance-tests.md,
+    # AT-9.2): the commit's run, and the jobs whose latest run tested it (AT-13.24).
     class StatusCommand
       include CommandSupport
 
@@ -28,7 +29,7 @@ module FunCi
       def answer(sha, report, output)
         return output.unknown(sha) unless report
 
-        output.report(report)
+        output.report(report, jobs: job_reports.of_commit(sha))
         ExitCode::FOR.fetch(report.verdict)
       end
     end

data/lib/fun_ci/agent/status_json.rb

@@ -19,7 +19,7 @@ module FunCi
       def self.unknown(sha) = { schema: SCHEMA, commit: { sha: sha }, verdict: "unknown" }
 
       def self.stage(stage)
-        facts = { name: stage.name, state: stage.state, seconds: stage.seconds }
+        facts = { name: stage.name, state: stage.state, seconds: stage.seconds, budget: stage.budget }
         stage.failures.any? ? facts.merge(failures: stage.failures) : facts
       end
       private_class_method :stage

data/lib/fun_ci/agent/status_text.rb

@@ -4,21 +4,40 @@ require_relative "run_report"
 require_relative "verdict"
 require_relative "digest"
 require_relative "trunk_text"
+require_relative "job_report"
+require_relative "starts_in"
+require_relative "../pipeline/budgets"
 
 module FunCi
   module Agent
     # A run report as text: the commit, a line per stage with what went wrong
     # in capitals, then the evidence of each needed stage that failed.
     module StatusText
-      WORDS = { "failed" => "FAILED", "over_budget" => "OVER BUDGET" }.freeze
+      WORDS = { "failed" => "FAILED", "over_budget" => "OVER BUDGET", "lost" => "LOST" }.freeze
 
-      # trunk: whether the agent asked about the trunk, which says so while its check is going.
-      def self.lines(report, trunk: false)
+      # trunk: whether the agent asked about the trunk, which says so while its
+      # check is going; jobs: the commit's CommitJobs, which change nothing
+      # about the verdict.
+      def self.lines(report, trunk: false, jobs: CommitJobs::NONE)
         needed = Verdict::LEVELS.fetch(report.need)
         [header(report), *report.stages.map { |stage| stage_line(stage, needed) }, *Digest.lines(report.stages, needed),
-         *trunk(report, trunk), *footer(report)]
+         *job_lines(jobs), *trunk(report, trunk), *footer(report)]
       end
 
+      def self.job_lines(jobs)
+        jobs.on_commit.map { |job| job_line(job) } + jobs.failing.map { |job| job_line(job, " on #{job.sha[0, 7]}") }
+      end
+
+      # `  soak (weekly job) FAILED  fun-ci why --job soak`; `where` names the
+      # commit it tested when that is another.
+      def self.job_line(job, where = "")
+        said = "  #{job.name} (#{job.cadence} job) #{WORDS.fetch(job.state, job.state)}#{starts(job)}#{where}"
+        job.needs_you? ? "#{said}  fun-ci why --job #{job.name}" : said
+      end
+
+      # `, starts in 8m` for a job waiting its turn.
+      def self.starts(job) = job.starts_in ? ", #{StartsIn.words(job.starts_in)}" : ""
+
       # The trunk lines; nothing while the check is going, unless asked about
       # (right after a commit it would say nothing useful).
       def self.trunk(report, asked)
@@ -31,10 +50,17 @@ module FunCi
 
       def self.stage_line(stage, needed)
         seconds = stage.seconds ? format("%6.1fs", stage.seconds) : " " * 7
-        note = needed.include?(stage.name) ? "" : " (not needed)"
+        note = (needed.include?(stage.name) ? "" : " (not needed)") + longer(stage)
         "  #{stage.name.ljust(6)} #{WORDS.fetch(stage.state, stage.state).ljust(12)}#{seconds}#{note}".rstrip
       end
 
+      # Only a worktree just made gives a stage more than its usual budget
+      # (AT-1.14), which a run in the background says nowhere else.
+      def self.longer(stage)
+        usual = Pipeline::DEFAULT_BUDGETS[stage.name]
+        stage.budget && usual && stage.budget > usual ? "  (new worktree, budget #{stage.budget}s)" : ""
+      end
+
       def self.footer(report)
         return ["fun-ci why #{report.sha[0, 7]} #{report.deciding}"] if report.deciding
         return ["fun-ci why #{report.sha[0, 7]} trunk"] if report.trunk&.state == "conflicts"
@@ -42,7 +68,7 @@ module FunCi
 
         ["Superseded by #{report.superseded_by[0, 7]}."]
       end
-      private_class_method :stage_line, :footer
+      private_class_method :stage_line, :longer, :footer, :job_lines, :job_line, :starts
     end
   end
 end

data/lib/fun_ci/agent/trunk_reading.rb

@@ -28,7 +28,8 @@ module FunCi
         return shown(check) if check
 
         started = run[:trunk_started_at]
-        started && Trunk::Shown.unchecked(started: Time.parse(started), now: @clock.now)
+        started && Trunk::Shown.unchecked(started: Time.parse(started), now: @clock.now,
+                                          stages_running: !run[:trigger_pid].nil?)
       end
 
       # Checks the commit against where the trunk is now, without fetching, and keeps the check,

data/lib/fun_ci/agent/wait_command.rb

@@ -52,9 +52,10 @@ module FunCi
         ExitCode::FOR.fetch(report.verdict)
       end
 
+      # A waiter keeps its run from being superseded, unless it follows the branch to the newer commit.
       def poll(sha, options)
         @context.pipeline.watch(@context.db)
-        reports.mark_waited(sha, @context.clock.now)
+        reports.mark_waited(sha, @context.clock.now) unless options.follow_branch
         report_for(sha, options) || start_after_grace(sha)
       end
 

data/lib/fun_ci/agent/why_command.rb

@@ -3,13 +3,15 @@
 require_relative "command_support"
 require_relative "output"
 require_relative "trunk_why"
+require_relative "job_why"
 
 module FunCi
   module Agent
     # `fun-ci why [REV] [STAGE] [--need LEVEL] [--json] [--raw]`
     # (acceptance-tests.md, AT-10.1, AT-10.6): everything kept about the stage
     # named, or else about the stage that decided the verdict; with --raw, the
-    # raw output it kept, and nothing else.
+    # raw output it kept, and nothing else. With `--job NAME`, the same about
+    # a daily or weekly job's latest run (JobWhy).
     class WhyCommand
       include CommandSupport
 
@@ -20,7 +22,9 @@ module FunCi
       end
 
       def run(args)
-        options = Options.parse(args, takes: %i[need json stage raw])
+        options = Options.parse(args, takes: %i[need json stage raw job])
+        return JobWhy.new(@context, job_reports).answer(options) if options.job
+
         sha = resolve(options.rev)
         answer(sha, reports.for(sha, options.need), options)
       rescue Options::Invalid => e

data/lib/fun_ci/cli.rb

@@ -17,7 +17,7 @@ module FunCi
       "prune" => :run_prune,
       "extract" => :run_extract
     }.freeze
-    AGENT_COMMANDS = %w[status runs wait events why].freeze
+    AGENT_COMMANDS = %w[status runs wait events why jobs cancel].freeze
 
     def self.default_db_dir = Persistence::StateDir.path(ENV)
 

data/lib/fun_ci/cli_help.rb

@@ -31,6 +31,8 @@ module FunCi
         wait           Wait for a commit's verdict, then exit with it as status does
         events         Print this project's runs' events as JSON lines
         why            Print everything kept about why a commit's stage failed, or its conflict with the trunk
+        jobs           List this project's daily and weekly jobs and how each stands
+        cancel         Cancel a daily or weekly job's run: cancel --job NAME
         extract        Try a stage's evidence extractors on a saved output
 
       Options:
@@ -46,10 +48,11 @@ module FunCi
         --follow-branch  (wait) Move on to the newer commit that superseded the run
         --trunk        (status, wait) Exit 6 when the run passed but conflicts with the trunk
         --raw          (why) Print the stage's whole output as it was kept
+        --job NAME     (why, cancel) The daily or weekly job to explain or cancel, instead of a commit
         -n N           (runs) How many runs to list (default 10)
         --branch NAME  (runs) Only runs on this branch
         --follow       (events) Keep printing events as they happen, until stopped
-        --only failures  (events) Print only failed stages and superseded runs
+        --only failures  (events) Print only failed stages, superseded runs and failed jobs
         --json         Print JSON instead of text (events always print JSON lines)
         Exit codes: 0 passed, 1 failed, 2 over budget, 3 undecided,
         4 superseded, 5 no run, 6 conflicts with the trunk (--trunk), 64 usage error

data/lib/fun_ci/console/board_data.rb

@@ -9,6 +9,9 @@ require_relative "streak_counter"
 require_relative "trunk_marks"
 require_relative "cancelled_folding"
 require_relative "row_order"
+require_relative "paging"
+require_relative "job_rows"
+require_relative "../persistence/active_jobs"
 
 module FunCi
   module Console
@@ -17,39 +20,49 @@ module FunCi
       # find its standing against the trunk.
       BRANCH_WINDOW = 100
 
-      def initialize(db, limit: 15, page_size: nil, run_canceller: Pipeline::RunCanceller.new)
+      # `clock` answers the time now, which decides which jobs are due.
+      def initialize(db, page_size: 15, run_canceller: Pipeline::RunCanceller.new, clock: -> { Time.now })
         @db = db
-        @page_size = page_size || limit
-        @limit = @page_size
+        @paging = Paging.new(page_size)
         @run_canceller = run_canceller
+        @clock = clock
       end
 
-      def load_more
-        @limit += @page_size
-      end
+      def load_more = @paging.load_more
 
       # Pages by `page_size` from now on, loading at least one such page.
-      def resize(page_size)
-        @page_size = page_size
-        @limit = [@limit, page_size].max
-      end
+      def resize(page_size) = @paging.resize(page_size)
 
       # Whether there are branches beyond those `runs` loads.
-      def more? = Persistence::PipelineRun.branch_heads(@db, limit: @limit + 1).size > @limit
+      def more? = Persistence::PipelineRun.branch_heads(@db, limit: @paging.limit + 1).size > @paging.limit
 
       # Records failed each slow suite whose process died (acceptance-tests.md, AT-8.3).
       def record_dead_slow_suites = @run_canceller.record_dead(@db)
 
+      # The job section's rows (JobRows): the jobs of the projects among `runs`.
+      def jobs(runs)
+        JobRows.new(@db).of(runs.map { |run| run[:project_path] }.uniq.compact, now: @clock.call)
+      end
+
+      # Records failed each job whose process died (acceptance-tests.md, AT-13.6).
+      def record_dead_jobs = @run_canceller.record_dead_jobs(@db)
+
+      # Stops a daily or weekly job's processes, then records it cancelled,
+      # unless it has finished meanwhile.
+      def cancel_job(id) = @run_canceller.cancel_job(@db, id)
+
       # One row per branch, its newest run, for the branches that most need you
       # and then those run most recently, in RowOrder: a run of cancelled
       # runs folded into one, with its stages and the branch's standing against the trunk.
-      def runs = RowOrder.of(Persistence::PipelineRun.branch_heads(@db, limit: @limit).map { |head| branch_row(head) })
+      def runs
+        RowOrder.of(Persistence::PipelineRun.branch_heads(@db, limit: @paging.limit).map { |head| branch_row(head) })
+      end
 
       # The projects among `runs` whose trunk is stale.
       def stale_trunks(runs, now:) = TrunkMarks.new(@db).stale(runs, now: now)
 
       def streak
-        pipeline_runs = Persistence::PipelineRun.recent(@db, limit: @limit)
+        pipeline_runs = Persistence::PipelineRun.recent(@db, limit: @paging.limit)
         StreakCounter.count(pipeline_runs)
       end