agentilda 2.0.1 → 2.0.4

data/lib/agentilda/status.rb

@@ -1,363 +0,0 @@
-# frozen_string_literal: true
-
-module Agentilda
-  # A folder's state: what it means, which files it cannot be honest without,
-  # and the rule that decides whether the folder may legitimately claim it.
-  #
-  # `invariant` is asked in both directions. {StateMachine} asks it of a
-  # destination before moving there; `resync` and `check` ask it of the current
-  # state, to catch folders whose name has drifted from their contents. One
-  # definition, so the two can never disagree about what a state means.
-  #
-  # @!attribute [r] key
-  #   @return [Symbol] machine-facing name, e.g. `:product_blocked`
-  # @!attribute [r] emoji
-  #   @return [String] as it appears in the folder name
-  # @!attribute [r] label
-  #   @return [String] the human words
-  # @!attribute [r] requires
-  #   @return [Array<String>] files this state cannot be honest without
-  # @!attribute [r] note
-  #   @return [String] one-line meaning, for tables and generated docs
-  # @!attribute [r] invariant
-  #   @return [Proc, nil] `(subject) -> String | nil` — the reason it does not hold
-  Status = Data.define(:key, :emoji, :label, :requires, :note, :invariant) do
-    # @param subject [#file?, #read, #pull_requests]
-    # @return [Boolean]
-    def satisfied_by?(subject) = violation(subject).nil?
-
-    # @param subject [#file?, #read, #pull_requests]
-    # @return [String, nil] why this state is not justified, nil when it is
-    def violation(subject)
-      missing = requires.reject { |f| subject.file?(f) }
-      return "#{label} requires #{missing.map { |f| "`#{f}`" }.join(" and ")}" unless missing.empty?
-
-      invariant&.call(subject)
-    end
-
-    # @return [Boolean] whether nothing may follow this state
-    def terminal? = StateMachine.outbound(key).empty?
-
-    # @return [String] emoji and words, as the tables print it
-    def to_s = "#{emoji} #{label}"
-  end
-
-  # "1 pull request", "3 pull requests".
-  #
-  # @param count [Integer]
-  # @return [String]
-  def self.pull_request_count(count) = "#{count} pull request#{"s" unless count == 1}"
-
-  # What proves a specification has been researched rather than merely
-  # written: the chapter `leah-researcher` contributes. It is a section of
-  # `spec.md` rather than a file of its own because research is not a separate
-  # document — it is the first half of the specification, and splitting it
-  # would leave `yoda-writer` reading two files to write one.
-  RESEARCH_CHAPTER = /^[ \t]{0,3}\#{2,3}[ \t]+Research\b/i
-
-  # What proves `plan.md` holds a plan rather than the blank file
-  # `yoda-writer` leaves for `palpatine-planner`: any section heading. The
-  # ledger notes are stripped first, so an agent's `Started` line does not
-  # count as a plan.
-  PLAN_HEADING = /^[ \t]{0,3}\#{1,3}[ \t]+\S/
-
-  # Variation selectors make ⚪️ and ⚪ different strings that mean the same
-  # thing to a human. Compare with them removed.
-  #
-  # @param str [String, nil]
-  # @return [String]
-  def self.fold_emoji(str) = str.to_s.gsub(/[\u{FE0E}\u{FE0F}\u{200D}]/, "")
-
-  # 🟢 Ready for Review, 👀 In Review and 🔴 Changes Requested are the same
-  # thing on disk — the work exists and at least one pull request is still
-  # open. Which of the three it is lives in the folder name and nowhere else,
-  # so they share one invariant rather than three that could drift apart.
-  #
-  # @param label [String]
-  # @return [Proc]
-  def self.open_pull_request(label)
-    lambda { |subject|
-      return "#{label} requires an open pull request; none are recorded" if subject.pull_requests.empty?
-
-      "#{label}, but every pull request is already merged" if subject.pull_requests.none?(&:open?)
-    }
-  end
-
-  # A question that is still somebody's to answer, written as its own heading:
-  # `## B1`, `## B2`. The number is what `blocked.md` gets referenced by in
-  # conversation and in pull requests, so it is also the only part of the file
-  # a program can count.
-  #
-  # Whoever writes `blocked.md` MUST use this notation. A question written any
-  # other way is invisible to every part of this tool: the folder never becomes
-  # ⭕️, and `unblock` reports a file with nothing in it to drain. {ANSWER_BLOCK}
-  # is the other half of the pair.
-  OPEN_BLOCK = /^[ \t]{0,3}\#{0,4}[ \t]*\**B(\d+)\b/
-
-  # The answer to the question of the same number: `## A1` settles `## B1`.
-  #
-  # Answers are an inbox, not a record. `lando-broker` folds each one into the
-  # document its question was stopping and deletes both, so a `blocked.md`
-  # holding nothing but history must not go on stopping the folder. An `A`
-  # never matches {OPEN_BLOCK}, which is what lets the two live in one file.
-  ANSWER_BLOCK = /^[ \t]{0,3}\#{0,4}[ \t]*\**A(\d+)\b/
-
-  # The numbers named by every heading in +text+ matching +pattern+.
-  #
-  # @param text [String, nil]
-  # @param pattern [Regexp] {OPEN_BLOCK} or {ANSWER_BLOCK}
-  # @return [Array<Integer>] in the order they appear, without duplicates
-  def self.block_numbers(text, pattern)
-    text.to_s.lines.filter_map { |line| line[pattern, 1]&.to_i }.uniq
-  end
-
-  # ⭕️ Technical Block and 🅱️ Product Block are the same thing on disk: a
-  # `blocked.md` still naming at least one question nobody has answered. Which
-  # human is owed the answer lives in the folder name and nowhere else, so the
-  # two share one invariant rather than two that could drift apart.
-  #
-  # This is what lets a block drain in pieces. Answers land in `blocked.md`
-  # one at a time, `lando-broker` moves each into `spec.md` or `plan.md` and
-  # deletes it here, and the folder leaves ⭕️ on the pass that empties the
-  # file, by content rather than by anyone remembering to delete it.
-  #
-  # @param label [String]
-  # @return [Proc]
-  def self.open_block(label)
-    lambda { |subject|
-      "#{label}, but `blocked.md` names no open question" unless subject.read("blocked.md").to_s.match?(OPEN_BLOCK)
-    }
-  end
-
-  # Every state a plan folder may be in, in lifecycle order. That order drives
-  # the legend, the generated documentation and the `--to` help text.
-  #
-  # 🟣 Merged is deliberately absent: it is a pull request's status, not a
-  # folder's, and giving it a folder state invites folders that claim a pull
-  # request's condition as their own.
-  #
-  # Adding a state here, or changing an emoji, makes the hand-drawn
-  # `docs/img/plan-spec-build.png` stale — `just docs` will show you, because
-  # the mermaid source in the generated document moves with this list.
-  STATUSES = [
-    Status.new(
-      key:       :new,
-      emoji:     "⚪️",
-      label:     "New",
-      requires:  %w[spec.md],
-      note:      "a specification exists; it has not been planned yet",
-      invariant: nil
-    ),
-    Status.new(
-      key:       :researched,
-      emoji:     "🔎",
-      label:     "Researched",
-      requires:  %w[spec.md],
-      note:      "the topic has been researched; `spec.md` carries a `## Research` chapter",
-      invariant: lambda { |s|
-        body = s.read("spec.md").to_s
-        "Researched, but `spec.md` has no `## Research` chapter" unless body.match?(RESEARCH_CHAPTER)
-      }
-    ),
-    Status.new(
-      key:       :ready_for_planning,
-      emoji:     "📋",
-      label:     "Ready for Planning",
-      requires:  %w[spec.md plan.md],
-      note:      "the specification is finished; `plan.md` exists and is still blank, waiting for the planner",
-      invariant: lambda { |s|
-        body = Ledger.stripped(s.read("plan.md"))
-        "Ready for Planning, but `plan.md` already holds a plan" if body.match?(PLAN_HEADING)
-      }
-    ),
-    Status.new(
-      key:       :planned,
-      emoji:     "⭐️",
-      label:     "Planned",
-      requires:  %w[spec.md plan.md],
-      note:      "specified and planned; nobody has started building",
-      invariant: lambda { |s|
-        body = Ledger.stripped(s.read("plan.md"))
-        next "Planned, but `plan.md` has no work units yet" unless body.match?(PLAN_HEADING)
-
-        # An open pull request means somebody did start. Without this
-        # clause a ✅ folder found with a new pull request would fall back
-        # to ⭐️, the family's floor, and claim nobody had touched it.
-        open = s.pull_requests.count(&:open?)
-        "Planned, but #{Agentilda.pull_request_count(open)} already open" if open.positive?
-      }
-    ),
-    # `pull-requests.md` is deliberately absent from `requires` on both of the
-    # building states, though it names the file they are about. That file is
-    # written by opening a pull request, which happens once, when the last
-    # implementer advances the plan to Ready for Review. Requiring the file to
-    # *enter* Building would mean nothing could ever justify entering it, and
-    # `palpatine-planner` finishing `plan.md` would loop forever between itself
-    # and a state it can never actually reach. Ready for Review is where the
-    # file becomes a real requirement, once something has had the chance to
-    # write it.
-    Status.new(
-      key:       :building,
-      emoji:     "🟡",
-      label:     "Building",
-      requires:  %w[spec.md plan.md],
-      note:      "the back end is under way: data, domain and the API the interface will call",
-      invariant: lambda { |s|
-        body = Ledger.stripped(s.read("plan.md"))
-        "Building, but `plan.md` has no work units to build" unless body.match?(PLAN_HEADING)
-      }
-    ),
-    # Two building states rather than one, because the order is not a
-    # preference: an interface is written against an API that already answers.
-    # Splitting them lets each half be built by someone who only has to be good
-    # at that half, and gives the second a working system to build on rather
-    # than a description of one.
-    Status.new(
-      key:       :building_ui,
-      emoji:     "🎨",
-      label:     "Building UI",
-      requires:  %w[spec.md plan.md],
-      note:      "the back end holds; the interface is being built against it",
-      invariant: lambda { |s|
-        body = Ledger.stripped(s.read("plan.md"))
-        "Building UI, but `plan.md` has no work units to build" unless body.match?(PLAN_HEADING)
-      }
-    ),
-    Status.new(
-      key:       :ready_for_review,
-      emoji:     "🟢",
-      label:     "Ready for Review",
-      requires:  %w[spec.md plan.md pull-requests.md],
-      note:      "every pull request is green on CI and waiting for a reviewer",
-      invariant: open_pull_request("Ready for Review")
-    ),
-    Status.new(
-      key:       :in_review,
-      emoji:     "👀",
-      label:     "In Review",
-      requires:  %w[spec.md plan.md pull-requests.md],
-      note:      "a reviewer has picked it up and has not ruled yet",
-      invariant: open_pull_request("In Review")
-    ),
-    Status.new(
-      key:       :rejected,
-      emoji:     "🔴",
-      label:     "Changes Requested",
-      requires:  %w[spec.md plan.md pull-requests.md],
-      note:      "the review asked for fixes; resubmit once they are made",
-      invariant: open_pull_request("Changes Requested")
-    ),
-    Status.new(
-      key:       :approved,
-      emoji:     "✅",
-      label:     "Approved & Merged",
-      requires:  %w[pull-requests.md],
-      note:      "reviewed, approved, and every pull request merged",
-      invariant: lambda { |s|
-        return "Approved & Merged, but no pull requests are recorded" if s.pull_requests.empty?
-
-        open = s.pull_requests.count(&:open?)
-        "Approved & Merged, but #{Agentilda.pull_request_count(open)} still open" if open.positive?
-      }
-    ),
-    Status.new(
-      key:       :deployed,
-      emoji:     "😎",
-      label:     "Deployed",
-      requires:  %w[deployed.md],
-      note:      "live in production; `deployed.md` names the release, date and SHA",
-      invariant: nil
-    ),
-    Status.new(
-      key:       :rolled_back,
-      emoji:     "😱",
-      label:     "Rolled Back",
-      requires:  %w[rollback.md],
-      note:      "it shipped and was pulled; `rollback.md` names what broke",
-      invariant: nil
-    ),
-    Status.new(
-      key:       :shit,
-      emoji:     "💩",
-      label:     "Scrapped by Review",
-      requires:  %w[rewrite.md],
-      note:      "the review scrapped the work; the plan survives, the pull requests do not",
-      invariant: nil
-    ),
-    Status.new(
-      key:       :blocked,
-      emoji:     "⭕️",
-      label:     "Technical Block",
-      requires:  %w[blocked.md],
-      note:      "cannot proceed; `blocked.md` names what an engineer or the CTO must decide",
-      invariant: open_block("Technical Block")
-    ),
-    Status.new(
-      key:       :product_blocked,
-      emoji:     "🅱️",
-      label:     "Product Block",
-      requires:  %w[blocked.md],
-      note:      "cannot proceed; `blocked.md` names what a product manager must decide",
-      invariant: open_block("Product Block")
-    ),
-    Status.new(
-      key:       :deferred,
-      emoji:     "☢️",
-      label:     "Deferred",
-      requires:  %w[delayed.md],
-      note:      "could proceed and chose not to yet; `delayed.md` must name the trigger",
-      invariant: lambda { |s|
-        body = s.read("delayed.md").to_s
-        "Deferred, but `delayed.md` names no trigger" unless body.match?(/trigger|revisit|when\b|until\b|once\b/i)
-      }
-    ),
-    Status.new(
-      key:       :retroactive,
-      emoji:     "🕰️",
-      label:     "Retroactive",
-      requires:  [],
-      note:      "the feature is live, but has neither a specification nor a plan",
-      invariant: lambda { |s|
-        next "Retroactive, but a `spec.md` already exists — it has been documented" if s.file?("spec.md")
-
-        "Retroactive, but no pull requests are recorded" if s.pull_requests.empty?
-      }
-    ),
-    Status.new(
-      key:       :discarded,
-      emoji:     "❌",
-      label:     "Discarded",
-      requires:  %w[discarded.md],
-      note:      "dropped for good; `discarded.md` says why. A terminal state",
-      invariant: nil
-    )
-  ].freeze
-
-  # Emoji => status, folded so ⚪ and ⚪️ both resolve.
-  STATUS_BY_EMOJI = STATUSES.each_with_object({}) { |s, h| h[fold_emoji(s.emoji)] ||= s }.freeze
-
-  # Symbol => status.
-  STATUS_BY_KEY = STATUSES.to_h { |s| [s.key, s] }.freeze
-
-  # @param emoji [String, nil]
-  # @return [Agentilda::Status, nil]
-  def self.status_for_emoji(emoji) = STATUS_BY_EMOJI[fold_emoji(emoji)]
-
-  # Resolve a state from the only two names it has: its key, and its emoji.
-  #
-  # There is deliberately no synonym table. A state that also answers to
-  # "star", "green" and "completed" has four names to keep in step with the
-  # folder, the generated docs and the agent frontmatter — and the synonym
-  # table that used to live here went stale pointing six words at a state that
-  # no longer existed.
-  #
-  # @param text [String, Symbol, Agentilda::Status, nil]
-  # @return [Agentilda::Status, nil]
-  def self.status(text)
-    return nil if text.nil?
-    return text if text.is_a?(Status)
-
-    key = text.to_s.strip
-    STATUS_BY_KEY[key.to_sym] || status_for_emoji(key)
-  end
-end

