agentilda 1.0.3 → 2.0.1

data/lib/agentilda/mailbox.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Agentilda
+  # The one channel two agents on the same plan have to each other.
+  #
+  # `luke-backend` and `rey-frontend` build one plan in one worktree at the
+  # same time, but each is its own `claude -p` process. Claude Code can
+  # message between local sessions, and the prompts used to say so, but a
+  # session is named after its directory plus a random suffix, so a pair had
+  # to guess its partner from a list of every session on the machine by start
+  # time. It worked once, by luck. With ten plans running there would have
+  # been ten `agentilda-xx` entries and nothing to tell them apart.
+  #
+  # So the mailbox is a file in the plan folder, append-only, one numbered
+  # entry per message, readable by `agentilda mail read` during the round and
+  # by a person after it. The harness names the file and the partner in each
+  # agent's prompt, so nobody guesses.
+  class Mailbox
+    FILENAME = "mailbox.md"
+
+    # Between the fields of a heading. Neither a name nor a timestamp
+    # contains it, which is what makes the heading parseable.
+    SEPARATOR = " · "
+
+    # `## 3 · 2026-09-06 10:30:53 -0700 · rey-frontend → luke-backend`
+    HEADING = /\A\#\# (\d+) · (.+?) · (\S+) → (\S+)\s*\z/
+
+    TIME_FORMAT = "%Y-%m-%d %H:%M:%S %z"
+
+    # One entry.
+    #
+    # @!attribute [r] number
+    #   @return [Integer] 1-based, in order of writing
+    # @!attribute [r] at
+    #   @return [String] when, as {TIME_FORMAT} writes it
+    # @!attribute [r] from
+    #   @return [String] the agent that wrote it
+    # @!attribute [r] to
+    #   @return [String] the agent it is for
+    # @!attribute [r] body
+    #   @return [String]
+    Message = Data.define(:number, :at, :from, :to, :body) do
+      # @return [String] as it stands in the file
+      def to_s = "## #{number}#{SEPARATOR}#{at}#{SEPARATOR}#{from} → #{to}\n\n#{body.strip}\n"
+    end
+
+    # @param dir [String] the plan folder
+    def initialize(dir:)
+      @dir = dir
+    end
+
+    # @return [String] the plan folder
+    attr_reader :dir
+
+    # @return [String]
+    def path = File.join(dir, FILENAME)
+
+    # @return [Boolean]
+    def exist? = File.file?(path)
+
+    # Every message, in the order it was written.
+    #
+    # @return [Array<Agentilda::Mailbox::Message>]
+    def messages
+      return [] unless exist?
+
+      parse(File.read(path, encoding: "UTF-8"))
+    end
+
+    # What is waiting for one agent.
+    #
+    # @param name [String] the reader
+    # @param after [Integer] a number the reader has already seen; only
+    #   messages above it are returned
+    # @return [Array<Agentilda::Mailbox::Message>]
+    def for(name, after: 0)
+      messages.select { |m| m.to == name && m.number > after }
+    end
+
+    # Append one message and give it the next number.
+    #
+    # The append takes a lock on the file. Two agents finishing a unit in the
+    # same second would otherwise read the same last number and both write
+    # the one after it.
+    #
+    # @param from [String]
+    # @param to [String]
+    # @param body [String]
+    # @param at [Time]
+    # @return [Agentilda::Mailbox::Message] as written
+    # @raise [Agentilda::Error] on an empty body, which would be a heading
+    #   with nothing under it for the reader to act on, or on a sender or
+    #   recipient that is blank or holds whitespace: {HEADING} could not
+    #   parse such an entry back, so it would be written and never read
+    def append(from:, to:, body:, at: Time.now)
+      text = body.to_s.strip
+      raise Error, "a message needs a body" if text.empty?
+      raise Error, "a message needs --from and --to, each one agent name" unless name?(from) && name?(to)
+
+      File.open(path, File::RDWR | File::CREAT | File::APPEND, 0o644) do |f|
+        f.flock(File::LOCK_EX)
+        f.rewind
+        existing = f.read
+        number = (parse(existing).last&.number || 0) + 1
+        message = Message.new(number:, at: at.strftime(TIME_FORMAT), from:, to:, body: text)
+        f.write(existing.empty? ? "# Mailbox\n\n#{message}" : "\n#{message}")
+        message
+      end
+    end
+
+    private
+
+    # @param value [Object]
+    # @return [Boolean] one token, as {HEADING} expects a name to be
+    def name?(value) = value.to_s.match?(/\A\S+\z/)
+
+    # Only a line shaped exactly like {HEADING} starts a message, so a body
+    # may hold headings of its own, code, anything.
+    #
+    # @param text [String]
+    # @return [Array<Agentilda::Mailbox::Message>]
+    def parse(text)
+      messages = []
+      current = nil
+      body = []
+
+      text.to_s.each_line(chomp: true) do |line|
+        if (heading = HEADING.match(line))
+          messages << current.with(body: body.join("\n").strip) if current
+          current = Message.new(number: heading[1].to_i, at: heading[2], from: heading[3], to: heading[4], body: "")
+          body = []
+        elsif current
+          body << line
+        end
+      end
+
+      messages << current.with(body: body.join("\n").strip) if current
+      messages
+    end
+  end
+end

