fun_ci 2.1.0-aarch64-linux → 2.2.0-aarch64-linux

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,18 @@ 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))
+      end
+
       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/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_text.rb

@@ -4,19 +4,33 @@ require_relative "run_report"
 require_relative "verdict"
 require_relative "digest"
 require_relative "trunk_text"
+require_relative "job_report"
 
 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)}#{where}"
+        job.needs_you? ? "#{said}  fun-ci why --job #{job.name}" : said
       end
 
       # The trunk lines; nothing while the check is going, unless asked about
@@ -42,7 +56,7 @@ module FunCi
 
         ["Superseded by #{report.superseded_by[0, 7]}."]
       end
-      private_class_method :stage_line, :footer
+      private_class_method :stage_line, :footer, :job_lines, :job_line
     end
   end
 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].freeze
 
     def self.default_db_dir = Persistence::StateDir.path(ENV)
 

data/lib/fun_ci/cli_help.rb

@@ -21,7 +21,7 @@ module FunCi
 
       Commands:
         trigger        Run CI pipeline for a commit
-        console        Launch the admin TUI dashboard
+        console        Watch your runs as they happen, in the terminal
         init           Initialize .fun-ci/ with template scripts
         install-hooks  Install post-commit and pre-push git hooks
         check          Verify project setup
@@ -31,6 +31,7 @@ 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
         extract        Try a stage's evidence extractors on a saved output
 
       Options:
@@ -46,10 +47,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) Explain the daily or weekly job's latest run instead of a commit's stage
         -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
 

data/lib/fun_ci/console/console_state.rb

@@ -2,12 +2,14 @@
 
 require_relative "run_message"
 require_relative "console_events"
+require_relative "job_message"
 
 module FunCi
   module Console
     # What the console shows: the page of runs BoardData reads that the View
-    # puts on screen, and the clock's time, as a protocol `board` message,
-    # after the `event`s for what changed since the last one.
+    # puts on screen, the daily and weekly jobs below it, and the clock's
+    # time, as a protocol `board` message, after the `event`s for what changed
+    # since the last one.
     class ConsoleState
       KEYS = { "up" => :up, "down" => :down, "esc" => :escape, "ctrl_c" => "q", "enter" => :enter }.freeze
 
@@ -26,18 +28,22 @@ module FunCi
 
       def updates
         @board_data.record_dead_slow_suites
+        @board_data.record_dead_jobs
         runs = @board_data.runs
-        [*@events.since_last(runs), board(runs)]
+        [*@events.since_last(runs), board(runs, @board_data.jobs(runs))]
       end
 
       private
 
-      def board(runs)
-        page = @view.page(runs, more: @board_data.more?)
+      def board(runs, jobs)
+        page = @view.page(runs, more: @board_data.more?, jobs: jobs)
         { t: "board", now: @clock.call.to_i, streak: @board_data.streak, **page,
-          runs: page[:runs].map { |run| RunMessage.from(run) }, **stale_trunks(runs) }
+          runs: page[:runs].map { |run| RunMessage.from(run) }, **job_section(jobs), **stale_trunks(runs) }
       end
 
+      # Only when there are jobs, as the protocol lets a board leave them out.
+      def job_section(jobs) = jobs.empty? ? {} : { jobs: jobs.map { |job| JobMessage.from(job) } }
+
       # Only when a trunk is stale, as the protocol lets a board leave it out.
       def stale_trunks(runs)
         stale = @board_data.stale_trunks(runs, now: @clock.call)

