proctolog 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6eb6543861d7372fd74ab555d42c786fd2880d7f236a2a606cb8d8a69dda443
-  data.tar.gz: 9c3785dbab77433adad9a7d388bd451864a213ca206cb3e99a919b9ade5773ce
+  metadata.gz: 7e70671fa7a287f7273aa19d34e110411abdaf6eaa53af119c538e6f9f558b83
+  data.tar.gz: 715e723cad15056e1c5e878e21f89895e10a8a970550a6eb84183e9ccfc2c84a
 SHA512:
-  metadata.gz: 83f284129d2ab34f5235510c39b196a181158a5b853dcbe41b31b855f0400df548c41e0d631902e5b398a8f1fcb893856b0509d3bd70d7232ddbbf128cf62090
-  data.tar.gz: 80cf8f0953c7f7badbc7c5ed7791b4211b2f9a5d9047bb7bb7c8a2117b2f6ff133edc409c12b46c948d58e03862a536cf94f5e27adea2b9715d55a649d5d4900
+  metadata.gz: ab6e65d6dffbb0cf8cfa2b1dd228879e3aae55f32f5118a77873c5e69fab28e840dfce9240cf44d88efc30e59a7cb4b8e271d800e987126e6c3514d60a718109
+  data.tar.gz: 38aa55282ff812f1eb8ff1fe22b6dbff1493f0debfe592c6b57f6e21a0cd6a2b7343ad86d45363202cfa3318070f9116a71039bffec371866a60c2cc8d1680f4

data/CHANGELOG.md

@@ -1,11 +1,117 @@
 # Changelog
 
