proctolog 0.1.0

data/app/helpers/proctolog/desk_helper.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Proctolog
+  # What every page of the desk shares: its top line, how far the decisions
+  # are, and the list of keys that ? opens.
+  module DeskHelper
+    # A page of the desk in its top line, marked when it is the one shown.
+    def desk_link(name, path, on:) = link_to(name, path, aria: {current: ("page" if controller_name == on)})
+
+    # When GitHub was read, on this Mac's clock: "at 15:45" today, "on 12 Oct at 15:45" before.
+    def read_at_in_words(time)
+      time = time.localtime
+      time.strftime((time.to_date == Date.current) ? "at %H:%M" : "on %-d %b at %H:%M")
+    end
+
+    # How far one pull request is, as the side pane marks its row: every
+    # decision reviewed, some, none yet (which takes no mark), or none to
+    # review at all. The page's script writes the same marks as choices are made.
+    def side_mark(progress)
+      if !progress.any? then "-"
+      elsif progress.done? then "x"
+      elsif progress.reviewed.positive? then "~"
+      end
+    end
+
+    def side_fraction(progress) = ("#{progress.reviewed}/#{progress.total}" if progress.any?)
+
+    # The whole burst in one line: "6 of 439 decisions reviewed" over a bar.
+    # Focused on a part, what is left in it against the burst: "120 / 380
+    # decisions left, part / burst", over the part's bar.
+    def side_gauge(burst, part: nil)
+      said = part ? "#{number_with_delimiter(part.left)} / #{number_with_delimiter(burst.left)} decisions left, part / burst" : "#{number_with_delimiter(burst.reviewed)} of #{number_with_delimiter(burst.total)} decisions reviewed"
+      shown = part || burst
+      safe_join([tag.span(said), tag.meter(value: shown.reviewed, max: [shown.total, 1].max)])
+    end
+
+    # "12 of 21 decisions reviewed, 2 of them ticked on GitHub, 1 draft unfinished".
+    def progress_in_words(progress)
+      ["#{number_with_delimiter(progress.reviewed)} of #{pluralize(number_with_delimiter(progress.total), "decision")} reviewed",
+        ("#{progress.ticked} of them ticked on GitHub" if progress.ticked.positive?),
+        ("#{pluralize(progress.drafts, "draft")} unfinished" if progress.drafts.positive?)].compact.join(", ")
+    end
+
+    # One group of keys in the list: `keys` maps the keys, a space between
+    # those that go together, to what they do.
+    def keys_group(title, keys)
+      tag.section do
+        safe_join([tag.h3(title), tag.dl { safe_join(keys.map { |pressed, does| tag.div { tag.dt(keycaps(pressed)) + tag.dd(does) } }) }])
+      end
+    end
+
+    # The line the bar at the foot of a page starts with: its name, then pairs like the list's.
+    def mode_line(name, hints)
+      safe_join([tag.strong(name), *hints.map { |pressed, does| tag.span { keycaps(pressed) + " #{does}" } }])
+    end
+
+    private
+
+    def keycaps(pressed) = safe_join(pressed.split.map { tag.kbd(it) })
+  end
+end