data/lib/fun_ci/console/job_message.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "time"
+
+module FunCi
+  module Console
+    # Where a job stands (Jobs::Standing) as the protocol's `board` carries it
+    # under `jobs`: protocol status names and epoch seconds. Formatting them
+    # is the renderer's job.
+    module JobMessage
+      # The protocol's word for a Jobs::State, where it has one of its own:
+      # a cancelled job is due again, and one it can't read is shown due.
+      STATUS = { "over_budget" => "timeout", "cancelled" => "due", "unknown" => "due" }.freeze
+
+      def self.from(standing)
+        { project: standing.project, name: standing.name, cadence: standing.cadence,
+          status: STATUS.fetch(standing.state, standing.state), **run(standing.run),
+          due_at: standing.due_at&.to_i }.compact
+      end
+
+      # What the latest run says: which, on what, and when.
+      def self.run(run)
+        return {} unless run
+
+        { run_id: run[:id], sha: run[:commit_hash], branch: run[:branch], started_at: epoch(run[:started_at]),
+          updated_at: epoch(run[:completed_at] || run[:started_at]) }
+      end
+
+      def self.epoch(iso) = Time.parse(iso).to_i
+      private_class_method :run, :epoch
+    end
+  end
+end

data/lib/fun_ci/console/job_order.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Console
+    # The order of the job section's rows (design.md, The console): what
+    # needs you first, then running, due and passed; among equals, the
+    # board's projects in its order, then each project's jobs by name. Rows
+    # answer #state (Jobs::State), #project and #name.
+    module JobOrder
+      URGENCY = { "failed" => 0, "lost" => 0, "over_budget" => 1, "running" => 2, "due" => 3, "cancelled" => 3,
+                  "passed" => 4 }.freeze
+      # A state this fun-ci doesn't know, which a newer one sharing the database may have written.
+      UNKNOWN = 5
+
+      def self.of(rows, projects:)
+        rows.sort_by do |row|
+          [URGENCY.fetch(row.state, UNKNOWN), projects.index(row.project) || projects.size, row.name]
+        end
+      end
+    end
+  end
+end

data/lib/fun_ci/console/job_rows.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "job_order"
+require_relative "../jobs/standings"
+
+module FunCi
+  module Console
+    # The job section's rows (design.md, The console): where each daily and
+    # weekly job of the board's projects stands (Jobs::Standing), in JobOrder.
+    class JobRows
+      def initialize(db)
+        @db = db
+      end
+
+      def of(projects, now:)
+        standings = projects.flat_map { |project| Jobs::Standings.new(@db, project, now: now).all }
+        JobOrder.of(standings, projects: projects)
+      end
+    end
+  end
+end

data/lib/fun_ci/console/key_handler.rb

@@ -2,9 +2,10 @@
 
 module FunCi
   module Console
-    # What a key means for the runs BoardData loads: moving the cursor,
-    # quitting, and cancelling the run under the cursor (a running one after
-    # the user confirms with `y`).
+    # What a key means for the runs BoardData loads, and the daily and weekly
+    # jobs after them: moving the cursor through both, quitting, and
+    # cancelling the run or job under the cursor (a running one after the
+    # user confirms with `y`).
     class KeyHandler
       CONFIRMATION_ANSWERS = ["y", "n", :escape].freeze
 
@@ -27,10 +28,6 @@ module FunCi
         !@confirm_cancel.nil?
       end
 
-      def confirmation_run
-        @confirm_cancel
-      end
-
       private
 
       def act(key)
@@ -41,15 +38,16 @@ module FunCi
         end
       end
 
-      # Onto the last run loaded, which loads the next page.
+      # Onto the last run loaded, which loads the next page, then into the jobs.
       def move_cursor_down
-        last = @board_data.runs.length - 1
+        runs = @board_data.runs
+        last = runs.length + @board_data.jobs(runs).length - 1
         return if last.negative?
         return @cursor_index = 0 if @cursor_index.nil?
         return unless @cursor_index < last
 
         @cursor_index += 1
-        @board_data.load_more if @cursor_index == last
+        @board_data.load_more if @cursor_index == runs.length - 1
       end
 
       def move_cursor_up
@@ -57,17 +55,38 @@ module FunCi
       end
 
       def initiate_cancel
-        run = @cursor_index && @board_data.runs[@cursor_index]
-        return unless run
+        kind, row = under_cursor
+        return unless row
 