data/lib/agentilda/markdown.rb

@@ -46,7 +46,7 @@ module Agentilda
           cursor += 1
         end
 
-        found << {header: cells(head), rows: body}
+        found << { header: cells(head), rows: body }
         index = cursor
       end
 

data/lib/agentilda/progress_log.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "agentilda/status"
+require "agentilda/ui"
+
 module Agentilda
   # One line of `run --log FILE`, laid out as fixed-width columns.
   #
@@ -18,6 +21,7 @@ module Agentilda
   # @example
   #   ProgressLog.render("editing spec.md", plan: "003.00", status: "⭐️ Planned",
   #     agent: "yoda-writer", seconds: 42, round: "01", pid: 91_234)
+
   #   #=> "[16:22:14 | 003.00 | ⭐️ Planned            | yoda-writer          | 01 |   91234 |    42s] editing spec.md"
   module ProgressLog
     # Wall clock only. A log line answers "when", and the date is the file's.
@@ -60,7 +64,7 @@ module Agentilda
     # that line happens to be missing, so a reader indenting a wrapped message
     # has a number to indent by.
     COLUMN_WIDTHS = [TIME_WIDTH, PLAN_WIDTH, STATUS_WIDTH, AGENT_WIDTH, ROUND_WIDTH, PID_WIDTH,
-      SECONDS_WIDTH].freeze
+                     SECONDS_WIDTH].freeze
 
     # @see COLUMN_WIDTHS
     LINE_WIDTH = COLUMN_WIDTHS.sum + (SEPARATOR.length * (COLUMN_WIDTHS.size - 1)) + 2

data/lib/agentilda/publisher.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
+require "tempfile"
+require "tty/command"
+
 module Agentilda
   # Turns a finished worktree into a pushed branch and a pull request.
   #
   # This is the one place the harness reaches off the machine, so it requires
-  # `--commit`, is skipped with `--dont-push-anything`, and refuses anything
+  # `--commit`, is skipped with `--no-git-push`, and refuses anything
   # it is not certain about. Everything it does is reported before it does it.
   #
   # Titles follow the convention the whole system joins on:
@@ -80,7 +83,7 @@ module Agentilda
       stderr = lines.find { |l| l.start_with?("stderr:") }
       complaint = stderr&.delete_prefix("stderr:")&.strip
 
-      (complaint.to_s.empty? || complaint == "Nothing written") ? lines.first.to_s : complaint
+      complaint.to_s.empty? || complaint == "Nothing written" ? lines.first.to_s : complaint
     end
 
     # The title a plan's next pull request should carry.