data/app/helpers/proctolog/mentions_helper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Proctolog
+  # Words the owner or the agent wrote, as a page shows them: each # that
+  # names a pull request of the repository goes to it, its title beside. One
+  # of the burst's own goes to its page on the desk, any other to GitHub. A #
+  # the desk has not read of yet, or that names no pull request, stays as
+  # written.
+  module MentionsHelper
+    # Words cut on each # they hold, which stands apart among the pieces.
+    EACH_MENTION = /(#{Mentions::WRITTEN})/
+
+    def with_mentions(text, burst: nil) = safe_join(text.to_s.split(EACH_MENTION).map { mention_of(it, burst) || it })
+
+    private
+
+    def mention_of(piece, burst)
+      mention = piece[/\A#(\d+)\z/, 1]&.then { mentions&.[](it.to_i) } or return
+      address = burst&.route&.at(mention.number) ? burst_pull_request_path(burst, mention.number) : mention.url
+      tag.span(class: "mention", data: {state: mention.state}) do
+        safe_join([link_to(piece, address), tag.span(mention.title, class: "mention-title"), (tag.span("· #{mention.state}", class: "mention-state") unless mention.open?)].compact, " ")
+      end
+    end
+
+    def mentions = defined?(@mentions) ? @mentions : (@mentions = Mentions.here)
+  end
+end

data/app/helpers/proctolog/open_pull_requests_helper.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Proctolog
+  module OpenPullRequestsHelper
+    # What a pull request on the pick says of itself, after its title: whose it
+    # is, what it sits on when that is not main, and whether it asks anything.
+    def pick_facts(pick, pull_request)
+      decisions = pull_request.description.decisions
+      [
+        (pick.yours?(pull_request) ? "yours" : pull_request.author&.then { "by @#{it}" }),
+        ("on #{pull_request.base}" unless pull_request.base.in?(%w[main master])),
+        decisions.any? ? pluralize(decisions.size, "decision") : "not written for PRoctolog yet"
+      ].compact.join(" · ")
+    end
+
+    # Why a burst is put away, after its other facts: its work went in, or
+    # the owner was done with it; nothing while it is out.
+    def put_away_in_words(burst)
+      if burst.put_away_by_hand? then " · put away by you"
+      elsif burst.finished? then " · finished, #{pluralize(burst.merged.size, "pull request")} merged"
+      end
+    end
+
+    # What one nobody has opened yet says of itself: its branch, what it
+    # would go into, and whether it asks anything.
+    def unopened_facts(pull_request)
+      decisions = pull_request.description.decisions
+      safe_join([tag.code(pull_request.head), "into #{pull_request.base}", (decisions.any? ? pluralize(decisions.size, "decision") : "asks nothing")], " · ")
+    end
+  end
+end

data/app/helpers/proctolog/prompts_helper.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Proctolog
+  module PromptsHelper
+    # A link that opens a new Claude Code session in the Claude app, in the
+    # checkout under review, with this typed in. Nothing is sent until the
+    # owner sends it there. Spaces are written %20: a plus is not read as a
+    # space by every handler.
+    def new_session_address(file) = "claude://code/new?folder=#{ERB::Util.url_encode(Project.current.root.to_s)}&q=#{ERB::Util.url_encode(session_prompt(file))}"
+
+    # What that session is asked, also put on the clipboard for a session started by hand.
+    def session_prompt(file) = "Read #{file} and carry it out. It is the brief of my own hand-over from the review desk, and the rest of its folder holds the work: follow it as if I had typed it."
+
+    def handed_over(handover)
+      threads = handover.stops.sum { it.pull_request.threads.size }
+      asked = handover.stops.count { handover.worklist.of(it.number).items.any? || it.pull_request.threads.any? }
+      [pluralize(handover.worklist.items.size, "request"), ("#{pluralize(threads, "unresolved review thread")} on GitHub" if threads.positive?)]
+        .compact.to_sentence + " on #{pluralize(asked, "pull request")}"
+    end
+  end
+end

data/app/helpers/proctolog/pull_requests_helper.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Proctolog
+  module PullRequestsHelper
+    # "Layer 19 of 23" or "Stands alone".
+    def position_of(stop) = stop.stacked? ? "Layer #{stop.layer} of #{stop.of}" : "Stands alone"
+
+    # "not opened, on recovery/emails" for a pull request nobody has opened
+    # yet; nil for one open on GitHub.
+    def not_opened(stop) = (safe_join(["not opened, on ", tag.code(stop.pull_request.head)]) if stop.pull_request.unopened?)
+
+    # "#1060 Title", the number being the desk's page for it.
+    def pull_request_link(burst, stop)
+      safe_join([link_to("##{stop.number}", burst_pull_request_path(burst, stop.number), class: "number"), stop.title], " ")
+    end
+
+    # A section as GitHub rendered it, to be shown as it is. Under "Decisions for the owner" each box
+    # has what stands under it on the decisions page, the same partial; where
+    # GitHub's list and the Markdown's disagree, the boxes are left as they are.
+    def section_html(section, burst:, boxes:)
+      if section.heading == Description::DECISIONS && section.boxes.size == boxes.size
+        section.furnish_boxes { |position| render("proctolog/decisions/beneath", box: boxes[position], burst:, back: box_on_its_page(burst, boxes[position])) }
+      end
+      section.html
+    end
+
+    # "1 of 4 met", of the conditions that can be judged, beside the Standing section's heading.
+    def conditions_met(standing) = "#{standing.judged.count(&:met)} of #{standing.judged.size} met"
+
+    # One line of the outline: a section by name, and its count when it has one.
+    # `waits` says the count is of something the owner still has to do, which the
+    # outline sets in full relief; `waits_for` leaves the counting to the script;
+    # `apart` begins the sections that follow the description. A line with
+    # somewhere to go `to` leaves the page instead, and is no section.
+    def outline_line(name, count: nil, waits: false, waits_for: nil, apart: false, to: nil, **options)
+      said = safe_join([tag.span(name, class: "name"), tag.span(count, class: "count", data: {waits: (waits if count), waits_for:})])
+      to ? link_to(said, to, class: ("apart" if apart), **options) : tag.button(said, type: "button", class: ("apart" if apart), data: {fold: ""})
+    end
+
+    # What a section is worth a glance at, said quietly beside its heading.
+    def count_of(section)
+      case section.heading
+      when Description::DECISIONS then ((open = section.open_decisions).zero? ? "none open" : "#{open} open")
+      when "Screenshots" then pluralize(section.figures.size, "picture")
+      else "#{number_with_delimiter(section.words)} words"
+      end
+    end
+
+    # Open when it is the summary, or when it holds a note someone still has to act on.
+    def unfolded?(section) = section.heading == "Summary" || section.noted?
+
+    # The same files as another pull request, longest overlap first.
+    def by_overlap(shared) = shared.sort_by { |stop, files| [-files.size, stop.number] }
+
+    # A note's own place in words: what it quotes, or which picture it is on.
+    def place_of(note, rendering)
+      return unless note.place
+
+      case note.place
+      in Note::Quote => quote then tag.blockquote(quote.exact, class: "words")
+      in Note::Region => region then tag.p(safe_join(["On the picture ", tag.code(region.picture), (" (retaken since)" if rendering.retaken?(note))]), class: "where")
+      in Note::Scenario => scenario then tag.p("On the scenario #{scenario.name}", class: "where")
+      in Note::Moment => moment then tag.p(moment_place(note, moment), class: "where")
+      end
+    end
+  end
+end

data/app/helpers/proctolog/recordings_helper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Proctolog
+  module RecordingsHelper
+    # 83.4 as "1:23", and 3725 as "1:02:05".
+    def timecode(seconds)
+      hours, rest = seconds.floor.divmod(3600)
+      minutes, whole = rest.divmod(60)
+      hours.positive? ? format("%d:%02d:%02d", hours, minutes, whole) : format("%d:%02d", minutes, whole)
+    end
+
+    # A recording's name as a title: "first-run" is "First run".
+    def recording_title(recording) = recording.name.tr("-_", "  ").upcase_first
+
+    # Where a folder of recordings belongs: the owner's sitting, or a pull request.
+    def recording_folder(folder) = (folder == "sitting") ? "My sitting" : "##{folder}"
+
+    # How far along a film a time is, for a mark on its timeline.
+    def film_position(time, recording) = "#{(100 * time / recording.length).clamp(0, 100).round(3)}%"
+
+    # Where a note on a moment is: a link to that moment while the recording is still there.
+    def moment_place(note, moment)
+      text = "In #{File.basename(moment.recording, ".mp4")} at #{timecode(moment.time)}"
+      recording = Recording.at(moment.recording)
+      recording ? link_to(text, burst_recording_path(recording.burst_slug, recording.to_param, anchor: "note-#{note.id}")) : text
+    end
+
+    def player_link(burst, recording, text = recording_title(recording)) = link_to(text, burst_recording_path(burst, recording.to_param))
+  end
+end

data/app/helpers/proctolog/rounds_helper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Proctolog
+  module RoundsHelper
+    # What a page's script needs of the rounds: the requests that stand, the
+    # heads read, the answers that came back, and the batches the desk wrote,
+    # which a page takes in as its own so that it knows the answer to a pass
+    # an agent took itself. On a pull request's page, its description now
+    # and as each handover the desk kept found it, by batch, so the page can
+    # say what changed since.
+    def round_data(burst, pr: nil)
+      route = burst.route
+      rounds = Rounds.new(burst, route:)
+      responses = ResponseFiles.new(burst)
+      {requests: rounds.requests, batches: Handover.kept(burst).map(&:batch), reports: responses.all, errors: responses.errors,
+       responseFolder: responses.folder.to_s, heads: rounds.heads,
+       **(route.at(pr)&.then { |stop| {descriptions: descriptions_of(burst, stop)} } || {})}
+    end
+
+    private
+
+    def descriptions_of(burst, stop)
+      handed_over = Handover.kept(burst).filter_map { |kept| kept.description_of(stop.number)&.then { [kept.batch_id, it] } }.to_h
+      {now: stop.description.to_s, handedOver: handed_over}
+    end
+  end
+end

data/app/helpers/proctolog/scenarios_helper.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Proctolog
+  module ScenariosHelper
+    # "up at http://localhost:3300", "starting", "down".
+    def server_status(server)
+      case server.state
+      when :up then safe_join(["The server is up at ", link_to(server.address, server.address), "."])
+      when :starting then "The server is starting. This takes a minute or two."
+      else server.crashed? ? "The server has stopped." : "The server is down."
+      end
+    end
+
+    # Where a scenario opens, in a few words.
+    def where_it_opens(scenario)
+      size = scenario.size.is_a?(Array) ? scenario.size.join("x") : scenario.size
+      case scenario.browser.name
+      when "mine" then "In your own Chrome. It replaces whoever is signed in on this app, on every port of localhost, in that browser."
+      when "clean" then "In a Chrome of its own, #{size}"
+      else "In a new Chrome, #{size}, cookie banner up"
+      end
+    end
+
+    # A step of a description, with its `code` set in code.
+    def with_code(text)
+      safe_join(text.split(/`([^`]*)`/).each_with_index.map { |part, index| index.odd? ? tag.code(part) : part })
+    end
+
+    # What a step's Markdown sets apart from its words: code, bold and links.
+    MARKED = /(`[^`]*`|\*\*[^*\n]+\*\*|\[[^\]]+\]\([^)\s]+\))/
+    LINK = /\A\[(?<words>[^\]]+)\]\((?<to>[^)\s]+)\)\z/
+
+    # A step of a description as GitHub sets it. A link to one of the
+    # description's pictures stays on the page, where a press opens the
+    # picture to look at closely; any other leaves the desk.
+    def step_words(text) = safe_join(text.split(MARKED).map { marked(it) })
+
+    BROWSERS = {"mine" => "your own Chrome", "clean" => "a Chrome of its own", "fresh" => "a new Chrome"}.freeze
+
+    # How a scenario starts, in a line under its button: whom it signs in, the
+    # page it opens at, and its size and browser where those are its own.
+    def how_it_starts(scenario, browser: true)
+      who = if scenario.recipe then "as #{with_article(scenario.recipe.humanize(capitalize: false))}#{", signed out" if scenario.signed_out}"
+      elsif scenario.signed_out then "signed out"
+      else "as whoever is signed in"
+      end
+      size = Array(scenario.size).join("x") unless scenario.size == "desktop" || scenario.browser.mine?
+      safe_join([who, ", at ", page_it_opens(scenario), *(", #{size}" if size), *(", in #{BROWSERS.fetch(scenario.browser.name)}" if browser), "."])
+    end
+
+    # The line over the scenarios' buttons: what pressing one does, and the
+    # browser they share, while they can be pressed; when they wait, for what.
+    def tries_lede(scenario, ready:, shared:)
+      browser = " in #{BROWSERS.fetch(scenario.browser.name)}" if shared
+      ready ? "Each sets its state up and opens#{browser} where its steps begin." : "Each opens#{browser} once the server is up."
+    end
+
+    # A path as the owner would type it: from the checkout's root, or from ~.
+    def shown_path(path) = Project.current.from_root(path).to_s
+
+    # A checkout by its last two folders, which tell it apart; the whole path
+    # on hover.
+    def folder(path) = tag.code(["…", *Pathname(path).each_filename.to_a.last(2)].join("/"), title: shown_path(path))
+
+    # The commit that brought the app its app.yml, by its hash and its words.
+    def arrival_of(app)
+      app.arrival&.then { safe_join([tag.code(it.commit), ", “", it.subject.truncate(44), "”"]) } || "the commit that added it"
+    end
+
+    # Words to copy as they are, with the button that copies them.
+    def copyable(text)
+      tag.div(class: "copyable") { tag.pre(tag.code(text)) + tag.button("copy", type: "button", class: "quiet", data: {copy: ""}) }
+    end
+
+    def day_of(time) = time&.localtime&.strftime("%-d %b") || "an unknown day"
+
+    # The end of a server's log, each line cut to a width that reads.
+    def log_tail(server) = server.last_lines(16).lines.map { it.chomp.truncate(220) }.join("\n")
+
+    # What was last seen of a scenario, and whether that was on the commit it
+    # is on now.
+    # "Grouse's overlay opened twice, last at 20 Oct 14:32. 3 notes pinned from it."
+    def overlays_line(overlays)
+      at = Time.iso8601(overlays.last.opened).localtime.strftime("%-d %b %H:%M")
+      times = {1 => "once", 2 => "twice"}.fetch(overlays.size) { "#{overlays.size} times" }
+      "Grouse's overlay opened #{times}, last at #{at}. #{pluralize(overlays.sum { it.pinned.size }, "note")} pinned from it."
+    end
+
+    def seen_line(seen, head)
+      return "Not seen yet." unless seen
+
+      at = Time.iso8601(seen["seen"]).localtime.strftime("%-d %b %H:%M")
+      moved = " On an earlier commit than the present one." if head && seen["head"] != head
+      "#{Scenario::RESULTS.key(seen["result"])}, #{at}.#{moved}"
+    end
+
+    # The pull requests that have scenarios, in the order of the route.
+    def scenarios_by_pull_request(scenarios, route)
+      order = route.map(&:number)
+      scenarios.select(&:pr).group_by(&:pr).sort_by { |number, _| order.index(number) || order.size }
+    end
+
+    private
+
+    def marked(piece)
+      if (code = piece[/\A`(.*)`\z/, 1]) then tag.code(code)
+      elsif (bold = piece[/\A\*\*(.+)\*\*\z/, 1]) then tag.strong(bold)
+      elsif (link = piece.match(LINK)) then link_to(link[:words], link[:to], **(link[:to].start_with?("#") ? {} : {target: "_blank", rel: "noopener"}))
+      else piece
+      end
+    end
+
+    def page_it_opens(scenario)
+      case scenario.opens
+      when %r{\A/} then tag.code(scenario.opens)
+      when "lands_on" then "where its member lands"
+      else "the #{scenario.opens.tr("_", " ")} its state makes"
+      end
+    end
+
+    def with_article(words) = "#{words.match?(/\A[aeiou]/i) ? "an" : "a"} #{words}"
+  end
+end