data/lib/agentilda/subject.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-require "agentilda/feature"
-require "agentilda/pull_requests"
-require "agentilda/state_machine"
-
-module Agentilda
-  # A plan folder as the state machine sees it: which files exist, what they
-  # say, and which pull requests they record.
-  #
-  # It exists because the invariants ask the same questions repeatedly and
-  # {Feature} is a frozen `Data` with nowhere to memoize the answers.
-  class Subject
-    # @param feature [Agentilda::Feature]
-    def initialize(feature)
-      @feature = feature
-      @reads = {}
-    end
-
-    # @return [Agentilda::Feature]
-    attr_reader :feature
-
-    # @return [Agentilda::Status] the status the folder name claims
-    def status = feature.status
-
-    # @param name [String] a bare filename
-    # @return [Boolean]
-    def file?(name) = File.file?(File.join(feature.path, name))
-
-    # @param name [String]
-    # @return [String, nil] contents, or nil when absent
-    def read(name)
-      @reads.fetch(name) do
-        @reads[name] = file?(name) ? File.read(File.join(feature.path, name), encoding: "UTF-8") : nil
-      end
-    end
-
-    # @return [Array<Agentilda::PullRequest>]
-    def pull_requests = @pull_requests ||= PullRequests.new(dir: feature.path).all
-
-    # The specification's own Goal section, verbatim and at most two
-    # paragraphs. Anything that paraphrases the spec is a second copy that
-    # drifts; quoting it is not — which is why the pull request body and the
-    # index both read it from here rather than each writing their own.
-    #
-    # @return [Array<String>] paragraphs, empty when there is no Goal to read
-    def goal
-      body = read("spec.md").to_s
-      section = body[/^\#{"#"}{2,3}\s*Goals?\b[^\n]*\n+(.*?)(?=\n\#{"#"}{1,3}\s|\z)/mi, 1]
-
-      paragraphs(section) || paragraphs(body.sub(/\A\s*\#{"#"}[^\n]*\n/, "")) || []
-    end
-
-    # Specifications written before the template existed have no Goal section,
-    # and they are exactly the ones an index most needs to describe. So the
-    # opening prose stands in — skipping headings, quotes, lists and tables,
-    # which describe the document rather than the work.
-    #
-    # @param text [String, nil]
-    # @return [Array<String>, nil] nil when there is no prose to be had
-    def paragraphs(text)
-      found = text.to_s.strip.split(/\n{2,}/)
-                  .map(&:strip)
-                  .reject { |p| p.empty? || p.match?(/\A[\#>|\-*\d`_=]/) }
-                  .first(2)
-
-      found.empty? ? nil : found
-    end
-
-    # The questions `blocked.md` still names, by number.
-    #
-    # Empty means one of two very different things, and a caller that treats
-    # them alike is how a folder with thirty kilobytes of open questions gets
-    # reported as "nothing left open": either there is no `blocked.md` at all,
-    # or there is one whose questions are not written as `## B<n>` and are
-    # therefore invisible to every part of this tool. Ask {#file?} which.
-    #
-    # @return [Array<Integer>]
-    def open_blocks = Agentilda.block_numbers(read("blocked.md"), OPEN_BLOCK)
-
-    # The answers waiting in `blocked.md`, by number. `## A1` settles `## B1`.
-    #
-    # Waiting, not folded. An `## A<n>` heading is not the same as a settled
-    # question: one may say in its own body that it is a draft pending a
-    # conversation. `lando-broker` makes that call; this only counts headings.
-    #
-    # @return [Array<Integer>]
-    def block_answers = Agentilda.block_numbers(read("blocked.md"), ANSWER_BLOCK)
-
-    # A `blocked.md` this tool cannot read: the file is there, and not one
-    # question in it is written as `## B<n>`. Nothing can drain it and nothing
-    # currently says so, which is the whole reason this exists.
-    #
-    # @return [Boolean]
-    def unreadable_block? = file?("blocked.md") && open_blocks.empty?
-
-    # @return [String, nil] why the folder's name is not justified
-    def violation = status.violation(self)
-
-    # @return [Boolean] whether the name matches the contents
-    def consistent? = violation.nil?
-
-    # @return [Agentilda::StateMachine] positioned at the current state
-    def machine = StateMachine.new(self)
-
-    # @return [Array<Symbol>] states reachable right now, guards applied
-    def allowed = machine.allowed
-
-    # @return [Agentilda::Status, nil] the state these contents justify
-    def best_fit = machine.best_fit
-
-    # Move the folder into +status+ — the side effect a transition *is*.
-    #
-    # The {Feature} is a frozen `Data` holding the old name, so it is replaced
-    # rather than mutated, and the memoized reads go with it.
-    #
-    # @param status [Agentilda::Status]
-    # @return [Agentilda::Feature] the feature under its new name
-    # @raise [Agentilda::Error] when the target name is already taken
-    def rename_to(status)
-      return @feature if status.key == @feature.status.key
-
-      target = File.join(File.dirname(@feature.path), @feature.dirname_as(status))
-      unless Agentilda.move_directory(@feature.path, target)
-        raise Error, "cannot rename #{@feature.dirname} — #{File.basename(target)} already exists"
-      end
-
-      @reads = {}
-      @pull_requests = nil
-      @feature = Feature.parse(target) or raise Error, "#{File.basename(target)} is not a plan folder"
-    end
-  end
-end

data/lib/agentilda/tally.rb

@@ -1,175 +0,0 @@
-# frozen_string_literal: true
-
-module Agentilda
-  # What a `run` cost, once it is over.
-  #
-  # The loop reports movement — which plan went from ⭐️ to 🟡, which agent
-  # failed and why — and says nothing about the bill. A round of five agents
-  # against a large repository spends several million tokens and the better
-  # part of an hour, and until this existed the only record of that was a
-  # directory of trace files nobody reads.
-  #
-  # {#render} returns a string and prints nothing, so the caller decides where
-  # it goes, the same way {Reporter} works.
-  class Tally
-    # One agent's share of the run, added up across every round it ran in.
-    #
-    # @!attribute [r] name
-    #   @return [String]
-    # @!attribute [r] invocations
-    #   @return [Integer] times this agent was started
-    # @!attribute [r] subagents
-    #   @return [Integer] sub-agents it spawned, across all of them
-    # @!attribute [r] up
-    #   @return [Integer] tokens sent, sub-agent spend included
-    # @!attribute [r] down
-    #   @return [Integer] tokens generated
-    # @!attribute [r] seconds
-    #   @return [Float] how long it was running, added up
-    Row = Data.define(:name, :invocations, :subagents, :up, :down, :seconds)
-
-    # Cells per column, so the header, the rows and the rule cannot drift.
-    WIDTHS = { name: 22, invocations: 6, subagents: 11, up: 9, down: 9, seconds: 8 }.freeze
-
-    # @param attempts [Array<Agentilda::Runner::Attempt>]
-    # @param seconds [Float] wall clock for the whole loop, which is not the
-    #   sum of the agents' own times: several of them run at once
-    # @param rounds [Integer, nil] accepted so an older caller still works, and
-    #   otherwise unused: the loop has no rounds of its own any more, each
-    #   agent counts its own per plan, so the summary counts invocations
-    def initialize(attempts:, seconds:, rounds: nil)
-      @attempts = attempts.reject { |a| a.ordinal == "?" }
-      @seconds = seconds
-      @rounds = rounds
-    end
-
-    # @return [Array<Agentilda::Runner::Attempt>]
-    attr_reader :attempts
-
-    # @return [Float] wall clock
-    attr_reader :seconds
-
-    # @return [Integer, nil]
-    attr_reader :rounds
-
-    # Plans an agent was actually started against, counted once each however
-    # many rounds they took.
-    #
-    # @return [Integer]
-    def plans = attempts.map(&:ordinal).uniq.size
-
-    # @return [Integer] tokens sent, everything included
-    def up = attempts.sum(&:up)
-
-    # @return [Integer] tokens generated
-    def down = attempts.sum(&:down)
-
-    # @return [Integer] sub-agents spawned by every agent in the run
-    def subagents = attempts.sum(&:subagents)
-
-    # Sub-agent spend that arrived as one number. `claude` reports what a
-    # sub-agent cost without splitting it between the two directions, so this
-    # much of {#up} is really up and down together.
-    #
-    # @return [Integer]
-    def delegated = attempts.sum(&:delegated)
-
-    # @return [Float] seconds of agent time, added up across all of them
-    def busy = attempts.sum(&:seconds)
-
-    # How many agents were running at any given moment, averaged over the
-    # run: agent-seconds divided by wall-clock seconds. Below the `-j` ceiling
-    # by however much the round spent waiting for its slowest member.
-    #
-    # @return [Float]
-    def concurrency = seconds.positive? ? busy / seconds : 0.0
-
-    # @return [Array<Agentilda::Tally::Row>] one per agent, dearest first
-    def by_agent
-      attempts.group_by(&:agent).map { |name, list|
-        Row.new(name:,
-          invocations: list.size,
-          subagents: list.sum(&:subagents),
-          up: list.sum(&:up),
-          down: list.sum(&:down),
-          seconds: list.sum(&:seconds))
-      }.sort_by { |row| -row.up }
-    end
-
-    # @return [String] the table and the summary line under it
-    def render
-      return summary if attempts.empty?
-
-      ([header, rule] + by_agent.map { |row| line(row) } + [rule, totals, "", summary]).join("\n")
-    end
-
-    # @return [String] the one-line version, for a box
-    def summary
-      [
-        "#{plans} plan#{"s" unless plans == 1} addressed",
-        "#{attempts.size} invocation#{"s" unless attempts.size == 1}",
-        duration(seconds),
-        "#{format("%.1f", concurrency)} agents at a time",
-        "↑ #{UI.abbreviate(up)} ↓ #{UI.abbreviate(down)}"
-      ].join(" · ") + delegation
-    end
-
-    private
-
-    # @return [String] the caveat, where there is one to make
-    def delegation
-      return "" if delegated.zero?
-
-      "\n#{subagents} sub-agent#{"s" unless subagents == 1} reported #{UI.abbreviate(delegated)} " \
-        "tokens without splitting them, counted above as ↑."
-    end
-
-    # @return [String]
-    def header
-      cell("Agent", :name) + %i[invocations subagents up down seconds]
-                             .zip(["runs", "sub-agents", "↑", "↓", "time"])
-                             .map { |key, text| right(text, key) }.join
-    end
-
-    # @return [String]
-    def rule = WIDTHS.values.map { |width| ("─" * (width - 1)) + " " }.join
-
-    # @param row [Agentilda::Tally::Row]
-    # @return [String]
-    def line(row)
-      cell(row.name, :name) + right(row.invocations.to_s, :invocations) +
-        right(row.subagents.to_s, :subagents) + right(UI.abbreviate(row.up), :up) +
-        right(UI.abbreviate(row.down), :down) + right(duration(row.seconds), :seconds)
-    end
-
-    # @return [String]
-    def totals
-      cell("", :name) + right(attempts.size.to_s, :invocations) + right(subagents.to_s, :subagents) +
-        right(UI.abbreviate(up), :up) + right(UI.abbreviate(down), :down) + right(duration(busy), :seconds)
-    end
-
-    # @param text [String]
-    # @param key [Symbol]
-    # @return [String] padded to its column, left-justified
-    def cell(text, key) = UI.fit(text, WIDTHS.fetch(key))
-
-    # @param text [String]
-    # @param key [Symbol]
-    # @return [String] padded to its column, right-justified
-    def right(text, key)
-      width = WIDTHS.fetch(key) - 1
-      text = UI.fit(text, width).rstrip
-      UI.fit("", width - UI.display_width(text)) + text + " "
-    end
-
-    # @param seconds [Numeric]
-    # @return [String] e.g. "42s", "12m40s", "1h04m"
-    def duration(seconds)
-      total = seconds.to_i
-      return "#{total}s" if total < 60
-      return "#{total / 60}m#{format("%02ds", total % 60)}" if total < 3600
-
-      "#{total / 3600}h#{format("%02dm", (total % 3600) / 60)}"
-    end
-  end
-end