agentilda 1.0.3 → 2.0.1

data/lib/agentilda/status.rb

@@ -55,6 +55,12 @@ module Agentilda
   # 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.
   #
@@ -135,22 +141,51 @@ module Agentilda
   # 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",
+      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",
+      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: :planned, emoji: "⭐️", label: "Planned", requires: %w[spec.md plan.md],
-      note: "specified and planned; nobody has started building",
-      invariant: nil
+      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
@@ -162,9 +197,15 @@ module Agentilda
     # 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: nil
+      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.
@@ -172,28 +213,46 @@ module Agentilda
     # 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: nil
+      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",
+      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",
+      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",
+      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",
+      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?
 
@@ -202,41 +261,62 @@ module Agentilda
       }
     ),
     Status.new(
-      key: :deployed, emoji: "😎", label: "Deployed", requires: %w[deployed.md],
-      note: "live in production; `deployed.md` names the release, date and SHA",
+      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",
+      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",
+      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",
+      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",
+      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",
+      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",
+      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")
 
@@ -244,8 +324,11 @@ module Agentilda
       }
     ),
     Status.new(
-      key: :discarded, emoji: "❌", label: "Discarded", requires: %w[discarded.md],
-      note: "dropped for good; `discarded.md` says why. A terminal state",
+      key:       :discarded,
+      emoji:     "❌",
+      label:     "Discarded",
+      requires:  %w[discarded.md],
+      note:      "dropped for good; `discarded.md` says why. A terminal state",
       invariant: nil
     )
   ].freeze

data/lib/agentilda/subject.rb

@@ -0,0 +1,133 @@
+# 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

@@ -29,13 +29,15 @@ module Agentilda
     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
+    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]
-    def initialize(attempts:, seconds:, rounds: 0)
+    # @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
@@ -47,7 +49,7 @@ module Agentilda
     # @return [Float] wall clock
     attr_reader :seconds
 
-    # @return [Integer]
+    # @return [Integer, nil]
     attr_reader :rounds
 
     # Plans an agent was actually started against, counted once each however
@@ -85,8 +87,12 @@ module Agentilda
     # @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))
+        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
 
@@ -101,7 +107,7 @@ module Agentilda
     def summary
       [
         "#{plans} plan#{"s" unless plans == 1} addressed",
-        "#{rounds} round#{"s" unless rounds == 1}",
+        "#{attempts.size} invocation#{"s" unless attempts.size == 1}",
         duration(seconds),
         "#{format("%.1f", concurrency)} agents at a time",
         "↑ #{UI.abbreviate(up)} ↓ #{UI.abbreviate(down)}"
@@ -115,18 +121,18 @@ module Agentilda
       return "" if delegated.zero?
 
       "\n#{subagents} sub-agent#{"s" unless subagents == 1} reported #{UI.abbreviate(delegated)} " \
-      "tokens without splitting them, counted above as ↑."
+        "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
+                             .zip(["runs", "sub-agents", "↑", "↓", "time"])
+                             .map { |key, text| right(text, key) }.join
     end
 
     # @return [String]
-    def rule = WIDTHS.values.map { |width| "─" * (width - 1) + " " }.join
+    def rule = WIDTHS.values.map { |width| ("─" * (width - 1)) + " " }.join
 
     # @param row [Agentilda::Tally::Row]
     # @return [String]

data/lib/agentilda/transcript.rb

@@ -47,8 +47,11 @@ module Agentilda
     # @!attribute [r] pid
     #   @return [Integer, nil] the `claude` process, once the harness has
     #     found it — nil until then, and for callers that never look
-    Progress = Data.define(:activity, :up, :down, :subagents, :pid) do
-      def initialize(pid: nil, **rest) = super
+    # @!attribute [r] message
+    #   @return [String, nil] the last thing the agent chose to say directly,
+    #     via `SendUserMessage`, or nil if it never sent one
+    Progress = Data.define(:activity, :up, :down, :subagents, :pid, :message) do
+      def initialize(pid: nil, message: nil, **rest) = super
     end
 
     # The one kind of line the trace does not keep.
@@ -62,8 +65,10 @@ module Agentilda
     # which is what makes it complete when the process dies mid-invocation.
     DELTA_NOISE = '"content_block_delta"'
 
-    # Longest phrase a spinner line can carry without wrapping into the next.
-    LIMIT = 56
+    # Longest phrase kept. A sanity cap, not a layout rule: each place that
+    # draws a phrase cuts it to the room it has, and the dashboard has most
+    # of a terminal's width.
+    LIMIT = 300
 
     # How each tool reads as something being done, rather than as a tool name.
     # A spinner says what is happening; "Edit" is a noun and says nothing.
@@ -72,7 +77,8 @@ module Agentilda
       "MultiEdit" => "editing", "NotebookEdit" => "editing",
       "Bash" => "running", "Grep" => "searching for", "Glob" => "looking for",
       "Task" => "delegating", "TodoWrite" => "planning",
-      "WebFetch" => "fetching", "WebSearch" => "searching the web for"
+      "WebFetch" => "fetching", "WebSearch" => "searching the web for",
+      "SendUserMessage" => "saying"
     }.freeze
 
     # The input key worth naming, per tool, in the order we would rather say it.