data/app/helpers/proctolog/standings_helper.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Proctolog
+  module StandingsHelper
+    # The four things a pull request can be, in the order the owner reads them.
+    TURNS = {owner: "Your turn", agent: "The agent's turn", settled: "Settled", waiting: "Waiting on"}.freeze
+
+    VERDICTS = {true => "Met", false => "Not met", nil => "Yours to judge"}.freeze
+
+    # "Your turn", or "Waiting on" and what, in the standing's own words.
+    def turn_of(standing) = [TURNS.fetch(standing.turn), standing.marks.waiting_on].compact.join(" ")
+
+    def turn_tag(standing) = tag.span(turn_of(standing), class: "turn", data: {turn: standing.turn})
+
+    def reasons_of(standing) = line_of(standing, beside_the_count(standing, standing.open))
+
+    # On the route a change since the mark has a column of its own.
+    def route_reasons_of(standing) = line_of(standing, beside_the_count(standing, standing.otherwise_open))
+
+    # How many pull requests are at each turn, the turns with none included.
+    def turn_counts(standings)
+      counts = standings.each_value.map(&:turn).tally
+      TURNS.keys.index_with { counts.fetch(it, 0) }
+    end
+
+    # Whose the pull requests of a burst are, as the route's first line says it.
+    IN_A_SENTENCE = {owner: "yours to review", agent: "with the agent", settled: "settled", waiting: "waiting on something"}.freeze
+
+    # "25 are yours to review, 2 are with the agent." The owner's share stands out.
+    def turns_in_words(standings)
+      parts = turn_counts(standings).select { |_, count| count.positive? }.map do |turn, count|
+        tag.span("#{count} #{(count == 1) ? "is" : "are"} #{IN_A_SENTENCE.fetch(turn)}", class: ("yours" if turn == :owner))
+      end
+      safe_join([safe_join(parts, ", "), "."])
+    end
+
+    # What a line of the route says at its right: whose the pull request is when
+    # it is not the owner's, then how far its decisions are.
+    def beside_a_line(standing)
+      whose = {agent: "with the agent", settled: "settled", waiting: "waiting"}[standing.turn]
+      safe_join([whose, (tag.span(side_fraction(standing.progress), class: "fraction") if standing.progress.any?)].compact, " · ")
+    end
+
+    def verdict_of(condition) = VERDICTS.fetch(condition.met)
+
+    # What the drawer of a pull request's page holds, said beside its heading.
+    def drawer_count(standing, scenarios)
+      judged = standing.conditions.reject { it.met.nil? }
+      ["#{judged.count(&:met)} of #{pluralize(judged.size, "condition")} met", (pluralize(scenarios.size, "scenario") if scenarios.any?)].compact.join(" · ")
+    end
+
+    # The route's last column: once there is a mark, what moved since it.
+    def changed_since_mark(standing, pull_request)
+      return last_change(pull_request) unless standing.good_to_go?
+
+      standing.changed? ? tag.span("changed since your mark: #{standing.changed.to_sentence}", class: "moved") : "unchanged since your mark"
+    end
+
+    # "12 Oct 09:40" on this Mac's clock, for a time or the ISO 8601 text of one.
+    def clock(time) = time.to_time.localtime.strftime("%-d %b %H:%M")
+
+    # A commit by its first eight characters; the name of a branch whole.
+    def short(commit) = tag.code(commit.to_s.match?(/\A\h{40}\z/) ? commit[0, 8] : commit)
+
+    def lines_of(file) = file.binary? ? "binary" : safe_join([tag.span("+#{file.added}", class: "added"), tag.span("−#{file.removed}", class: "removed")], " ")
+
+    private
+
+    # The pages that give these reasons show how many decisions are reviewed
+    # right beside them, so the decisions are named only when nothing else is.
+    def beside_the_count(standing, reasons) = (reasons - standing.to_review).presence || reasons
+
+    # What is open, as a line. Under a mark nothing but decisions can be, and they are said as what the mark left.
+    def line_of(standing, reasons)
+      return "nothing is open" if reasons.empty?
+
+      [("with" if standing.settled?), reasons.join(" · ")].compact.join(" ")
+    end
+  end
+end