@@ -104,7 +107,7 @@ module Agentilda
 
     # @return [Hash]
     def base_fields(subject, checkout, title)
-      {ordinal: subject.feature.ordinal, branch: checkout.branch, title:}
+      { ordinal: subject.feature.ordinal, branch: checkout.branch, title: }
     end
 
     # @return [Agentilda::Publisher::Publication]

data/lib/agentilda/pull_request.rb

@@ -24,190 +24,4 @@ module Agentilda
     # @return [String] "#92 — Send mail through Resend"
     def label = number ? "##{number} — #{title}" : title
   end
-
-  # Extracts the pull request roll-up from a plan folder.
-  class PullRequests
-    # A markdown link whose text may contain escaped brackets, because every
-    # title this tool writes now opens with `\[NNN.MM\]`. Matching `[^\]]+`
-    # stops at the escaped `]` and loses the URL with it.
-    LINK = /\[((?:\\.|[^\]\\])+)\]\((https?:[^)\s]+)\)/
-
-    # Canonical wording for the states we recognise, most specific first.
-    STATES = [
-      [/\bclosed\b|\bunmerged\b|\babandoned\b/i, "Closed 🔴"],
-      [/\bmerged\b/i, "Merged 🟣"],
-      [/\bdraft\b|\bwip\b/i, "WIP 🟡"],
-      [/\bopen\b/i, "Open 🟡"]
-    ].freeze
-
-    # Filenames that may hold the table.
-    CANDIDATES = %w[pull-requests.md pull_requests.md prs.md].freeze
-
-    # The file this class writes, and the first one it looks for.
-    FILENAME = CANDIDATES.first
-
-    # Render `pull-requests.md` for a set of pull requests fetched from GitHub.
-    #
-    # The table is what {#parse} reads back and what the state machine judges
-    # a folder by. The descriptions below it are for a reader — human or
-    # agent — synthesizing a specification from work that already shipped:
-    # the table says *which* pull requests, the bodies say *what they did*,
-    # and a retroactive `spec.md` cannot be written from numbers alone.
-    #
-    # Prose after the table is ignored by the parser, so the two can coexist
-    # in one file rather than needing a scratch file the folder rules forbid.
-    #
-    # @param prs [Array<Hash>] `{number:, title:, url:, state:, body:}`
-    # @return [String]
-    def self.render(prs)
-      rows = prs.map { |pr|
-        "| #{pr[:number]} | [#{escape(pr[:title])}](#{pr[:url]}) | #{pr[:state]} |"
-      }
-
-      <<~MARKDOWN
-        # Pull Requests
-
-        | Pull Request Number | Pull Request Name | Status |
-        | ------------------: | :---------------- | -----: |
-        #{rows.join("\n")}
-
-        ## What these pull requests did
-
-        #{prs.map { |pr| describe(pr) }.join("\n")}
-      MARKDOWN
-    end
-
-    # @param pr [Hash]
-    # @return [String]
-    def self.describe(pr)
-      body = pr[:body].to_s.strip
-      body = "_No description was written on the pull request._" if body.empty?
-
-      <<~MARKDOWN
-        ### ##{pr[:number]} — #{pr[:title]}
-
-        #{pr[:url]}
-
-        #{body}
-      MARKDOWN
-    end
-
-    # Three characters have to survive a round trip through a table cell.
-    #
-    # A `|` ends the cell, and a title containing one is not unusual —
-    # "fix: guard against a || b".
-    #
-    # `[` and `]` are newer and cost more. Every title this tool writes now
-    # opens with a plan number, so the row reads `[[013.00] Ship it](url)` —
-    # and a markdown link whose text starts with `[` does not parse. The
-    # title came back with the URL glued to it and `url` came back nil, which
-    # is not a cosmetic loss: it is every pull request link on the page, and
-    # the attachment on every Linear issue.
-    #
-    # @param text [String]
-    # @return [String]
-    def self.escape(text)
-      text.to_s.gsub(/([\[\]|])/) { "\\#{$1}" }.gsub(/\s+/, " ").strip
-    end
-
-    # @param dir [String] absolute path to the plan folder
-    def initialize(dir:)
-      @dir = dir
-    end
-
-    # @return [Array<Agentilda::PullRequest>] possibly empty
-    def all = @all ||= parse
-
-    private
-
-    # @return [String]
-    attr_reader :dir
-
-    # @return [Array<Agentilda::PullRequest>]
-    def parse
-      path = CANDIDATES.map { |f| File.join(dir, f) }.find { |p| File.file?(p) }
-      return [] unless path
-
-      text = File.read(path, encoding: "UTF-8")
-      table = pick_table(Markdown.tables(text))
-      return scrape(text) unless table
-
-      rows = table[:rows].filter_map { |cells| row_to_pr(cells, columns(table[:header])) }
-      rows.empty? ? scrape(text) : rows
-    end
-
-    # @param tables [Array<Hash>]
-    # @return [Hash, nil]
-    def pick_table(tables)
-      tables.find { |t|
-        t[:header].any? { |h| h.match?(/pull\s*request|\bpr\b|\A#\z|\Anumber\z/i) } &&
-          t[:rows].any? { |r| r.any? { |c| c.match?(%r{/(?:pull|merge_requests)/\d+}) } }
-      } || tables.find { |t| t[:rows].any? { |r| r.any? { |c| c.match?(%r{/pull/\d+}) } } }
-    end
-
-    # @param header [Array<String>]
-    # @return [Hash{Symbol => Integer, nil}]
-    def columns(header)
-      {
-        number: header.index { |h| h.match?(/number|\A#\z|\Apr\z|\Apr\s*#/i) },
-        title: header.index { |h| h.match?(/name|title|summary|description|scope/i) },
-        state: header.index { |h| h.match?(/status|state/i) }
-      }
-    end
-
-    # @param cells [Array<String>]
-    # @param idx [Hash{Symbol => Integer, nil}]
-    # @return [Agentilda::PullRequest, nil]
-    def row_to_pr(cells, idx)
-      title_cell = cells[idx[:title] || 1].to_s
-
-      # The title comes from the title column and the URL from wherever it is.
-      # Scanning every cell for the first link and taking both from it reads
-      # `| [#24](…) | Split verified into signed_off |` as an issue called
-      # "#24", because the number column is a link too and comes first.
-      titled = title_cell.match(LINK)
-      link = titled || cells.filter_map { |c| c.match(LINK) }.first
-
-      url = link && link[2]
-      title = titled ? titled[1] : unformat(title_cell)
-      title = title.gsub(/\\([\[\]|\\])/, '\1') # undo the escaping {.render} applies
-      number = cells[idx[:number] || 0].to_s[/\d+/] || url&.[](%r{/(?:pull|merge_requests)/(\d+)}, 1)
-      return nil if title.empty? && url.nil?
-
-      PullRequest.new(number:, url:, title: title.empty? ? "Pull request" : title,
-        state: normalize(cells[idx[:state] || -1].to_s))
-    end
-
-    # When there is no parsable table, scrape bare links so a folder that
-    # plainly has pull requests does not report none.
-    #
-    # @param text [String]
-    # @return [Array<Agentilda::PullRequest>]
-    def scrape(text)
-      text.scan(%r{https?://\S+?/(?:pull|merge_requests)/(\d+)}).flatten.uniq.map do |num|
-        PullRequest.new(number: num, title: "Pull request ##{num}", state: "Unknown",
-          url: text[%r{https?://\S+?/(?:pull|merge_requests)/#{num}\b}])
-      end
-    end
-
-    # Strip the markdown a title was wrapped in without eating the title.
-    #
-    # An underscore between letters is not emphasis, it is an identifier —
-    # `signed_off`, `as_of`, `pull_requests`. Removing every underscore turned
-    # "Split verified into signed_off" into "signedoff" on the way to Linear.
-    #
-    # @param cell [String]
-    # @return [String]
-    def unformat(cell)
-      cell.to_s.gsub(/[*`]/, "").sub(/\A_+/, "").sub(/_+\z/, "").strip
-    end
-
-    # @param cell [String]
-    # @return [String]
-    def normalize(cell)
-      STATES.each { |pattern, label| return label if cell.match?(pattern) }
-      stripped = cell.gsub(/[*_`]/, "").strip
-      stripped.empty? ? "Unknown" : stripped
-    end
-  end
 end

data/lib/agentilda/pull_requests.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require "agentilda/markdown"
+require "agentilda/pull_request"
+
+module Agentilda
+  # Extracts the pull request roll-up from a plan folder.
+  class PullRequests
+    # A markdown link whose text may contain escaped brackets, because every
+    # title this tool writes now opens with `\[NNN.MM\]`. Matching `[^\]]+`
+    # stops at the escaped `]` and loses the URL with it.
+    LINK = /\[((?:\\.|[^\]\\])+)\]\((https?:[^)\s]+)\)/
+
+    # Canonical wording for the states we recognise, most specific first.
+    STATES = [
+      [/\bclosed\b|\bunmerged\b|\babandoned\b/i, "Closed 🔴"],
+      [/\bmerged\b/i, "Merged 🟣"],
+      [/\bdraft\b|\bwip\b/i, "WIP 🟡"],
+      [/\bopen\b/i, "Open 🟡"]
+    ].freeze
+
+    # Filenames that may hold the table.
+    CANDIDATES = %w[pull-requests.md pull_requests.md prs.md].freeze
+
+    # The file this class writes, and the first one it looks for.
+    FILENAME = CANDIDATES.first
+
+    # Render `pull-requests.md` for a set of pull requests fetched from GitHub.
+    #
+    # The table is what {#parse} reads back and what the state machine judges
+    # a folder by. The descriptions below it are for a reader — human or
+    # agent — synthesizing a specification from work that already shipped:
+    # the table says *which* pull requests, the bodies say *what they did*,
+    # and a retroactive `spec.md` cannot be written from numbers alone.
+    #
+    # Prose after the table is ignored by the parser, so the two can coexist
+    # in one file rather than needing a scratch file the folder rules forbid.
+    #
+    # @param prs [Array<Hash>] `{number:, title:, url:, state:, body:}`
+    # @return [String]
+    def self.render(prs)
+      rows = prs.map { |pr|
+        "| #{pr[:number]} | [#{escape(pr[:title])}](#{pr[:url]}) | #{pr[:state]} |"
+      }
+
+      <<~MARKDOWN
+        # Pull Requests
+
+        | Pull Request Number | Pull Request Name | Status |
+        | ------------------: | :---------------- | -----: |
+        #{rows.join("\n")}
+
+        ## What these pull requests did
+
+        #{prs.map { |pr| describe(pr) }.join("\n")}
+      MARKDOWN
+    end
+
+    # The table alone, for splicing into a file that already says other
+    # things: the ledger blocks luke and rey write before a pull request
+    # exists. Rewriting the whole file deleted their signatures.
+    #
+    # @param prs [Array<Hash>]
+    # @return [String] header, rule and rows, newline-terminated
+    def self.table(prs)
+      rows = prs.map { |pr| "| #{pr[:number]} | [#{escape(pr[:title])}](#{pr[:url]}) | #{pr[:state]} |" }
+      ["| Pull Request Number | Pull Request Name | Status |",
+       "| ------------------: | :---------------- | -----: |", *rows].join("\n") + "\n"
+    end
+
+    # Write the table into +path+ without touching anything else there.
+    #
+    # @param path [String]
+    # @param prs [Array<Hash>]
+    # @return [void]
+    def self.upsert(path, prs)
+      return File.write(path, render(prs)) unless File.file?(path)
+
+      lines = File.read(path, encoding: "UTF-8").lines
+      start = lines.index { |l| l.strip.start_with?("|") && lines[lines.index(l) + 1].to_s.strip.start_with?("|") }
+      if start
+        stop = start
+        stop += 1 while lines[stop + 1]&.strip&.start_with?("|")
+        lines[start..stop] = [table(prs)]
+      else
+        at = lines.index { |l| l.start_with?("# ") }
+        insertion = ["\n", table(prs)]
+        at ? lines.insert(at + 1, *insertion) : lines.unshift("# Pull Requests\n", *insertion, "\n")
+      end
+      File.write(path, lines.join)
+    end
+
+    # @param pr [Hash]
+    # @return [String]
+    def self.describe(pr)
+      body = pr[:body].to_s.strip
+      body = "_No description was written on the pull request._" if body.empty?
+
+      <<~MARKDOWN
+        ### ##{pr[:number]} — #{pr[:title]}
+
+        #{pr[:url]}
+
+        #{body}
+      MARKDOWN
+    end
+
+    # Three characters have to survive a round trip through a table cell.
+    #
+    # A `|` ends the cell, and a title containing one is not unusual —
+    # "fix: guard against a || b".
+    #
+    # `[` and `]` are newer and cost more. Every title this tool writes now
+    # opens with a plan number, so the row reads `[[013.00] Ship it](url)` —
+    # and a markdown link whose text starts with `[` does not parse. The
+    # title came back with the URL glued to it and `url` came back nil, which
+    # is not a cosmetic loss: it is every pull request link on the page, and
+    # the attachment on every Linear issue.
+    #
+    # @param text [String]
+    # @return [String]
+    def self.escape(text)
+      text.to_s.gsub(/([\[\]|])/) { "\\#{$1}" }.gsub(/\s+/, " ").strip
+    end
+
+    # @param dir [String] absolute path to the plan folder
+    def initialize(dir:)
+      @dir = dir
+    end
+
+    # @return [Array<Agentilda::PullRequest>] possibly empty
+    def all = @all ||= parse
+
+    private
+
+    # @return [String]
+    attr_reader :dir
+
+    # @return [Array<Agentilda::PullRequest>]
+    def parse
+      path = CANDIDATES.map { |f| File.join(dir, f) }.find { |p| File.file?(p) }
+      return [] unless path
+
+      text = File.read(path, encoding: "UTF-8")
+      table = pick_table(Markdown.tables(text))
+      return scrape(text) unless table
+
+      rows = table[:rows].filter_map { |cells| row_to_pr(cells, columns(table[:header])) }
+      rows.empty? ? scrape(text) : rows
+    end
+
+    # @param tables [Array<Hash>]
+    # @return [Hash, nil]
+    def pick_table(tables)
+      tables.find { |t|
+        t[:header].any? { |h| h.match?(/pull\s*request|\bpr\b|\A#\z|\Anumber\z/i) } &&
+          t[:rows].any? { |r| r.any? { |c| c.match?(%r{/(?:pull|merge_requests)/\d+}) } }
+      } || tables.find { |t| t[:rows].any? { |r| r.any? { |c| c.match?(%r{/pull/\d+}) } } }
+    end
+
+    # @param header [Array<String>]
+    # @return [Hash{Symbol => Integer, nil}]
+    def columns(header)
+      {
+        number: header.index { |h| h.match?(/number|\A#\z|\Apr\z|\Apr\s*#/i) },
+        title:  header.index { |h| h.match?(/name|title|summary|description|scope/i) },
+        state:  header.index { |h| h.match?(/status|state/i) }
+      }
+    end
+
+    # @param cells [Array<String>]
+    # @param idx [Hash{Symbol => Integer, nil}]
+    # @return [Agentilda::PullRequest, nil]
+    def row_to_pr(cells, idx)
+      title_cell = cells[idx[:title] || 1].to_s
+
+      # The title comes from the title column and the URL from wherever it is.
+      # Scanning every cell for the first link and taking both from it reads
+      # `| [#24](...) | Split verified into signed_off |` as an issue called
+      # "#24", because the number column is a link too and comes first.
+      titled = title_cell.match(LINK)
+      link = titled || cells.filter_map { |c| c.match(LINK) }.first
+
+      url = link && link[2]
+      title = titled ? titled[1] : unformat(title_cell)
+      title = title.gsub(/\\([\[\]|\\])/, '\1') # undo the escaping {.render} applies
+      number = cells[idx[:number] || 0].to_s[/\d+/] || url&.[](%r{/(?:pull|merge_requests)/(\d+)}, 1)
+      return nil if title.empty? && url.nil?
+
+      PullRequest.new(number:,
+        url:,
+        title: title.empty? ? "Pull request" : title,
+        state: normalize(cells[idx[:state] || -1].to_s))
+    end
+
+    # When there is no parsable table, scrape bare links so a folder that
+    # plainly has pull requests does not report none.
+    #
+    # @param text [String]
+    # @return [Array<Agentilda::PullRequest>]
+    def scrape(text)
+      text.scan(%r{https?://\S+?/(?:pull|merge_requests)/(\d+)}).flatten.uniq.map do |num|
+        PullRequest.new(number: num,
+          title: "Pull request ##{num}",
+          state: "Unknown",
+          url: text[%r{https?://\S+?/(?:pull|merge_requests)/#{num}\b}])
+      end
+    end
+
+    # Strip the markdown a title was wrapped in without eating the title.
+    #
+    # An underscore between letters is not emphasis, it is an identifier —
+    # `signed_off`, `as_of`, `pull_requests`. Removing every underscore turned
+    # "Split verified into signed_off" into "signedoff" on the way to Linear.
+    #
+    # @param cell [String]
+    # @return [String]
+    def unformat(cell)
+      cell.to_s.gsub(/[*`]/, "").sub(/\A_+/, "").sub(/_+\z/, "").strip
+    end
+
+    # @param cell [String]
+    # @return [String]
+    def normalize(cell)
+      STATES.each { |pattern, label| return label if cell.match?(pattern) }
+      stripped = cell.gsub(/[*_`]/, "").strip
+      stripped.empty? ? "Unknown" : stripped
+    end
+  end
+end

data/lib/agentilda/reporter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "agentilda/status"
+
 module Agentilda
   # `/spec-status` — every plan, its state in icon and words, and its pull
   # requests as clickable links.
@@ -76,8 +78,12 @@ module Agentilda
     #
     # @return [Integer]
     def pr_column
-      @pr_column ||= row(" ", " " * ORDINAL_WIDTH, " " * EMOJI_WIDTH,
-        " " * label_width, " " * title_width, "").length
+      @pr_column ||= row(" ",
+        " " * ORDINAL_WIDTH,
+        " " * EMOJI_WIDTH,
+        " " * label_width,
+        " " * title_width,
+        "").length
     end
 
     # @return [Integer] cell at which the feature name starts
@@ -158,7 +164,7 @@ module Agentilda
     # @return [String]
     def footer
       counts = totals.map { |key, n| "#{STATUS_BY_KEY.fetch(key).emoji} #{n}" }.join("   ")
-      lines = ["  #{tree.subjects.size} #{(tree.subjects.size == 1) ? "plan" : "plans"}   #{counts}"]
+      lines = ["  #{tree.subjects.size} #{tree.subjects.size == 1 ? "plan" : "plans"}   #{counts}"]
 
       unless inconsistent.empty?
         lines << "  #{UI.paint("#{inconsistent.size} with a status their contents do not justify", :red)}"