-What changed in each version of the `proctolog` gem, newest first. Versions
-are semantic ([docs/manual/updates.md](docs/manual/updates.md)); a release
-that asks something of you says what under **You do**.
+What changed in each version of the `proctolog` gem, newest first: what it
+adds, what it changes and what it fixes. Versions are semantic
+([docs/manual/updates.md](docs/manual/updates.md)); a release that asks
+something of you says what under **You do**. Unreleased is what main has that
+no gem has yet.
+
+## 0.3.0
+
+### Added
+
+- `proctolog setup` is the one command to remember: it takes you from
+  wherever you are to an open desk, a step at a time. It links PRoctolog's
+  command, completion and skills, then goes through doctor's checks in the
+  order you meet them, each saying why it matters, checked again when you
+  press Enter, and stamped done or left for later. Outside a checkout, it
+  asks for one. Its sharing step says what Tailscale and ngrok each give, and
+  where to get them. Of anyone else's, it installs nothing
+  ([docs/manual/setup.md](docs/manual/setup.md)). A bare `proctolog`, and
+  `serve` outside a checkout, point to it.
+- `proctolog update` says what's new since the version you had, from this
+  changelog: each change by its first sentence, under Added, Changed and
+  Fixed, and in full what you must do. It starts with the update after this
+  one, as the version you leave is the one that runs it.
+
+### Changed
+
+- `proctolog install` is another name for `setup`: it links as before, then
+  takes you through the rest. After an update it only links, and says what's
+  new.
+- `doctor` says how to install Chrome when it is missing.
+
+### Fixed
+
+- `proctolog update` said it pulled a checkout forward, and to restart the
+  desk, when origin had nothing newer. It says the checkout is the latest now,
+  and changes nothing.
+- On macOS 27 the desk took every port on this Mac for answering: Try it
+  showed the app up and never started it, `doctor` said port 4040 was taken,
+  and `proctolog share start` shared a desk that was not there.
+
+## 0.2.0
+
+### Added
+
+- The desk is at <http://proctolog.localhost:4040>, a name of its own that a
+  browser's history finds from `procto`; `localhost:4040` still works.
+- Share the desk with your phone or another computer, through Tailscale (on
+  your tailnet, which the sharing page names, as one account can be in
+  several) or ngrok (behind its sign-in with Google, for your address): from
+  the foot of the pane at the left, with `proctolog share`, or with
+  `proctolog serve --share`. `proctolog share status` and `doctor` say what
+  each one needs. Neither is installed for you.
+- "Start here" heads the page of open pull requests until you have a burst of
+  your own, and whenever there is nothing to decide: how many are written for
+  PRoctolog and how to open one, how to have them rewritten when none is, or
+  how to have some written when nothing is open.
+- **back to you** on a line of the Route, and `↩` on it in the pane, once the
+  agent's answers have come back for you to confirm or answer, or it
+  addressed a note of yours. The `↩` follows as you go, without the page
+  loading again.
+- A panel beside the pictures of a change, in the viewer: the five ways to
+  look at them, each a button with its key, and the changed regions, counted
+  and numbered. `n` and `p`, or a press on a number, focus on a region and
+  keep your zoom; `z` goes near it and `0` back to the whole. The panel shows
+  the region as the before has it and as the after does, and Enter, or a
+  press on either, writes a note on it, in any view.
+- Shift B sets blink going by itself, or stops it.
+- Once the viewer shows only part of a picture, a map in its corner shows the
+  whole, with the part on the stage framed; a press on the map goes there.
+
+### Changed
+
+- Decisions are beads, on the Route and in the pane at the left: a full-size
+  bead for a blocking decision, a small one for a non-blocking, solid once
+  reviewed, hollow while it waits. They take the place of the counts and of
+  `x`, `~` and `-`, and in the pane follow your choices as you make them.
+- `N` opens the next pull request that asks for you: one with a blocking
+  decision left, or something back from the agent.
+- With no burst open, the pane lists your bursts with how many decisions of
+  each grade wait, rather than how far each one is.
+- In the viewer, a view's key again goes back to side by side. Changed regions
+  are outlined dashed and a note's box framed solid, so the two are told apart
+  at a glance.
+- A note on a picture is saved where you are: the page doesn't load again or
+  move, zoomed in or not, and closing the viewer draws the notes there where
+  the page stands, rather than coming back at the last one.
+- `bin/release` refuses a patch that adds something, and says when lines are
+  still left under Unreleased.
+
+### Fixed
+
+- "Review alone" on a pull request in no stack saved nothing, and said the
+  page was older than the desk's last start.
+- "Ask Claude now" on a pull request nobody has opened yet sent the session to
+  GitHub, which has nothing of it. It names the branch, its base and the file
+  its description is kept in now, and has the session read it with git.
+- The note button on selected text sat away from the selection on a burst's
+  pages.
+- A note of yours that an agent answered stayed open in the marks, for the
+  page's Notes and for an agent reading them. It follows its answer now:
+  addressed once the answer is in, confirmed once you confirm it, open again
+  once you answer back, and its card points you to Returned work.
+- `bin/release` and the Release workflow read the changelog whatever the
+  locale: a `⌘` or `↩` in it stopped them where none was set.
+
+**You do**: nothing, unless you want to share the desk: install Tailscale or
+ngrok, as [docs/manual/sharing.md](docs/manual/sharing.md) says.
 
 ## 0.1.1
 
+### Changed
+
 - The Try it rail follows the reading column and its keys rather than the far
   edge of the window, and grows to 20rem on wide screens; its outline scrolls
   on its own, leaving the starter room.
@@ -18,6 +124,8 @@ that asks something of you says what under **You do**.
 
 The first one published as a gem.
 
+### Added
+
 - `rvx proctolog install`, or
   `gem install proctolog` and `proctolog install`, in place of cloning the
   repository. Under rv it runs on a Ruby 4 of its own, whatever Ruby the shell

data/README.md

@@ -12,16 +12,16 @@ it works.
 
 ## The short version
 