data/app/jobs/proctolog/application_job.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Proctolog
+  # What the desk does behind the owner's back, and on a schedule
+  # (Housekeeping), in its own process: nothing of it outlives `serve`.
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/jobs/proctolog/ask_for_release_job.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Proctolog
+  # Once a day (Housekeeping): which PRoctolog is the latest, for the pages to
+  # say when it is newer than the one running.
+  class AskForReleaseJob < ApplicationJob
+    def perform = Release.ask
+  end
+end

data/app/jobs/proctolog/fetch_pictures_ahead_job.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Proctolog
+  # Takes a reading's pictures ahead of the pages that show them, so a page
+  # that shows forty waits neither on forty requests nor on forty runs of
+  # ImageMagick: those on this Mac without a signature are signed, and those
+  # not on it yet are fetched, and signed as they land. One that cannot be
+  # fetched now is fetched when a page asks for it, and says why there.
+  class FetchPicturesAheadJob < ApplicationJob
+    # How many pictures are fetched, or signed, at a time.
+    ABREAST = 6
+
+    # gh has no token now: a page that asks for a picture says so. Those on
+    # this Mac need none, and are signed first.
+    discard_on Picture::Unavailable
+
+    # Each picture as a pair of its id and its kind.
+    def perform(pictures)
+      missing, held = pictures.map { Picture.new(*it) }.partition { !it.path.exist? }
+      abreast(held) { Picture.sign(it.asset) }
+      return if missing.empty?
+
+      token = Picture.token
+      abreast(missing) { it.fetch(token) }
+    end
+
+    private
+
+    # Each picture handed to the block, ABREAST at a time, while the job
+    # holds the app's executor.
+    def abreast(pictures, &each)
+      waiting = Queue.new(pictures).tap(&:close)
+      Array.new([ABREAST, pictures.size].min) { Thread.new { while (picture = waiting.pop) do each.call(picture) end } }.each(&:join)
+    end
+  end
+end