@@ -92,12 +98,13 @@ module Agentilda
       @buffer = +""
       @plain = []
       @activity = nil
+      @message = nil
       @result = nil
       @error = nil
       @trace_path = trace
       @trace = trace && File.open(trace, "a")
       @tools = 0
-      @main = {up: 0, down: 0}
+      @main = { up: 0, down: 0 }
       @streamed = {}
       @tasks = {}
       @spawned = 0
@@ -132,11 +139,11 @@ module Agentilda
     # @return [Integer]
     def delegated
       @tasks.reject { |_, task| @streamed.key?(task[:tool_use_id]) }
-        .sum { |_, task| task[:total] }
+            .sum { |_, task| task[:total] }
     end
 
     # @return [Agentilda::Transcript::Progress] a snapshot, safe to keep
-    def progress = Progress.new(activity: @activity, up:, down:, subagents: @spawned, pid: @pid)
+    def progress = Progress.new(activity: @activity, up:, down:, subagents: @spawned, pid: @pid, message: @message)
 
     # @return [Integer] how many tool calls have gone past, which is the one
     #   honest measure of how much work an agent that says "done" actually did
@@ -148,6 +155,9 @@ module Agentilda
     # @return [String, nil] the last thing the agent was seen doing
     attr_reader :activity
 
+    # @return [String, nil] the last thing the agent sent via `SendUserMessage`
+    attr_reader :message
+
     # @return [String, nil] the final text, from the `result` event
     attr_reader :result
 
@@ -228,6 +238,7 @@ module Agentilda
     def handle(event)
       case event["type"]
       when "assistant"
+        capture_message(event)
         @tools += tool_calls(event)
         announce(phrase_for(event))
       when "stream_event" then meter(event)
@@ -236,6 +247,24 @@ module Agentilda
       end
     end
 
+    # `--brief` gives the agent SendUserMessage, and what it sends is the
+    # one line on the screen the agent itself chose. It outranks the tool
+    # phrase until the agent sends another.
+    #
+    # @param event [Hash]
+    # @return [void]
+    def capture_message(event)
+      blocks = event.dig("message", "content")
+      return unless blocks.is_a?(Array)
+
+      blocks.each do |block|
+        next unless block.is_a?(Hash) && block["type"] == "tool_use" && block["name"] == "SendUserMessage"
+
+        text = block.dig("input", "message").to_s.strip
+        @message = clip(text) unless text.empty?
+      end
+    end
+
     # @param event [Hash]
     # @return [Integer] how many tools this one message called
     def tool_calls(event)
@@ -264,7 +293,8 @@ module Agentilda
 
       usage = event.dig("event", "usage") or return
       bucket = bucket_for(event["parent_tool_use_id"])
