proctolog 0.1.0

data/app/models/proctolog/theme.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Proctolog
+  # The kind of question a decision asks, so that one kind can be answered
+  # across a burst at once. A project lists its themes, each with what it
+  # means, under `themes` in .proctolog/project.yml; without that, the desk's
+  # own list stands. A decision names its theme in a hidden marker,
+  # `<!-- proctolog:theme copy -->`, which is no part of its words: a name
+  # the list does not hold is "other", and a decision with no marker has none.
+  class Theme < Data.define(:name, :meaning)
+    MARKER = /<!-- proctolog:theme ([\w-]+) -->/
+
+    DEFAULTS = {
+      "copy" => "What the words on a screen say, and how",
+      "fit" => "How a screen holds what is on it: wrapping, folds, sizes",
+      "errors" => "What happens when something fails, and what the member is told",
+      "accounts" => "Who a member is: signing up, signing in, their account",
+      "data" => "What is kept, moved or deleted, and who may see it",
+      "plan" => "What was built against what was planned",
+      "build" => "How the code is made: its parts, its dependencies, its tools",
+      "limits" => "Bounds: sizes, counts, rates and time"
+    }.freeze
+
+    OTHER = new(name: "other", meaning: "A theme the project does not list")
+
+    # The project's themes, in its own order.
+    def self.all = (Project.current.setting(:themes).presence || DEFAULTS).map { |name, meaning| new(name: name.to_s, meaning: meaning.to_s) }
+
+    # The theme a marker's name stands for among `themes`: "other" for one
+    # they do not hold, and none for no name.
+    def self.named(name, themes = all) = name && (themes.find { it.name == name } || OTHER)
+
+    # Words with their theme markers taken out.
+    def self.unmarked(text) = text.to_s.gsub(/\s*#{MARKER}/o, "")
+
+    def other? = self == OTHER
+
+    def to_s = name
+  end
+end

data/app/models/proctolog/unopened/numbers.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Proctolog
+  class Unopened
+    # The numbers the desk gave the pull requests nobody has opened yet, in
+    # one YAML file of the store: a branch keeps its number across bursts and
+    # restarts, and once it is opened says which pull request it became.
+    #
+    #   "01": {branch: recovery/fields}
+    #   "02": {branch: recovery/emails, opened_as: 1140}
+    class Numbers
+      # Two pages may meet a new branch at once; only one numbers it.
+      WRITING = Mutex.new
+
+      def initialize(path) = @path = path
+
+      def read = (@path.exist? && YAML.safe_load_file(@path)) || {}
+
+      # The branch's number, a new one when it has none; nil once it is opened.
+      def of(branch)
+        WRITING.synchronize do
+          kept = read
+          number, entry = kept.find { |_, said| said["branch"] == branch }
+          return (number unless entry["opened_as"]) if entry
+
+          "0#{kept.keys.map(&:to_i).max.to_i + 1}".tap { write(kept.merge(it => {"branch" => branch})) }
+        end
+      end
+
+      def branch(number) = read.dig(number, "branch")
+
+      # The pull request it was opened as, once it was.
+      def opened_as(number) = read.dig(number, "opened_as")
+
+      def opened(number, as:) = WRITING.synchronize { write(read.tap { it.fetch(number)["opened_as"] = as }) }
+
+      private
+
+      # Written beside the file and moved over it, so a reader never meets half a file.
+      def write(numbers)
+        @path.dirname.mkpath
+        draft = @path.sub_ext(".yml.part")
+        draft.write(numbers.to_yaml(line_width: -1))
+        draft.rename(@path)
+      end
+    end
+  end
+end

data/app/models/proctolog/unopened/opening.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Proctolog
+  class Unopened
+    # A pull request that waited unopened and is open on GitHub now. What
+    # the owner kept of it under its number with a leading zero moves, in
+    # every burst and once, to the number GitHub gave it: its marks and
+    # notes, choices and drafts, what handovers asked and agents answered,
+    # its code comments and its films. Its route says so until the owner has
+    # seen it. GitHub is the truth about it from then on.
+    #
+    # A trial desk carries its own marks over, every time it meets the
+    # branch open, and never says in the register that it was opened: the
+    # owner's desk would then never carry the owner's marks.
+    class Opening
+      # Two pages may meet the opened branch at once; only one carries it.
+      CARRYING = Mutex.new
+
+      # The keys under which a pull request is named by its number alone.
+      NUMBERED = %w[pr pull_requests handed_over].freeze
+
+      def initialize(waiting, as:)
+        @from, @to = waiting.number, as
+        # An id that begins with the number: a note's 01-2, a choice's
+        # choice:01-0:…, a film's 01/sign-in.
+        @begun = /(\A|:)#{Regexp.escape(@from)}(?=-\d|\/)/
+      end
+
+      def carry_over
+        CARRYING.synchronize do
+          next if Unopened.numbers.opened_as(@from)
+
+          Marks.root.then { it.directory? ? it.children.select(&:directory?) : [] }.each { carry(it) }
+          Recording.directory.then { it.directory? ? it.children.select(&:directory?) : [] }.each { move(it.join(@from), it.join(@to.to_s)) }
+          Unopened.numbers.opened(@from, as: @to) unless Marks.trial?
+        end
+      end
+
+      private
+
+      # A burst that held anything of it says so on its route.
+      def carry(burst)
+        carried = [move(burst.join("#{@from}.yml"), burst.join("#{@to}.yml")), move(burst.join("code", @from), burst.join("code", @to.to_s)),
+          *burst.glob("**/*.{json,yml}").map { rewrite(it) }]
+        Membership.new(burst.join("membership.yml")).then { it.note_opened(@to, was: @from) if carried.any? && it.pull_requests.include?(@to) }
+      end
+
+      # What was kept under the new number already stays, and the old waits
+      # beside it. True when it moved.
+      def move(from, to) = (from.rename(to).zero? if from.exist? && !to.exist?)
+
+      # Rewritten only when it named the old number, beside the file and
+      # moved over it; true then. A file the desk cannot read is left for
+      # the owner.
+      def rewrite(file)
+        json = file.extname == ".json"
+        before = json ? JSON.parse(file.read) : YAML.safe_load_file(file)
+        after = renumbered(before)
+        return false if after == before
+
+        draft = file.sub_ext("#{file.extname}.part")
+        draft.write(json ? JSON.pretty_generate(after) : after.to_yaml(line_width: -1))
+        draft.rename(file).zero?
+      rescue JSON::ParserError, Psych::Exception
+        false
+      end
+
+      def renumbered(value, under = nil)
+        case value
+        when Hash then value.to_h { |key, inner| [renamed(key), renumbered(inner, key)] }
+        when Array then value.map { renumbered(it, under) }
+        when @from then NUMBERED.include?(under) ? @to : value
+        when String then begun_anew(value)
+        else value
+        end
+      end
+
+      # A key by the pull request, as a batch keeps its heads, or by one of its films.
+      def renamed(key)
+        return @to.to_s if key == @from
+
+        key.is_a?(String) ? begun_anew(key) : key
+      end
+
+      def begun_anew(text) = text.sub(@begun) { "#{$1}#{@to}" }
+    end
+  end
+end

data/app/models/proctolog/unopened.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Proctolog
+  # A pull request nobody has opened yet: a branch on this Mac, and a folder
+  # of the owner's store named after it, which holds what its agent wrote as
+  # `gh pr create` would be told it. A title and a base as front matter,
+  # then the description, with its pictures beside it:
+  #
+  #   ~/.local/share/proctolog/<owner>/<repo>/unopened/recovery/emails/
+  #     pull_request.md
+  #     reset-mail-after.png
+  #
+  # The desk reviews it as it reviews an open one, under a number GitHub
+  # never gives, 01, which the branch keeps (Numbers). Once the branch is
+  # opened, the pull request is GitHub's and the folder is left alone.
+  #
+  # The class answers for these numbers what Github answers for its own: a
+  # rendering, the description as it stands, a rewrite and its history.
+  class Unopened
+    FILE = "pull_request.md"
+
+    # What `gh pr create` would be told, above the description.
+    FRONT_MATTER = /\A---\n(?<settings>.*?)^---[ \t]*\n/m
+
+    # A branch of this Mac, or of origin as this Mac last fetched it: where
+    # it is now, and when it was last committed to.
+    Branch = Data.define(:head, :committed_at)
+
+    class << self
+      # Every one whose branch is on this Mac, in the order of their numbers;
+      # read again only when a branch moves or a folder changes.
+      def all
+        state = [folder.glob("**/#{FILE}").map { [it, it.mtime] }, branches, numbers.read]
+        return @all if @read == state
+
+        @read = state
+        @all = state.first.filter_map { |file, _| from(file) }.sort_by { it.number.to_i }
+      end
+
+      # Those still waiting, now that `open` are open on GitHub. One whose
+      # branch has an open pull request is that pull request from now on: its
+      # review is carried over to it first.
+      def waiting(open:)
+        all.reject do |waiting|
+          opened = open.find { it.head == waiting.branch } or next false
+          Opening.new(waiting, as: opened.number).carry_over
+          true
+        end
+      end
+
+      def find(number) = all.find { it.number == number.to_s }
+
+      def on(branch) = all.find { it.branch == branch }
+
+      def folder = Project.current.unopened
+
+      # The folder a branch's pull request is written in, whether it holds
+      # one yet or not.
+      def folder_of(branch) = folder.join(branch)
+
+      def numbers = Numbers.new(folder.join("numbers.yml"))
+
+      # As Github answers them, for one of these numbers.
+      def rendering(number) = find(number)&.rendering
+
+      def description_now(number) = held(number).description.to_s
+
+      def description_revisions(number) = find(number)&.revisions || []
+
+      def rewrite(number, text) = held(number).rewrite(text)
+
+      # The desk writes the file itself: this only shows where.
+      def rewriting(number, file) = ["cp", file, held(number).file.to_s]
+
+      # Every branch of this Mac and of origin, asked of git at once.
+      def branches
+        output, status = Open3.capture2e("git", "-C", Project.current.root.to_s, "for-each-ref", "--format=%(refname)%09%(objectname)%09%(committerdate:iso-strict)", "refs/heads/", "refs/remotes/origin/")
+        return {} unless status.success?
+
+        output.lines(chomp: true).to_h do |line|
+          name, head, at = line.split("\t")
+          [name.delete_prefix("refs/heads/").sub(%r{\Arefs/remotes/}, ""), Branch.new(head:, committed_at: Time.iso8601(at))]
+        end
+      end
+
+      private
+
+      def held(number) = find(number) || raise(Failure, "No pull request waits unopened as #{number}.")
+
+      # One whose branch is gone, or which was opened already, is not read.
+      def from(file)
+        branch = file.dirname.relative_path_from(folder).to_s
+        here = branches[branch] or return
+        number = numbers.of(branch) or return
+        new(branch:, number:, file:, at: here)
+      end
+    end
+
+    attr_reader :branch, :number, :file
+
+    def initialize(branch:, number:, file:, at:)
+      @branch, @number, @file, @at = branch, number, file, at
+      # Its words and the time of their edit, read together.
+      @text, @described_at = file.read.gsub("\r\n", "\n"), file.mtime.floor
+      @settings = @text[FRONT_MATTER, :settings]&.then { YAML.safe_load(it) } || {}
+      @settings.is_a?(Hash) or raise Failure, "#{Project.current.from_root(file)} opens with front matter that is not a title and a base."
+    rescue Psych::Exception => e
+      raise Failure, "#{Project.current.from_root(file)} opens with front matter that is not valid YAML (#{e.message.lines.first&.strip})."
+    end
+
+    def folder = file.dirname
+
+    def title = @settings["title"].presence || branch
+
+    def base = @settings["base"].presence || Project.current.default_branch
+
+    def description = Description.new(@text.sub(FRONT_MATTER, ""))
+
+    # Edited to the second, as a mark keeps the time.
+    attr_reader :described_at
+
+    def pull_request
+      @pull_request ||= PullRequest.new(number:, title:, url: nil, author: nil, base:, head: branch, head_oid: @at.head, description:, described_at:,
+        committed_at: @at.committed_at, files:, threads: [], stack_entry: nil)
+    end
+
+    # The files its branch changes since it left its base, as GitHub would
+    # list them; none while the base is on neither this Mac nor origin.
+    def files
+      under = base_head or return []
+
+      Rails.cache.fetch([:unopened_files, under, @at.head]) do
+        output, status = Open3.capture2e("git", "-C", Project.current.root.to_s, "diff", "--name-only", "--no-renames", "#{under}...#{@at.head}")
+        status.success? ? output.lines(chomp: true) : []
+      end
+    end
+
+    # Where its base is now: on this Mac, or else on origin as last fetched.
+    def base_head = self.class.branches.then { it[base] || it["origin/#{base}"] }&.head
+
+    # Its base and head, as GitHub names a pull request's for its code.
+    def heads
+      base_head or raise Failure, "#{base}, the base of #{branch}, is neither a branch of this Mac nor of origin."
+      {"baseRefOid" => base_head, "headRefOid" => @at.head}
+    end
+
+    # GitHub's HTML of the description, which GitHub keeps nothing of, with
+    # each picture beside it served from this Mac.
+    def rendering
+      repository = Project.current.github_repository or raise Failure, "#{Project.current.root} has no GitHub repository to render descriptions with."
+      fragment = Nokogiri::HTML5.fragment(Github.new(repository).rendered(description.to_s))
+      fragment.css("img").each do |img|
+        picture = picture(img["src"]) or next
+        address = "/pictures/#{picture.asset}.#{picture.extension}"
+        img["src"] = address
+        img.parent["href"] = address if img.parent.name == "a"
+      end
+      keep_revision
+      fragment.to_html
+    end
+
+    # Its text with new words, its front matter as it was. Written beside
+    # the file and moved over it, so a reader never meets half of one.
+    def rewrite(text)
+      draft = file.sub_ext(".md.part")
+      draft.write("#{@text[FRONT_MATTER]}#{text}")
+      draft.rename(file)
+    end
+
+    # Each text the desk read, newest first, as GitHub keeps a description's
+    # edits: what "since good to go" compares with.
+    def revisions
+      keep_revision
+      revisions_folder.glob("*.md").map { Github::Revision.new(at: Time.strptime(it.basename(".md").to_s, REVISION), text: it.read) }.sort_by(&:at).reverse
+    end
+
+    private
+
+    # A revision's file is named for the moment of its edit, in UTC.
+    REVISION = "%Y%m%dT%H%M%S%z"
+
+    def revisions_folder = folder.join(".revisions")
+
+    def keep_revision
+      revision = revisions_folder.join("#{described_at.utc.strftime(REVISION)}.md")
+      return if revision.exist?
+
+      revisions_folder.mkpath
+      revision.write(description.to_s)
+    end
+
+    # A picture beside the description, named by its file; nothing outside
+    # its folder, and nothing on the web.
+    def picture(source)
+      return if source.blank? || source.match?(%r{\A([a-z][a-z0-9+.-]*:|/)}i)
+
+      path = folder.join(CGI.unescape(source)).expand_path
+      Picture.import(path) if path.to_s.start_with?("#{folder.expand_path}/") && path.file?
+    end
+  end
+end

data/app/models/proctolog/visit.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Proctolog
+  # Where pressing a scenario's button sends the browser, and the cookies it is
+  # given on the way. Cookies on localhost are shared by every port, so a
+  # response from the desk can set the app's own. `overlay` is what became of
+  # Grouse's overlay on the way (Overlay::Opened or Refused), when the app has one.
+  class Visit < Data.define(:to, :cookies, :overlay)
+    GOOD_FOR = 2.minutes
+
+    def initialize(to:, cookies:, overlay: nil) = super
+
+    # One of the app's cookies (name=value), kept for as long as a browser's profile.
+    def self.cookie(pair) = "#{pair}; Path=/; HttpOnly; SameSite=Lax; Max-Age=#{12.months.to_i}"
+
+    # The visit that an address from #keep stands for, once; nil after that.
+    def self.take(token)
+      key = [:visit, token]
+      Rails.cache.read(key)&.then { new(**it) if Rails.cache.delete(key) }
+    end
+
+    # An address of the desk that is good once, so where it goes and what it
+    # sets stay out of the browser's history.
+    def keep = SecureRandom.urlsafe_base64(16).tap { Rails.cache.write([:visit, it], {to:, cookies:}, expires_in: GOOD_FOR) }
+  end
+end

data/app/views/layouts/proctolog/application.html.erb

@@ -0,0 +1,58 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title><%= content_for(:title) || "PRoctolog" %></title>
+    <%= csrf_meta_tags %>
+    <link rel="icon" type="image/png" href="/favicon.png">
+    <link rel="stylesheet" href="/desk.css">
+    <script src="/desk.js" defer></script>
+    <script type="module" src="/keys.js"></script>
+    <%# Before the page's own scripts: a # in any box answers its keys first. %>
+    <script type="module" src="/mentions.js"></script>
+    <% if @burst %>
+      <script type="module" src="/side.js"></script>
+    <% end %>
+    <%= yield :head %>
+    <% if (newer = Proctolog::Release.newer) %>
+      <%= tag.meta name: "proctolog-newer", content: newer, data: {news: newer.news} %>
+      <script type="module" src="/release.js"></script>
+    <% end %>
+    <%# Last, so that every page wears the same look: its panes, its type and its colours. %>
+    <link rel="stylesheet" href="/terminal.css">
+  </head>
+  <%= tag.body class: ("shell" if @burst || content_for?(:side)), data: {page: controller_name} do %>
+    <% if @burst %>
+      <%= render "proctolog/bursts/side", burst: @burst, at: @stop&.number %>
+    <% else %>
+      <%= yield :side %>
+    <% end %>
+    <div class="main">
+      <% flash.each do |kind, sentence| %>
+        <p class="flash <%= kind %>" role="status"><%= sentence %></p>
+      <% end %>
+      <%= yield %>
+    </div>
+    <% if content_for?(:keys) %>
+      <%# The keys of this page. The bar says the few that matter where the owner is; ? docks the list of them all above it, where it stays while the owner works, the keys of the block they are on first. %>
+      <footer class="foot" data-desk>
+        <section class="keys-help" id="keys-help" aria-label="Keys on this page" hidden>
+          <section class="this-block" data-this-block hidden>
+            <h3>This block</h3>
+            <dl></dl>
+          </section>
+          <%= yield :keys %>
+          <%= keys_group "Every page", "m" => "messages the desk showed" %>
+        </section>
+        <div class="modebar">
+          <p class="mode" data-mode><%= yield :mode %></p>
+          <button type="button" class="all-keys" data-show-keys aria-controls="keys-help" aria-expanded="false"><kbd>?</kbd> <span data-keys-word>keep the keys open</span></button>
+          <button type="button" class="all-keys" data-show-messages aria-controls="messages" aria-expanded="false"><kbd>m</kbd> messages</button>
+        </div>
+      </footer>
+    <% end %>
+    <%# Grouse's overlay, for a note on the desk itself. Last, as it lists the templates the page rendered. %>
+    <%= grouse_widget if Proctolog::Desk.grouse? %>
+  <% end %>
+</html>

data/app/views/proctolog/acceptances/new.html.erb

@@ -0,0 +1,34 @@
+<% content_for :title, "Accept on ##{@stop.number}" %>
+<% content_for :head do %>
+  <link rel="stylesheet" href="/decisions.css">
+<% end %>
+
+<% back = burst_decisions_path(@burst, show: params[:show], anchor: "pr-#{@stop.number}") %>
+<% home = @stop.pull_request.opened? ? "the description on GitHub" : "its file on this Mac, as nobody has opened it yet" %>
+
+<header class="burst">
+  <h1>Accept <%= pluralize(@boxes.size, "box") %> of #<%= @stop.number %></h1>
+  <p class="tally title"><%= @stop.title %></p>
+  <p class="tally">They are ticked in <%= home %>, and nowhere else. Nothing is ticked until you press Run it.</p>
+</header>
+
+<main class="acceptance">
+  <ol class="chosen">
+    <% @boxes.each do |box| %>
+      <li><%= box.plain_lead %></li>
+    <% end %>
+  </ol>
+
+  <h2>The command</h2>
+  <pre><code><%= @acceptance.command %></code></pre>
+  <p class="how">
+    Run it reads <%= home %> again, ticks exactly these lines and changes nothing else,
+    then reads it once more to check that it holds what was sent.
+  </p>
+
+  <div class="buttons">
+    <%= button_to "Run it", burst_pull_request_acceptance_path(@burst, @stop.number, show: params[:show]),
+          params: {positions: @boxes.map(&:position), digest: @stop.description.digest}, class: "primary" %>
+    <%= link_to "Back", back %>
+  </div>
+</main>

data/app/views/proctolog/bursts/_line.html.erb

@@ -0,0 +1,28 @@
+<%# locals: (burst:, stop:, standing:) %>
+<%# One pull request of the route, in a line: its number, its title, and at the right whose it is when it is not the owner's, and how far its decisions are. The line the cursor is on opens out: its title in full, what else there is to know of it, and its keys beside it. %>
+<%= tag.li id: "pr-#{stop.number}", data: {stop: "", blocking_left: standing.progress.blocking_left, turn: standing.turn} do %>
+  <p class="what">
+    <%= link_to "##{stop.number}", burst_pull_request_path(burst, stop.number), class: "number" %>
+    <%= link_to stop.title, burst_pull_request_path(burst, stop.number), class: "title" %>
+    <span class="stands"><%= beside_a_line(standing) %></span>
+  </p>
+  <p class="facts">
+    <% if (waiting = not_opened(stop)) %><%= waiting %> ·<% end %>
+    <%= stop.stacked? ? "layer #{stop.layer}" : "stands alone" %> · <%= turn_of(standing).downcase_first %> ·
+    <% if (grades = grades_of(stop.description.decisions)).present? %><%= grades %> ·<% end %>
+    <% if (open = route_reasons_of(standing)) != "nothing is open" %><span class="reasons"><%= open %></span> ·<% end %>
+    <%= pluralize(stop.description.pictures.size.nonzero? || "no", "picture") %> ·
+    <%= number_with_delimiter(stop.description.words) %> words ·
+    <%= changed_since_mark(standing, stop.pull_request) %><%= open_threads(stop.pull_request) %>
+  </p>
+  <div class="beside" data-desk>
+    <%= link_to burst_pull_request_path(burst, stop.number) do %><kbd>Enter</kbd> open<% end %>
+    <% unless focus.part == stop.part %>
+      <%= link_to burst_path(burst, part: stop.part.to_param), data: {key: "p"} do %><kbd>p</kbd> this part only<% end %>
+    <% end %>
+    <%= button_to burst_pull_request_code_review_path(burst, stop.number), form: {target: "_blank", data: {code: ""}} do %><kbd>d</kbd> code in Diffle<% end %>
+    <% if stop.url %>
+      <%= link_to stop.url, target: "_blank", rel: "noopener", data: {key: "G"} do %><kbd>G</kbd> on GitHub<% end %>
+    <% end %>
+  </div>
+<% end %>

data/app/views/proctolog/bursts/_merged.html.erb

@@ -0,0 +1,23 @@
+<%# locals: (burst:, merged:, shown:) %>
+<%# The pull requests the burst held that went in, the latest first: put away under their heading until the owner asks for them, and shown at once when nothing else of the burst is left. Each says when it went in and how far its review got. %>
+<section class="merged" id="merged" aria-labelledby="merged-heading">
+  <h2 id="merged-heading">Merged, <%= merged.size %></h2>
+  <% if shown %>
+    <ol class="lines">
+      <% merged.each do |pull_request| %>
+        <li>
+          <p class="what">
+            <%= link_to "##{pull_request.number}", pull_request.url, class: "number", target: "_blank", rel: "noopener" %>
+            <span class="title"><%= pull_request.title %></span>
+          </p>
+          <p class="facts">merged <%= pull_request.merged_at.localtime.strftime("%-d %b") %> · <%= progress_in_words(burst.choices.progress(pull_request.number, pull_request.description.decisions)) %></p>
+        </li>
+      <% end %>
+    </ol>
+    <% unless burst.finished? %>
+      <p class="hint"><%= link_to "Put them away", burst_path(burst, **request.query_parameters.symbolize_keys.except(:merged), anchor: "merged") %></p>
+    <% end %>
+  <% else %>
+    <p class="hint">Put away. <%= link_to "Show them", burst_path(burst, **request.query_parameters.symbolize_keys, merged: 1, anchor: "merged") %></p>
+  <% end %>
+</section>

data/app/views/proctolog/bursts/_moved.html.erb

@@ -0,0 +1,16 @@
+<%# locals: (burst:, pull_request:, way:) %>
+<%# A pull request that joined the burst, left it, or was opened on GitHub since it waited unopened, `way` saying which, as a line of the route: one still in it opens on Enter, and each goes once x dismisses it. %>
+<% joined = way != :left %>
+<%= tag.li data: {stop: "", notice: way} do %>
+  <p class="what">
+    <%= joined ? link_to("##{pull_request.number}", burst_pull_request_path(burst, pull_request.number), class: "number") : tag.span("##{pull_request.number}", class: "number") %>
+    <span class="title"><%= pull_request.title || "no longer open" %></span>
+    <span class="stands"><%= pull_request.was ? "opened, was ##{pull_request.was}" : way %></span>
+  </p>
+  <div class="beside" data-desk>
+    <% if joined %>
+      <%= link_to burst_pull_request_path(burst, pull_request.number) do %><kbd>Enter</kbd> open<% end %>
+    <% end %>
+    <%= button_to burst_membership_path(burst), method: :patch, params: {number: pull_request.number}, form: {data: {dismiss: ""}} do %><kbd>x</kbd> dismiss<% end %>
+  </div>
+<% end %>

data/app/views/proctolog/bursts/_notices.html.erb

@@ -0,0 +1,39 @@
+<%# locals: (burst:, notices:) %>
+<%# At the head of the route: how the burst moved since the owner last looked, and where its file and GitHub disagree, a line each, grouped by cause. What joined or left is a line of the route's own, which j and k rest on and x dismisses once seen; a disagreement stays while it is true, with its fix beside it. %>
+<section class="notices" id="notices" aria-label="Notices">
+  <% if notices.joined.any? %>
+    <h2>Joined the burst</h2>
+    <ol class="lines"><%= render partial: "moved", collection: notices.joined, as: :pull_request, locals: {burst:, way: :joined} %></ol>
+  <% end %>
+  <% if notices.left.any? %>
+    <h2>Left the burst</h2>
+    <ol class="lines"><%= render partial: "moved", collection: notices.left, as: :pull_request, locals: {burst:, way: :left} %></ol>
+  <% end %>
+  <% if notices.opened.any? %>
+    <h2>Opened on GitHub, with their review</h2>
+    <ol class="lines"><%= render partial: "moved", collection: notices.opened, as: :pull_request, locals: {burst:, way: :opened} %></ol>
+  <% end %>
+
+  <% if notices.departed.any? %>
+    <h2>Left with your choices, until handed over</h2>
+    <% notices.departed.each do |departed| %>
+      <div class="departed">
+        <p class="what"><span class="number">#<%= departed.number %></span> <span class="title"><%= departed.title || "no longer open" %></span></p>
+        <ul>
+          <% departed.entries.each do |entry| %>
+            <li><%= entry_line(entry) %></li>
+          <% end %>
+        </ul>
+      </div>
+    <% end %>
+  <% end %>
+
+  <% notices.disagreements.group_by(&:cause).each do |cause, disagreements| %>
+    <h2><%= disagreement_heading(cause) %></h2>
+    <ul class="disagreements">
+      <% disagreements.each do |disagreement| %>
+        <li><%= disagreement.said %> <span class="fix"><%= disagreement.fix %></span></li>
+      <% end %>
+    </ul>
+  <% end %>
+</section>

data/app/views/proctolog/bursts/_put_away.html.erb

@@ -0,0 +1,11 @@
+<%# locals: (burst:) %>
+<%# The owner's word that they are done with a burst some of which is still open, and the way back. %>
+<div class="put-away" data-desk>
+  <% if burst.put_away_by_hand? %>
+    <p>Put away by you: the desk no longer opens on it.</p>
+    <%= button_to "Take it out", burst_put_away_path(burst), method: :delete, class: "quiet" %>
+  <% else %>
+    <p>Done with it, open pull requests and all?</p>
+    <%= button_to "Put it away", burst_put_away_path(burst), class: "quiet" %>
+  <% end %>
+</div>

data/app/views/proctolog/bursts/_rules.html.erb

@@ -0,0 +1,27 @@
+<%# locals: (burst:, rules:) %>
+<%# The rules the owner made of answers, each a line of the route that j and k rest on: c edits it, x withdraws it. Before the agent has a rule either changes it where it stands; after, the next handover carries the replacement or the withdrawal. %>
+<section class="rules" id="rules" aria-label="Rules made in this burst">
+  <h2>Rules made in this burst</h2>
+  <ol class="lines">
+    <% rules.each do |rule| %>
+      <%= tag.li id: "rule-#{rule.id.delete_prefix("rule:")}", data: {stop: ("" unless rule.withdrawn?), rule: rule.id, state: rule.state} do %>
+        <p class="what">
+          <span class="number">rule</span>
+          <span class="title"><%= with_mentions(rule.text, burst:) %></span>
+          <span class="stands"><%= rule.state %></span>
+        </p>
+        <p class="facts"><%= rule_facts(rule) %></p>
+        <% unless rule.withdrawn? %>
+          <%= form_with url: burst_rule_path(burst, rule), method: :patch, class: "edit", data: {edit_rule: ""}, html: {hidden: true} do |form| %>
+            <%= form.text_field :text, value: rule.text, required: true, aria: {label: "The rule, in one line"} %>
+            <span class="said"><kbd>Enter</kbd> saves · <kbd>Esc</kbd> closes</span>
+          <% end %>
+          <div class="beside" data-desk>
+            <button type="button" data-edit><kbd>c</kbd> edit</button>
+            <%= button_to burst_rule_path(burst, rule), method: :delete, form: {data: {dismiss: ""}} do %><kbd>x</kbd> withdraw<% end %>
+          </div>
+        <% end %>
+      <% end %>
+    <% end %>
+  </ol>
+</section>