data/app/jobs/proctolog/prune_fresh_profiles_job.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Proctolog
+  # The desk's own prune, once a day (Housekeeping): the Chrome profiles of
+  # fresh browsers, one for every scenario opened in one.
+  class PruneFreshProfilesJob < ApplicationJob
+    def perform = Browser.prune_fresh_profiles
+  end
+end

data/app/jobs/proctolog/read_mentions_ahead_job.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Proctolog
+  # Reads the pull requests a # can name in a repository the desk has never
+  # read, so that the first # the owner types finds them there.
+  class ReadMentionsAheadJob < ApplicationJob
+    # The first # asks again, and says what GitHub answered.
+    discard_on Github::Unreachable
+
+    def perform(repository) = Mentions.new(Github.new(repository)).up_to_date
+  end
+end

data/app/models/proctolog/acceptance.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Proctolog
+  # Ticking decision boxes of one description: the one way the desk writes to
+  # GitHub, or to the file of a pull request nobody has opened yet. It is
+  # made to be shown before it is carried out: the boxes it will tick, and
+  # the command. Carried out, it reads the description again at that moment,
+  # ticks only lines that stand in it exactly once, changes nothing else, and
+  # checks that its home then holds what it sent.
+  class Acceptance
+    Refused = Class.new(StandardError)
+
+    attr_reader :number, :decisions
+
+    # `home` holds the description: Github, or Unopened.
+    def initialize(home:, number:, decisions:)
+      @home, @number, @decisions = home, number, decisions
+    end
+
+    FILE = "<the description, with these boxes ticked>"
+
+    # The command as the owner would type it, for showing first. The file is a
+    # temporary one, written at the moment it runs.
+    def command = @home.rewriting(number, "FILE").shelljoin.sub("FILE", FILE)
+
+    # `seen` is the digest of the description the owner was shown the command
+    # for: an edit since then, by anyone, stops it.
+    def carry_out(seen: nil)
+      before = @home.description_now(number)
+      seen.nil? || Description.new(before).digest == seen or raise Refused, "The description of ##{number} changed since you saw the command. Look at it again."
+      after = self.class.ticked(before, decisions.map(&:line))
+      @home.rewrite(number, after)
+      @home.description_now(number).strip == after.strip or raise Refused, "##{number} does not hold what was sent: read it before anything else"
+      decisions.map(&:lead)
+    end
+
+    # The text with each of these unticked lines ticked. Line endings are kept
+    # as they are; a line that is missing, or stands more than once, stops it.
+    def self.ticked(text, lines)
+      lines.reduce(text) do |ticking, line|
+        box = /^#{Regexp.escape(line)}(?=\r?$)/
+        ticking.scan(box).one? or raise Refused, "#{ticking.scan(box).size} lines, not one, read: #{line.truncate(90)}"
+        ticking.sub(box) { line.sub("- [ ]", "- [x]") }
+      end
+    end
+  end
+end