-      bucket[:up] += usage.values_at("input_tokens", "cache_creation_input_tokens",
+      bucket[:up] += usage.values_at("input_tokens",
+        "cache_creation_input_tokens",
         "cache_read_input_tokens").compact.sum
       bucket[:down] += usage["output_tokens"].to_i
       publish
@@ -275,12 +305,12 @@ module Agentilda
     def bucket_for(parent)
       return @main if parent.nil?
 
-      @streamed[parent] ||= {up: 0, down: 0}
+      @streamed[parent] ||= { up: 0, down: 0 }
     end
 
     # @return [Hash] every streamed sub-agent's counters, added together
     def streamed
-      @streamed.values.each_with_object({up: 0, down: 0}) do |b, sum|
+      @streamed.values.each_with_object({ up: 0, down: 0 }) do |b, sum|
         sum[:up] += b[:up]
         sum[:down] += b[:down]
       end
@@ -309,7 +339,7 @@ module Agentilda
     def start_task(event)
       id = event["task_id"] or return
 
-      @tasks[id] ||= {tool_use_id: event["tool_use_id"], total: 0}
+      @tasks[id] ||= { tool_use_id: event["tool_use_id"], total: 0 }
       @spawned = @tasks.size
       publish
     end
@@ -319,7 +349,7 @@ module Agentilda
     def update_task(event)
       id = event["task_id"] or return
 
-      task = (@tasks[id] ||= {tool_use_id: event["tool_use_id"], total: 0})
+      task = (@tasks[id] ||= { tool_use_id: event["tool_use_id"], total: 0 })
       task[:tool_use_id] ||= event["tool_use_id"]
       task[:total] = event.dig("usage", "total_tokens").to_i
       @spawned = @tasks.size
@@ -386,7 +416,7 @@ module Agentilda
     # @return [String]
     def noun(key, value)
       text = value.to_s.strip.tr("\n", " ").squeeze(" ")
-      (key == "file_path") ? File.basename(text) : text
+      key == "file_path" ? File.basename(text) : text
     end
 
     # The agent's own narration, first sentence only. Everything after it is
@@ -402,7 +432,7 @@ module Agentilda
 
     # @param text [String]
     # @return [String]
-    def clip(text) = (text.length > LIMIT) ? "#{text[0, LIMIT - 1]}…" : text
+    def clip(text) = text.length > LIMIT ? "#{text[0, LIMIT - 1]}…" : text
 
     # @param usage [Hash, nil] the `result` event's own accounting
     # @return [void]
@@ -410,7 +440,8 @@ module Agentilda
       return unless usage.is_a?(Hash)
 
       @main = {
-        up: usage.values_at("input_tokens", "cache_creation_input_tokens",
+        up:   usage.values_at("input_tokens",
+          "cache_creation_input_tokens",
           "cache_read_input_tokens").compact.sum,
         down: usage["output_tokens"].to_i
       }

data/lib/agentilda/tree.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require "agentilda/feature"
+require "agentilda/ordinal"
+require "agentilda/subject"
+
 module Agentilda
   # A project's `.plans` directory: the folders in it, decoded and ordered.
   class Tree
@@ -38,8 +42,8 @@ module Agentilda
     # @return [Hash{Agentilda::Ordinal => Array<String>}] number => dirnames
     def duplicates
       features.group_by(&:ordinal)
-        .select { |_, group| group.size > 1 }
-        .transform_values { |group| group.map(&:dirname) }
+              .select { |_, group| group.size > 1 }
+              .transform_values { |group| group.map(&:dirname) }
     end
 
     # @param ordinal [Agentilda::Ordinal, String]
@@ -68,10 +72,10 @@ module Agentilda
       return [] unless exist?
 
       Dir.children(dir)
-        .map { |c| File.join(dir, c) }
-        .select { |p| File.directory?(p) }
-        .reject { |p| File.basename(p).start_with?(".") }
-        .sort
+         .map { |c| File.join(dir, c) }
+         .select { |p| File.directory?(p) }
+         .reject { |p| File.basename(p).start_with?(".") }
+         .sort
     end
   end
 end