-Install it with [rv](https://rv.dev), then run it from a checkout of the repo
-whose PRs you review:
+With [rv](https://rv.dev), from a checkout of the repo whose PRs you review:
 
 ```sh
-rvx proctolog install
 cd path/to/your-repo
-proctolog doctor   # fix what it marks !!
-proctolog serve    # then open http://localhost:4040
+rvx proctolog setup   # a step at a time, to http://proctolog.localhost:4040
 ```
 
+`setup` is the one command to remember: it links PRoctolog's own pieces, says
+what to do about the rest, and opens the desk. `install` is another name for it.
+
 Pick a PR, a stack, or a few ticked ones, and press `?` once you're in. When
 your agent opens PRs, tell it to "write these PRs for PRoctolog", so they come
 with decisions to review. Everything below is the long version.
@@ -41,11 +41,10 @@ brew install diffle imagemagick ffmpeg
 With rv, whatever Ruby your shell or your repo runs:
 
 ```sh
-rvx proctolog install
-proctolog doctor
+rvx proctolog setup
 ```
 
-rv gives PRoctolog a Ruby 4 and gems of its own, and `install` puts a
+rv gives PRoctolog a Ruby 4 and gems of its own, and `setup` puts a
 `proctolog` in `~/.local/bin` that runs it through `rvx`. The apps you review
 keep their own Ruby: what the desk starts for them never sees PRoctolog's.
 rv installs from gem.coop, which mirrors RubyGems.
@@ -54,20 +53,24 @@ With Ruby 4.0 already in your shell:
 
 ```sh
 gem install proctolog
-proctolog install
-proctolog doctor
+proctolog setup
 ```
 
-Either way `install` also links the zsh completion into `~/.zsh/completions`
-and the agent skills (below) into `~/.claude/skills` and `~/.agents/skills`. `doctor`
-says what's missing, a line each, with the fix: `!!` for what the desk can't do
+Either way `setup` first links the zsh completion into `~/.zsh/completions`
+and the agent skills (below) into `~/.claude/skills` and `~/.agents/skills`.
+Then it takes the rest a step at a time: gh, the checkout, a first burst, what
+turns features on, sharing the desk with your phone. Each step says why it
+matters, checks again once you've acted, and is stamped done or left for
+later; the last one opens the desk ([setting up](docs/manual/setup.md)). Run it
+again whenever: what's done is stamped and passed. `doctor` asks the same
+things all at once, a line each with the fix: `!!` for what the desk can't do
 without, `--` for what only turns a feature off.
 
 When a newer PRoctolog is out, the desk says so, and `proctolog update` takes
 it ([versions and updates](docs/manual/updates.md)).
 
 Working on PRoctolog itself? Run it from a checkout instead: clone it, then
-`bundle install && ruby bin/install`, which also puts a `proctolog` that runs
+`bundle install && bin/proctolog setup`, which also puts a `proctolog` that runs
 the checkout in `~/.local/bin`. Keep the checkout where it is, since
 everything links back to it. The desk tells a checkout of a newer release
 too, and `proctolog update` pulls it forward.
@@ -79,7 +82,7 @@ cd path/to/your-repo
 proctolog serve
 ```
 
-Open <http://localhost:4040>. It lists the repo's open PRs: GitHub's stacks
+Open <http://proctolog.localhost:4040>. It lists the repo's open PRs: GitHub's stacks
 whole, then the rest, yours first. Press "Review alone" on one, "Review the
 stack" on a stack, or tick a few and review them together. That's all the setup
 there is.
@@ -104,7 +107,7 @@ Your review is saved as you go, on your Mac under `~/.local/share/proctolog/`.
 
 PRoctolog finds decisions under a `## Decisions for the owner` heading, one
 checkbox line each. The `proctolog-pr-writing` skill teaches your agent the
-format, and `proctolog install` already put it where the agent looks. Tell it to
+format, and `proctolog setup` already put it where the agent looks. Tell it to
 "write these PRs for PRoctolog", or "rewrite this PR's description for
 PRoctolog" for one that's open. Check a description before publishing it:
 
@@ -147,7 +150,7 @@ bundle config set --local with grouse && bundle install
 
 Then every page of the desk carries Grouse's overlay, at the bottom right: say or type what's wrong with the page you're
 on, and the note keeps the page, the templates that drew it, what you pointed
-at and, if you ask, a screenshot. Read them at <http://localhost:4040/grouse>.
+at and, if you ask, a screenshot. Read them at <http://proctolog.localhost:4040/grouse>.
 An agent working on the desk reads them through Grouse's export API;
 [AGENTS.md](AGENTS.md) tells it how. They're kept under
 `~/.local/share/proctolog/grouse_notes`, one store for every repo you review.
@@ -156,15 +159,26 @@ A voice note is written out by ElevenLabs, and every note written up as an
 issue by Anthropic, with keys the desk reads from 1Password when it serves:
 `config/keys.yml` holds the references, never the keys, and `op` (1Password's
 CLI, signed in) reads them. Point them at your own items there if yours live
-elsewhere.
+elsewhere. A trial desk, on marks of its own (`PROCTOLOG_MARKS`), reads none,
+so an agent trying a change never has 1Password ask you to unlock it.
 
 Without a key a voice note arrives "audio only", with a recording that plays,
 and a note's page says "No structurer set up". `bin/rails grouse:doctor`, in the
 desk's checkout, says what Grouse is missing.
 
+## From your phone
+
+`proctolog share` puts the desk where your other devices reach it and nobody
+else does: through Tailscale, at your Mac's name on your tailnet, or through
+ngrok, behind its sign-in with Google for your own address. The pane at the
+left says whether it's shared, and opens the page that shares it. Neither is
+installed for you; `proctolog share status` says what each one needs. More in
+[the address, and sharing it](docs/manual/sharing.md).
+
 ## More
 
 - [Bursts, the route and where things live](docs/manual/bursts.md)
+- [The address, and sharing it](docs/manual/sharing.md)
 - [How the desk runs your app](docs/manual/app.md)
 - [Reading a PR by keyboard](docs/manual/reading.md)
 - [Deciding](docs/manual/deciding.md)

data/app/controllers/proctolog/application_controller.rb

@@ -2,9 +2,9 @@
 
 module Proctolog
   class ApplicationController < ActionController::Base
-    rescue_from(Github::Unreachable) { render plain: "GitHub did not answer.\n\n#{it.message}", status: :service_unavailable }
+    rescue_from(Github::Unreachable) { render plain: "GitHub did not answer.\n\n#{it.message}\n\nIf gh is not set up on this Mac yet, proctolog setup takes you through it.", status: :service_unavailable }
     rescue_from(ActionController::InvalidAuthenticityToken) do
-      redirect_back_or_to root_path, alert: "This page was older than the desk's last start, so nothing was saved. Do it once more."
+      redirect_back_or_to root_path, alert: "The desk did not know this page any more, so nothing was saved. Do it once more."
     end
     rescue_from(Burst::Missing) { render plain: it.message, status: :not_found }
     # A button's press comes back to the page it was pressed on, with the

data/app/controllers/proctolog/bursts_controller.rb

@@ -12,7 +12,7 @@ module Proctolog
       @route = @burst.route(fresh: params.key?(:fresh))
       return redirect_to(burst_path(@burst)) if params.key?(:fresh)
 
-      @taken_in = @burst.reports.take_in
+      @taken_in = @burst.take_in
       @standings = @burst.standings(@route)
       @notices = @burst.notices
       @rules = @burst.rules.select { it.within?(focus) }

data/app/controllers/proctolog/choices_controller.rb

@@ -12,11 +12,13 @@ module Proctolog
     def show = render(json: {document: choices.document})
 
     # A desk from before bursts had their name reads `review`, so both are
-    # written: one rolled back can still read what this one saved.
+    # written: one rolled back can still read what this one saved. What the
+    # owner said of an agent's answers moves the notes they answer at once.
     def update
       incoming = JSON.parse(request.raw_post)
       mine?(incoming) or raise KeyError
       choices.keep(incoming.merge("burst" => @burst.slug, "review" => @burst.slug))
+      @burst.take_in
       render json: {revision: choices.revision}
     end
 

data/app/controllers/proctolog/decisions_controller.rb

@@ -13,7 +13,7 @@ module Proctolog
         return redirect_to(burst_decisions_path(@burst, show: params[:show]))
       end
 
-      @burst.reports.take_in
+      @burst.take_in
       # Listed and counted within the focus; the stars and ticks it sends are
       # found among the whole burst's.
       @decisions = @burst.decisions(pages:, focus:)

data/app/controllers/proctolog/notes_controller.rb

@@ -10,8 +10,8 @@ module Proctolog
 
     before_action { @burst = Burst.find(params.expect(:burst_id)) }
 
-    # A note written in the picture viewer is saved without leaving it: the
-    # answer says where the page shows it, for once the viewer closes.
+    # A note on a picture, on the page or in the viewer, is saved without
+    # leaving either: the answer names the note and where the page shows it.
     def create
       note = marks.pin(kind: one_of(Note::KINDS, params.expect(:kind)), text: params.expect(:text).strip, place:)
       respond_to do |format|

data/app/controllers/proctolog/prompts_controller.rb

@@ -8,7 +8,7 @@ module Proctolog
     before_action { @burst = Burst.find(params.expect(:burst_id)) }
 
     def show
-      @taken_in = @burst.reports.take_in
+      @taken_in = @burst.take_in
       @handover = @burst.handover(@burst.route, focus:)
     end
 

data/app/controllers/proctolog/pull_requests_controller.rb

@@ -11,13 +11,11 @@ module Proctolog
       @route = @burst.route(fresh: params.key?(:fresh))
       return redirect_to(burst_pull_request_path(@burst, params.expect(:number))) if params.key?(:fresh)
 
-      @burst.reports.take_in
+      @burst.take_in
       @stop = @route.at(PullRequest.number(params.expect(:number))) or return render(plain: "##{params[:number]} is not part of #{@burst.name}.", status: :not_found)
       standings = @burst.standings(@route)
       @standing = standings.fetch(@stop)
-      # Next to review is the next with blocking decisions left: the non-blocking
-      # wait for one gesture, and do not hold up deciding.
-      @next_to_review = focus.round_from(@stop).find { standings.fetch(it).progress.blocking_left.positive? }
+      @next_to_review = focus.round_from(@stop).find { standings.fetch(it).asks_for_owner? }
       @since = @burst.since(@stop) if @standing.changed?
       @scenarios = @burst.scenarios.select { it.pr == @stop.number }
       @rendering = Rendering.new(@burst.rendering(@stop.number), notes: @standing.marks.notes, pages: pages, linked: @stop.description.linked)

data/app/controllers/proctolog/review_data_controller.rb

@@ -2,10 +2,12 @@
 
 module Proctolog
   # What the pages' script needs of the burst's review rounds, built from the
-  # whole burst; with `pr`, that pull request's descriptions too.
+  # whole burst; with `pr`, that pull request's descriptions too. Answers an
+  # agent wrote since are taken in first, as a page's load takes them in.
   class ReviewDataController < ApplicationController
     def show
       @burst = Burst.find(params.expect(:burst_id))
+      @burst.take_in
       render json: helpers.round_data(@burst, pr: params[:pr]&.then { PullRequest.number(it) })
     end
   end

data/app/controllers/proctolog/shares_controller.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Proctolog
+  # The page that shares the desk with the owner's other devices, through
+  # whichever of Tailscale and ngrok this Mac has, and stops it (Share). A
+  # press comes back to it, with the sentence; `back` is the page it was
+  # opened from.
+  class SharesController < ApplicationController
+    before_action { @back = params[:back].to_s.then { (it.start_with?("/") && !it.start_with?("//")) ? it : root_path } }
+    rescue_from(Share::Refused) { redirect_to share_path(back: @back), alert: it.message }
+
+    def show
+      @share = Share.at(Desk.port)
+      @ways = Share.ways
+    end
+
+    def create
+      share = Share.open(Desk.port, via: params[:via].presence, allow: params[:allow]&.split(/[\s,]+/))
+      redirect_to share_path(back: @back), notice: share.to_s
+    end
+
+    def destroy
+      Share.at(Desk.port)&.close
+      redirect_to share_path(back: @back), notice: "The desk is only on this Mac again."
+    end
+  end
+end

data/app/helpers/proctolog/decisions_helper.rb

@@ -9,7 +9,11 @@ module Proctolog
     # focus is never taken for one whose decision is gone.
     # What the inventory holds changed with the desk: a page built from an
     # older one would read its decisions wrong.
-    INVENTORY = 3
+    INVENTORY = 4
+
+    # Where the description of a pull request nobody has opened yet is kept,
+    # which an agent reads in place of GitHub's.
+    def unopened_file(stop) = (Unopened.find(stop.number)&.file&.to_s if stop.pull_request.unopened?)
 
     # The pictures' files and pixel signatures are looked up at each page,
     # not kept with the rest: a picture fetched since the reading is known.
@@ -20,7 +24,7 @@ module Proctolog
 
     def draft_decision(box)
       {id: box.to_param, pr: box.stop.number, title: box.stop.title, url: box.stop.url, branch: box.stop.pull_request.head,
-       head: box.stop.head_oid, description: box.stop.description.digest, position: box.position, lead: box.lead,
+       base: box.stop.pull_request.base, file: unopened_file(box.stop), head: box.stop.head_oid, description: box.stop.description.digest, position: box.position, lead: box.lead,
        text: box.decision.text, key: box.decision.key, ticked: box.decision.ticked, protected: @burst.refusal(box.stop.number).present?,
        grade: box.decision.grade, theme: box.decision.theme_name, pictures: box.decision.pictures.map(&:to_h)}
     end

data/app/helpers/proctolog/desk_helper.rb

@@ -13,17 +13,48 @@ module Proctolog
       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 "~"
+    # A pull request's decisions as beads, the way deciding draws them: a
+    # bead to each blocking decision and a smaller one to each non-blocking,
+    # solid once reviewed and hollow while it waits. Each grade is labelled
+    # in words, which the pane's card shows. The page's script draws the same
+    # as choices are made (beadsOf in review-drafts.js).
+    def decision_beads(progress)
+      return unless progress.any?
+
+      tag.span(class: "beads") do
+        safe_join(progress.grades.select { it.total.positive? }.map do |grade|
+          tag.span(class: grade.name, role: "img", aria: {label: reviewed_in_words(grade)}) do
+            safe_join(Array.new(grade.total) { tag.span(class: ["bead", ("reviewed" if it < grade.reviewed)]) })
+          end
+        end)
+      end
+    end
+
+    # A whole burst has too many decisions for a bead each: a hollow bead of
+    # each grade that waits, and how many of it.
+    def decisions_left(progress)
+      waiting = progress.grades.select { it.left.positive? }
+      return if waiting.empty?
+
+      tag.span(class: "beads") do
+        safe_join(waiting.map do |grade|
+          tag.span(class: [grade.name, "count"], role: "img", aria: {label: "#{pluralize(grade.left, "#{grade.name} decision")} to review"}) do
+            tag.span(class: "bead") + grade.left.to_s
+          end
+        end)
       end
     end
 
-    def side_fraction(progress) = ("#{progress.reviewed}/#{progress.total}" if progress.any?)
+    # The pane's mark for a pull request the agent's answers came back on,
+    # labelled with what came back (Standing#for_the_owner). The page's
+    # script marks the pane again from the same words as answers are judged.
+    def side_mark(came_back)
+      return tag.span(class: "mark", data: {side_mark: ""}) if came_back.empty?
+
+      tag.span("↩", class: "mark", data: {side_mark: ""}, role: "img", aria: {label: back_in_words(came_back)})
+    end
+
+    def back_in_words(came_back) = "back to you: #{came_back.to_sentence}"
 
     # 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
@@ -57,5 +88,14 @@ module Proctolog
     private
 
     def keycaps(pressed) = safe_join(pressed.split.map { tag.kbd(it) })
+
+    # "1 of 4 blocking decisions reviewed".
+    def reviewed_in_words(grade)
+      decisions = "#{grade.name} decision".pluralize(grade.total)
+      if grade.left.zero? then (grade.total == 1) ? "its one #{decisions} reviewed" : "all #{grade.total} #{decisions} reviewed"
+      elsif grade.reviewed.zero? then "none of #{grade.total} #{decisions} reviewed yet"
+      else "#{grade.reviewed} of #{grade.total} #{decisions} reviewed"
+      end
+    end
   end
 end

data/app/helpers/proctolog/rounds_helper.rb

@@ -7,13 +7,15 @@ module Proctolog
     # 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.
+    # say what changed since. `back` names the pull requests something came
+    # back on, in the words of the pane's mark.
     def round_data(burst, pr: nil)
       route = burst.route
       rounds = Rounds.new(burst, route:)
       responses = ResponseFiles.new(burst)
+      back = burst.standings(route).filter_map { |stop, standing| [stop.number, back_in_words(standing.for_the_owner)] if standing.back_to_owner? }.to_h
       {requests: rounds.requests, batches: Handover.kept(burst).map(&:batch), reports: responses.all, errors: responses.errors,
-       responseFolder: responses.folder.to_s, heads: rounds.heads,
+       responseFolder: responses.folder.to_s, heads: rounds.heads, back:,
        **(route.at(pr)&.then { |stop| {descriptions: descriptions_of(burst, stop)} } || {})}
     end
 

data/app/helpers/proctolog/shares_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Proctolog
+  module SharesHelper
+    # A way's sentence, with the addresses in it to follow: where to download
+    # it, or where to turn something on.
+    def linked_sentence(sentence)
+      safe_join(sentence.split(%r{(https?://[^\s,]*[^\s,.])}).map { it.start_with?("http") ? link_to(it, it, target: "_blank", rel: "noopener") : it })
+    end
+  end
+end

data/app/helpers/proctolog/standings_helper.rb

@@ -34,11 +34,12 @@ module Proctolog
       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.
+    # What a line of the route says at its right: whose the pull request is,
+    # "back to you" when the owner's turn is what came back from the agent,
+    # then its decisions as beads.
     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, " · ")
+      whose = {owner: (tag.strong("back to you") if standing.back_to_owner?), agent: "with the agent", settled: "settled", waiting: "waiting"}.fetch(standing.turn)
+      safe_join([whose, decision_beads(standing.progress)].compact, " ")
     end
 
     def verdict_of(condition) = VERDICTS.fetch(condition.met)

data/app/models/proctolog/burst.rb

@@ -124,14 +124,9 @@ module Proctolog
     def decisions(pages: {}, focus: route) = Decisions.new(route: focus, marks: method(:marks), renderings: method(:rendering), named: @waiting, pages:)
 
     # Where every stop of the route stands, in its order: each layer knows the
-    # standing of the one it sits on.
-    def standings(route)
-      progress, scenarios = progress(route), scenarios_on(route)
-      route.each_with_object({}) do |stop, standings|
-        standings[stop] = Standing.new(stop:, marks: marks(stop.number), progress: progress.fetch(stop.number), under: route.under(stop)&.then { standings[it] },
-          above: route.above(stop), scenarios: scenarios.select { it.pr == stop.number }.map(&:name), named: @before_it_goes.fetch(stop.number, []))
-      end
-    end
+    # standing of the one it sits on. Worked out once for a reading of a
+    # page, which asks for it from the page and from its pane.
+    def standings(route) = (@standings ||= {}.compare_by_identity)[route] ||= standings_on(route)
 
     # What moved in a pull request since the owner's "good to go", to show
     # when its standing says something did.
@@ -143,6 +138,11 @@ module Proctolog
 
     def reports = Reports.new(self)
 
+    # What came back from agents, taken into the marks: a report moves the
+    # note it names, and a handover's answers move theirs as the owner judges
+    # them (Rounds#move_notes). Answers the notes the reports moved.
+    def take_in = reports.take_in.tap { Rounds.new(self, route:).move_notes }
+
     # A description's picture as a file on this Mac, once the desk has shown it.
     def picture_file(asset) = (Project.current.pictures.glob("#{asset}.*").first if Picture.asset?(asset.to_s))
 
@@ -246,6 +246,15 @@ module Proctolog
 
     private
 
+    def standings_on(route)
+      progress, scenarios, returned = progress(route), scenarios_on(route), Rounds.new(self, route:).returned
+      route.each_with_object({}) do |stop, standings|
+        standings[stop] = Standing.new(stop:, marks: marks(stop.number), progress: progress.fetch(stop.number),
+          returned: returned.fetch(stop.number, Rounds::Returned.new), under: route.under(stop)&.then { standings[it] },
+          above: route.above(stop), scenarios: scenarios.select { it.pr == stop.number }.map(&:name), named: @before_it_goes.fetch(stop.number, []))
+      end
+    end
+
     # The pictures its descriptions show, each by its id and its kind, as GitHub's HTML addresses them.
     def pictures_of(route) = route.flat_map { Rendering.pictures(rendering(it.number)) }
 

data/app/models/proctolog/choices.rb

@@ -9,6 +9,12 @@ module Proctolog
     # A writing older than the one kept: another page moved on since.
     Stale = Class.new(StandardError)
 
+    # One grade's share of a pull request's decisions: "blocking" or
+    # "non-blocking", how many it has, and how many of them wait.
+    Grade = Data.define(:name, :total, :left) do
+      def reviewed = total - left
+    end
+
     # How far one pull request's decisions are: a decision is reviewed once
     # the owner chose on its present words, or it is ticked on GitHub. Its
     # blocking decisions are counted apart: those left of them are what
@@ -31,6 +37,8 @@ module Proctolog
       def non_blocking = total - blocking
       def non_blocking_left = left - blocking_left
 
+      def grades = [Grade.new(name: "blocking", total: blocking, left: blocking_left), Grade.new(name: "non-blocking", total: non_blocking, left: non_blocking_left)]
+
       def +(other) = with(**members.to_h { [it, public_send(it) + other.public_send(it)] })
     end