+        kind == :job ? offer_job_cancel(row) : offer_run_cancel(row)
+      end
+
+      # A run waiting to start is cancelled at once; a running one once the user confirms.
+      def offer_run_cancel(run)
         @board_data.cancel_run(run[:id]) if run[:status] == "scheduled"
-        @confirm_cancel = run if run[:status] == "running"
+        @confirm_cancel = [:run, run] if run[:status] == "running"
+      end
+
+      # A running job (a Jobs::Standing) once the user confirms.
+      def offer_job_cancel(job)
+        @confirm_cancel = [:job, job] if job.state == "running"
+      end
+
+      # [:run, the run] or [:job, the job row] under the cursor, or none.
+      def under_cursor
+        runs = @board_data.runs
+        return [] unless @cursor_index
+        return [:run, runs[@cursor_index]] if @cursor_index < runs.length
+
+        [:job, @board_data.jobs(runs)[@cursor_index - runs.length]]
       end
 
       def confirm(key)
-        @board_data.cancel_run(@confirm_cancel[:id]) if key == "y"
+        cancel(*@confirm_cancel) if key == "y"
         @confirm_cancel = nil if CONFIRMATION_ANSWERS.include?(key)
       end
+
+      def cancel(kind, row) = kind == :job ? @board_data.cancel_job(row.run[:id]) : @board_data.cancel_run(row[:id])
     end
   end
 end

data/lib/fun_ci/console/paging.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Console
+    # How many branches BoardData loads: a page of `page_size` at first, a
+    # page more each time the cursor reaches the last one loaded.
+    class Paging
+      attr_reader :limit
+
+      def initialize(page_size)
+        @page_size = page_size
+        @limit = page_size
+      end
+
+      def load_more
+        @limit += @page_size
+      end
+
+      # 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
+    end
+  end
+end

data/lib/fun_ci/console/view.rb

@@ -11,6 +11,8 @@ module FunCi
       # table: a page this many rows short of the terminal fits one line per
       # row, however the renderer spaces them (renderer-protocol.md, `board`).
       CHROME_ROWS = 18
+      # A blank line and one for the job section, the least the renderer folds it to.
+      JOB_LINES = 2
 
       def initialize(key_handler:)
         @key_handler = key_handler
@@ -25,23 +27,30 @@ module FunCi
       # :quit when the key ends the session.
       def press(key) = @key_handler.handle_key(key)
 
-      # `more`: whether the store holds runs beyond `runs`.
-      def page(runs, more:)
-        first = first_shown
-        { cursor: cursor_on_page(first), confirming: @key_handler.confirming?,
-          has_more: more || first + @page_size < runs.size, runs: runs[first, @page_size] || [] }
+      # `more`: whether the store holds runs beyond `runs`. `jobs`: the job
+      # section's rows, below the page, which the cursor reaches after the runs.
+      def page(runs, more:, jobs: [])
+        size = jobs.empty? ? @page_size : [@page_size - JOB_LINES, 0].max
+        first = first_shown(runs.size, size)
+        { cursor: cursor_on_page(first, size), confirming: @key_handler.confirming?,
+          has_more: more || first + size < runs.size, runs: runs[first, size] || [] }
       end
 
       private
 
-      def first_shown
+      # The last page of runs while the cursor is on a job.
+      def first_shown(count, size)
         cursor = @key_handler.cursor_index
-        cursor ? [cursor - @page_size + 1, 0].max : 0
+        return 0 unless cursor
+
+        [[cursor, count - 1].min - size + 1, 0].max
       end
 
-      def cursor_on_page(first)
+      # Past the page's runs while the cursor is on a job: a page that holds
+      # a job's cursor ends at the last run.
+      def cursor_on_page(first, size)
         cursor = @key_handler.cursor_index
-        cursor - first if cursor && @page_size.positive?
+        cursor - first if cursor && size.positive?
       end
     end
   end