agentilda 1.0.3 → 2.0.1

data/lib/agentilda/ledger.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Agentilda
+  # The dated notes an agent leaves in the document it owns.
+  #
+  # This is the only place in the codebase that knows the syntax. The
+  # dispatcher reads it to learn whether an agent finished and who it named
+  # next; the state file records it; the screen paints it. An agent writes
+  # one entry when it starts and one when it stops, in a GitHub NOTE alert,
+  # one entry per line:
+  #
+  #   > [!NOTE]
+  #   >
+  #   > [2026-09-04 11:29:20 AM PDT] [ agent: leah-researcher   status: Started, round 1 ]
+  #   > [2026-09-04 11:44:03 AM PDT] [ agent: leah-researcher   status: Completed, round 1 ]
+  #   > [2026-09-04 11:44:04 AM PDT] [ next: yoda-writer ]
+  #
+  # The verbs are a closed set. A line that looks like an entry but does not
+  # parse is reported as a {Problem}, never dropped, because an agent that
+  # wrote "Done" has said nothing the harness can act on and silence would
+  # read as a stall.
+  module Ledger
+    # Everything an agent may claim. `Completed` is the only verb a `next:`
+    # line may follow.
+    STATUSES = ["Started", "Completed", "Almost completed", "Interrupted", "Blocked"].freeze
+
+    # Local time with the zone spelled out, so an entry written on one
+    # machine reads correctly on another.
+    TIME_FORMAT = "%Y-%m-%d %I:%M:%S %p %Z"
+
+    # An entry. `**` around the status is how the harness marks the one line
+    # it writes itself, the Interrupted that precedes a signature.
+    ENTRY = /\A>\s*\[(?<at>[^\]]+)\]\s*\[\s*agent:\s*(?<agent>[\w-]+)\s+status:\s*(?<bold>\*\*)?
+      (?<status>#{STATUSES.map { |s| Regexp.escape(s) }.join("|")}),\s*round\s*(?<round>\d+)
+      (?:\s*\((?<note>[^)]*)\))?\s*(?:\*\*)?\s*\]\s*\z/x
+
+    # The handoff line.
+    NEXT = /\A>\s*\[(?<at>[^\]]+)\]\s*\[\s*next:\s*(?<next>[\w-]+)\s*\]\s*\z/
+
+    # A line that is trying to be one of the two above. Anything matching
+    # this and neither of those is a {Problem}.
+    ATTEMPT = /\A>\s*\[[^\]]+\]\s*\[/
+
+    # The whole alert block, for {.stripped}.
+    BLOCK = /^[ \t]*>[ \t]*\[!NOTE\][ \t]*\n(?:[ \t]*>.*\n?)*/
+
+    # @!attribute [r] at
+    #   @return [Time]
+    # @!attribute [r] agent
+    #   @return [String] the definition's name, `leah-researcher`
+    # @!attribute [r] status
+    #   @return [String] one of {STATUSES}
+    # @!attribute [r] round
+    #   @return [Integer]
+    # @!attribute [r] note
+    #   @return [String, nil] the parenthesised tail, `rejected 1/2`
+    # @!attribute [r] file
+    #   @return [String] the document it was read from
+    # @!attribute [r] line
+    #   @return [Integer] 1-based
+    # @!attribute [r] bold
+    #   @return [Boolean] written `**bold**`, which only the harness does
+    Entry = Data.define(:at, :agent, :status, :round, :note, :file, :line, :bold) do
+      def initialize(note: nil, bold: false, **rest) = super
+
+      # @return [Boolean]
+      def completed? = status == "Completed"
+
+      # @return [Boolean] whether the agent gets another round
+      def retry? = ["Almost completed", "Interrupted"].include?(status)
+
+      # @return [Boolean]
+      def blocked? = status == "Blocked"
+    end
+
+    # @!attribute [r] next
+    #   @return [String] the agent named
+    Handoff = Data.define(:at, :next, :file, :line)
+
+    # @!attribute [r] text
+    #   @return [String] the line as written
+    Problem = Data.define(:file, :line, :text)
+
+    # What one read of a plan folder yielded.
+    Reading = Data.define(:entries, :handoffs, :problems) do
+      # @return [Agentilda::Ledger::Reading]
+      def self.empty = new(entries: [], handoffs: [], problems: [])
+
+      # @param other [Agentilda::Ledger::Reading]
+      # @return [Agentilda::Ledger::Reading]
+      def +(other)
+        self.class.new(entries: entries + other.entries,
+          handoffs: handoffs + other.handoffs,
+          problems: problems + other.problems)
+      end
+    end
+
+    class << self
+      # @param text [String] a whole document
+      # @param file [String] its name, carried on every entry
+      # @return [Agentilda::Ledger::Reading]
+      def parse(text, file:)
+        entries = []
+        handoffs = []
+        problems = []
+        text.to_s.each_line.with_index(1) do |raw, line|
+          stripped = raw.chomp
+          if (m = ENTRY.match(stripped))
+            entries << Entry.new(at: parse_time(m[:at]),
+              agent: m[:agent],
+              status: m[:status],
+              round: m[:round].to_i,
+              note: m[:note]&.strip,
+              file:,
+              line:,
+              bold: !m[:bold].nil?)
+          elsif (m = NEXT.match(stripped))
+            handoffs << Handoff.new(at: parse_time(m[:at]), next: m[:next], file:, line:)
+          elsif ATTEMPT.match?(stripped)
+            problems << Problem.new(file:, line:, text: stripped.strip)
+          end
+        end
+        Reading.new(entries:, handoffs:, problems:)
+      end
+
+      # Every document an agent may sign, in the order its definition lists
+      # them. A missing file is not a problem; an agent that has not reached
+      # `pull-requests.md` yet has not written it.
+      #
+      # @param dir [String] the plan folder
+      # @param files [Array<String>]
+      # @return [Agentilda::Ledger::Reading]
+      def read(dir, files)
+        files.each_with_index.reduce(Reading.empty) do |reading, (name, _index)|
+          path = File.join(dir, name)
+          next reading unless File.file?(path)
+
+          found = parse(File.read(path, encoding: "UTF-8"), file: name)
+          reading + Reading.new(entries: found.entries.map { |e| e.with(file: name) },
+            handoffs: found.handoffs,
+            problems: found.problems)
+        end
+      end
+
+      # @param time [Time]
+      # @return [String]
+      def timestamp(time = Time.now) = time.strftime(TIME_FORMAT)
+
+      # Agents write what `date` prints, and `Time.strptime` cannot read a
+      # zone abbreviation back into an offset. The abbreviation is dropped
+      # and the time read as local, which is right on the machine that wrote
+      # it and off by a zone anywhere else, which the tick tolerates: entries
+      # are compared with each other, never with the wall clock.
+      #
+      # @param text [String]
+      # @return [Time]
+      def parse_time(text)
+        Time.strptime(text.to_s.strip.sub(/\s+[A-Z]{2,5}\z/, ""), "%Y-%m-%d %I:%M:%S %p")
+      rescue ArgumentError
+        Time.at(0)
+      end
+
+      # @param entry [Agentilda::Ledger::Entry]
+      # @return [String] one quoted line, no newline
+      def render(entry)
+        tail = entry.note ? " (#{entry.note})" : ""
+        body = "#{entry.status}, round #{entry.round}#{tail}"
+        body = "**#{body}**" if entry.bold
+        "> [#{timestamp(entry.at)}] [ agent: #{entry.agent}   status: #{body} ]"
+      end
+
+      # @param handoff [Agentilda::Ledger::Handoff]
+      # @return [String]
+      def render_handoff(handoff) = "> [#{timestamp(handoff.at)}] [ next: #{handoff.next} ]"
+
+      # @param lines [Array<String>] already quoted
+      # @return [String] a NOTE alert, newline-terminated
+      def block(*lines) = (["> [!NOTE]", ">"] + lines.flatten).join("\n") + "\n"
+
+      # Append one block. Separated from what is there by a blank line so the
+      # alert renders as its own block rather than merging into a paragraph.
+      #
+      # @param path [String]
+      # @param lines [Array<String>]
+      # @return [void]
+      def append(path, *lines)
+        existing = File.file?(path) ? File.read(path, encoding: "UTF-8") : ""
+        glue = if existing.empty?
+                 ""
+               elsif existing.end_with?("\n\n")
+                 ""
+               elsif existing.end_with?("\n")
+                 "\n"
+               else
+                 "\n\n"
+               end
+        File.write(path, existing + glue + block(*lines))
+      end
+
+      # The entry that tells the harness where this agent stands: the latest
+      # by clock, then by the order its documents are listed, then by line.
+      #
+      # @param reading [Agentilda::Ledger::Reading]
+      # @param agent [String]
+      # @return [Agentilda::Ledger::Entry, nil]
+      def last_for(reading, agent)
+        files = reading.entries.map(&:file).uniq
+        reading.entries.select { |e| e.agent == agent }
+               .max_by { |e| [e.at, files.index(e.file), e.line] }
+      end
+
+      # The `next:` that belongs to an entry: same file, a later line, and no
+      # other entry between the two. A handoff written under somebody else's
+      # entry is not this agent's handoff.
+      #
+      # @param reading [Agentilda::Ledger::Reading]
+      # @param entry [Agentilda::Ledger::Entry]
+      # @return [Agentilda::Ledger::Handoff, nil]
+      def handoff_after(reading, entry)
+        candidates = reading.handoffs.select { |h| h.file == entry.file && h.line > entry.line }
+        handoff = candidates.min_by(&:line) or return nil
+        between = reading.entries.any? { |e| e.file == entry.file && e.line > entry.line && e.line < handoff.line }
+        between ? nil : handoff
+      end
+
+      # @param text [String]
+      # @return [String] the document without its ledger blocks
+      def stripped(text) = text.to_s.gsub(BLOCK, "")
+    end
+  end
+end

data/lib/agentilda/linear/api.rb

@@ -32,8 +32,9 @@ module Agentilda
         @endpoint = endpoint
         return if transport || (token && !token.empty?)
 
-        raise Error, "no Linear token. Set #{TOKEN_VARIABLE}, or use the MCP transport:\n  " \
-                     "agentilda linear import <TEAM> -p <PROJECT> --format json"
+        raise Error,
+          "no Linear token. Set #{TOKEN_VARIABLE}, or use the MCP transport:\n  " \
+          "agentilda linear import <TEAM> -p <PROJECT> --format json"
       end
 
       # The team, its workflow states and its labels, in one round trip.
@@ -45,8 +46,8 @@ module Agentilda
         node = query(TEAM, key: key.to_s.upcase).dig("teams", "nodes")&.first
         raise Error, "no Linear team has the key #{key.to_s.upcase}" unless node
 
-        {id: node["id"], name: node["name"], key: node["key"],
-         states: node.dig("states", "nodes").to_a, labels: node.dig("labels", "nodes").to_a}
+        { id: node["id"], name: node["name"], key: node["key"],
+         states: node.dig("states", "nodes").to_a, labels: node.dig("labels", "nodes").to_a }
       end
 
       # @param team_id [String]
@@ -75,7 +76,7 @@ module Agentilda
       # @param team_id [String]
       # @return [Hash] `{id:, name:}`
       def create_label(name, team_id)
-        unwrap(query(LABEL_CREATE, input: {name:, teamId: team_id}), "issueLabelCreate", "issueLabel")
+        unwrap(query(LABEL_CREATE, input: { name:, teamId: team_id }), "issueLabelCreate", "issueLabel")
       end
 
       # @param issue_id [String]
@@ -83,7 +84,7 @@ module Agentilda
       # @param title [String]
       # @return [void]
       def link(issue_id:, url:, title:)
-        query(ATTACHMENT_CREATE, input: {issueId: issue_id, url:, title:})
+        query(ATTACHMENT_CREATE, input: { issueId: issue_id, url:, title: })
       end
 
       # @param query [String] a GraphQL document
@@ -139,8 +140,11 @@ module Agentilda
         request["Authorization"] = token
         request.body = JSON.generate(query: document, variables:)
 
-        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https",
-          open_timeout: 10, read_timeout: 30) { |http| http.request(request) }
+        response = Net::HTTP.start(uri.hostname,
+          uri.port,
+          use_ssl:      uri.scheme == "https",
+          open_timeout: 10,
+          read_timeout: 30) { |http| http.request(request) }
 
         parse(response)
       rescue JSON::ParserError, IOError, SystemCallError, Net::OpenTimeout, Net::ReadTimeout => e
@@ -153,8 +157,8 @@ module Agentilda
         return JSON.parse(response.body.to_s) if response.is_a?(Net::HTTPSuccess)
 
         hint = if ["400", "401"].include?(response.code)
-          "\n\nCheck #{TOKEN_VARIABLE}. A personal API key is sent verbatim, without a `Bearer` prefix."
-        end
+                 "\n\nCheck #{TOKEN_VARIABLE}. A personal API key is sent verbatim, without a `Bearer` prefix."
+               end
         raise Error, "Linear returned HTTP #{response.code}#{hint}"
       end
 

data/lib/agentilda/linear/attribution.rb

@@ -75,7 +75,7 @@ module Agentilda
       MINIMUM_WORDS = 3
 
       NOISE = %w[the and for with from into that this add adds added fix fixes
-        update updates use uses spec plan pull request pr tax app web api].freeze
+                 update updates use uses spec plan pull request pr tax app web api].freeze
 
       # @param tree [Agentilda::Tree]
       def initialize(tree:)
@@ -113,9 +113,9 @@ module Agentilda
       # @return [Array<String>]
       def opening_words(body)
         text = body.to_s
-          .gsub(/<!--.*?-->/m, "")
-          .gsub(/```.*?```/m, "")
-          .gsub(/^\s*[-*|#>]+/, " ")
+                   .gsub(/<!--.*?-->/m, "")
+                   .gsub(/```.*?```/m, "")
+                   .gsub(/^\s*[-*|#>]+/, " ")
         words(text.split(/\s+/).first(OPENING_WORDS * 3).join(" ")).first(OPENING_WORDS)
       end
 
@@ -161,7 +161,7 @@ module Agentilda
       # @return [Array<String>]
       def words(text)
         text.to_s.downcase.gsub(/[^a-z0-9]+/, " ").split
-          .reject { |w| w.length < 4 || NOISE.include?(w) }.uniq
+            .reject { |w| w.length < 4 || NOISE.include?(w) }.uniq
       end
 
       # How much of a folder's name a pull request title actually said.

data/lib/agentilda/linear/import.rb

@@ -41,7 +41,7 @@ module Agentilda
 
       # @return [Hash] for `--format json`
       def to_h_json
-        {kind:, op:, plan: ordinal, unit:, identifier:, title:, digest:, args:}.compact
+        { kind:, op:, plan: ordinal, unit:, identifier:, title:, digest:, args: }.compact
       end
     end
 
@@ -103,7 +103,7 @@ module Agentilda
       # @return [Hash{Agentilda::Status => Array<String>}] state => ordinals
       def unplaced
         @unplaced ||= (chosen - subjects).group_by(&:status)
-          .transform_values { |group| group.map { |s| s.feature.ordinal.to_s } }
+                                         .transform_values { |group| group.map { |s| s.feature.ordinal.to_s } }
       end
 
       private
@@ -152,8 +152,10 @@ module Agentilda
       # @param pull [Agentilda::PullRequest]
       # @return [Agentilda::Linear::Unit]
       def adopted_unit(pull)
-        Unit.new(key: "##{pull.number}", title: Units.clean_title(pull.title),
-          body: "", pull_requests: [pull])
+        Unit.new(key: "##{pull.number}",
+          title: Units.clean_title(pull.title),
+          body: "",
+          pull_requests: [pull])
       end
 
       # @param subject [Agentilda::Subject]
@@ -175,15 +177,22 @@ module Agentilda
         recorded = record_for(subject).by_unit[Issues::PARENT]
         title = plan_title(subject)
 
-        args = {team:, project: project_name, title:, description: plan_description(subject),
-                state: placement.name, labels: placement.labels}
+        args = { team:, project: project_name, title:, description: plan_description(subject),
+                state: placement.name, labels: placement.labels }
         digest = Issues.digest(args)
 
         op, reason = decide(recorded&.identifier, recorded&.digest, digest)
         args = args.merge(id: recorded.identifier).except(:team, :project) if op == :update && recorded
 
-        Action.new(kind: :issue, op:, ordinal: subject.feature.ordinal.to_s, unit: Issues::PARENT,
-          identifier: recorded&.identifier, title:, digest:, args:, reason:)
+        Action.new(kind: :issue,
+          op:,
+          ordinal: subject.feature.ordinal.to_s,
+          unit: Issues::PARENT,
+          identifier: recorded&.identifier,
+          title:,
+          digest:,
+          args:,
+          reason:)
       end
 
       # @param subject [Agentilda::Subject]
@@ -194,17 +203,24 @@ module Agentilda
         recorded = record_for(subject).by_unit[unit.key]
         parent = record_for(subject).by_unit[Issues::PARENT]
 
-        args = {team:, project: project_name, title: unit.title,
+        args = { team:, project: project_name, title: unit.title,
                 description: unit_description(subject, unit),
-                state: placement.name, labels: placement.labels, links: links_for(unit)}
+                state: placement.name, labels: placement.labels, links: links_for(unit) }
         args = args.merge(parentId: parent.identifier) if parent
         digest = Issues.digest(args.except(:parentId))
 
         op, reason = decide(recorded&.identifier, recorded&.digest, digest)
         args = args.merge(id: recorded.identifier).except(:team, :project) if op == :update && recorded
 
-        Action.new(kind: :subissue, op:, ordinal: subject.feature.ordinal.to_s, unit: unit.key,
-          identifier: recorded&.identifier, title: unit.title, digest:, args:, reason:)
+        Action.new(kind: :subissue,
+          op:,
+          ordinal: subject.feature.ordinal.to_s,
+          unit: unit.key,
+          identifier: recorded&.identifier,
+          title: unit.title,
+          digest:,
+          args:,
+          reason:)
       end
 
       # The three-way decision, in one place so a plan and a unit cannot
@@ -271,7 +287,7 @@ module Agentilda
       # @param unit [Agentilda::Linear::Unit]
       # @return [Array<Hash>]
       def links_for(unit)
-        unit.pull_requests.select(&:url).map { |pr| {url: pr.url, title: pr.label} }
+        unit.pull_requests.select(&:url).map { |pr| { url: pr.url, title: pr.label } }
       end
 
       # A plan section can run to several hundred lines of design notes and
@@ -291,7 +307,7 @@ module Agentilda
       # @return [String]
       def provenance
         "_Imported by `agentilda linear import`. The plan folder is the source of truth; " \
-        "edits made here do not travel back._"
+          "edits made here do not travel back._"
       end
     end
   end

data/lib/agentilda/linear/issue.rb

@@ -164,9 +164,12 @@ module Agentilda
         identifier = (link ? link[1] : cell["issue"]).gsub(/[*_`]/, "").strip
         return nil if identifier.empty?
 
-        Issue.new(unit: cell["unit"].strip, identifier:, url: link && link[2],
+        Issue.new(unit: cell["unit"].strip,
+          identifier:,
+          url: link && link[2],
           title: cell["title"].gsub(/\\([|\\])/, '\1').strip,
-          state: cell["state"].strip, digest: cell["synced"].gsub(/[`\s]/, ""))
+          state: cell["state"].strip,
+          digest: cell["synced"].gsub(/[`\s]/, ""))
       end
 
       # @return [Hash, nil]
@@ -177,7 +180,7 @@ module Agentilda
         link = line.match(/project\s+\[([^\]]+)\]\((\S+?)\)/i)
         return nil unless link
 
-        {name: link[1].strip.gsub(/\\([|\\])/, '\1'), url: link[2]}
+        { name: link[1].strip.gsub(/\\([|\\])/, '\1'), url: link[2] }
       end
     end
   end

data/lib/agentilda/linear/mapping.rb

@@ -39,24 +39,25 @@ module Agentilda
     # nothing here changes, and its plans quietly import as Backlog with no
     # indication anything was missed.
     PLACEMENTS = {
-      new: Placement.new(type: "backlog", name: "Backlog", labels: []),
-      researched: Placement.new(type: "backlog", name: "Backlog", labels: %w[researched]),
-      planned: Placement.new(type: "unstarted", name: "Todo", labels: []),
-      building: Placement.new(type: "started", name: "In Progress", labels: []),
+      new:                Placement.new(type: "backlog", name: "Backlog", labels: []),
+      researched:         Placement.new(type: "backlog", name: "Backlog", labels: %w[researched]),
+      ready_for_planning: Placement.new(type: "backlog", name: "Backlog", labels: %w[spec-ready]),
+      planned:            Placement.new(type: "unstarted", name: "Todo", labels: []),
+      building:           Placement.new(type: "started", name: "In Progress", labels: []),
       # Both halves of building are one column on a board. A reader there
       # wants to know work is under way; which half is under way is this
       # tool's business, and the label carries it for anyone who does care.
-      building_ui: Placement.new(type: "started", name: "In Progress", labels: %w[frontend]),
-      ready_for_review: Placement.new(type: "started", name: "In Review", labels: []),
-      in_review: Placement.new(type: "started", name: "In Review", labels: []),
-      rejected: Placement.new(type: "started", name: "In Review", labels: %w[changes-requested]),
-      approved: Placement.new(type: "completed", name: "Done", labels: []),
-      deployed: Placement.new(type: "completed", name: "Done", labels: %w[deployed]),
-      blocked: Placement.new(type: "unstarted", name: "Todo", labels: %w[blocked]),
-      product_blocked: Placement.new(type: "unstarted", name: "Todo", labels: %w[blocked-on-product]),
-      deferred: Placement.new(type: "backlog", name: "Backlog", labels: %w[deferred]),
-      retroactive: Placement.new(type: "completed", name: "Done", labels: %w[retroactive]),
-      discarded: Placement.new(type: "canceled", name: "Canceled", labels: [])
+      building_ui:        Placement.new(type: "started", name: "In Progress", labels: %w[frontend]),
+      ready_for_review:   Placement.new(type: "started", name: "In Review", labels: []),
+      in_review:          Placement.new(type: "started", name: "In Review", labels: []),
+      rejected:           Placement.new(type: "started", name: "In Review", labels: %w[changes-requested]),
+      approved:           Placement.new(type: "completed", name: "Done", labels: []),
+      deployed:           Placement.new(type: "completed", name: "Done", labels: %w[deployed]),
+      blocked:            Placement.new(type: "unstarted", name: "Todo", labels: %w[blocked]),
+      product_blocked:    Placement.new(type: "unstarted", name: "Todo", labels: %w[blocked-on-product]),
+      deferred:           Placement.new(type: "backlog", name: "Backlog", labels: %w[deferred]),
+      retroactive:        Placement.new(type: "completed", name: "Done", labels: %w[retroactive]),
+      discarded:          Placement.new(type: "canceled", name: "Canceled", labels: [])
     }.freeze
 
     # States deliberately left out, and why.
@@ -71,8 +72,8 @@ module Agentilda
     # A plan in one of these states is reported and skipped. To import them,
     # decide where they belong and move the entry into {PLACEMENTS}.
     UNPLACED = {
-      shit: "the plan survives and its pull requests do not; whether that is work still to do " \
-            "or work abandoned depends on what the team does next",
+      shit:        "the plan survives and its pull requests do not; whether that is work still to do " \
+                   "or work abandoned depends on what the team does next",
       rolled_back: "it shipped and was pulled; whether that reopens this work or opens new work " \
                    "depends on what broke"
     }.freeze

data/lib/agentilda/linear/push.rb

@@ -78,16 +78,18 @@ module Agentilda
       # @return [Agentilda::Linear::Result]
       def apply(action, subject, parent)
         if parent && !parent.ok?
-          return Result.new(action:, identifier: action.identifier, url: nil,
+          return Result.new(action:,
+            identifier: action.identifier,
+            url: nil,
             error: "the issue for its plan could not be created")
         end
 
         attempt(action) do
           node = case action.op
-          when :skip then recorded(action, subject)
-          when :update then attach(api.update_issue(action.args[:id], input(action, parent)), action)
-          else attach(api.create_issue(input(action, parent).merge(teamId: team[:id], projectId: project_id)), action)
-          end
+                 when :skip then recorded(action, subject)
+                 when :update then attach(api.update_issue(action.args[:id], input(action, parent)), action)
+                 else attach(api.create_issue(input(action, parent).merge(teamId: team[:id], projectId: project_id)), action)
+                 end
 
           [node["identifier"], node["url"]]
         end
@@ -100,8 +102,8 @@ module Agentilda
       # @param parent [Agentilda::Linear::Result, nil]
       # @return [Hash]
       def input(action, parent)
-        base = {title: action.args[:title], description: action.args[:description],
-                stateId: state_id(action.args[:state]), labelIds: label_ids(action.args[:labels])}.compact
+        base = { title: action.args[:title], description: action.args[:description],
+                stateId: state_id(action.args[:state]), labelIds: label_ids(action.args[:labels]) }.compact
         return base unless parent&.identifier
 
         base.merge(parentId: parent.identifier)
@@ -125,7 +127,7 @@ module Agentilda
       # @return [Hash]
       def recorded(action, subject)
         was = Issues.new(dir: subject.feature.path).by_unit[action.unit]
-        {"identifier" => was&.identifier || action.identifier, "url" => was&.url}
+        { "identifier" => was&.identifier || action.identifier, "url" => was&.url }
       end
 
       # A team names its own workflow states, so the name we would prefer is a
@@ -177,13 +179,18 @@ module Agentilda
       # @return [void]
       def record(subject, results)
         issues = results.select { |r| r.ok? && r.identifier }.map { |r|
-          Issue.new(unit: r.action.unit, identifier: r.identifier, url: r.url,
-            title: r.action.title, state: r.action.args[:state] || "", digest: r.action.digest)
+          Issue.new(unit: r.action.unit,
+            identifier: r.identifier,
+            url: r.url,
+            title: r.action.title,
+            state: r.action.args[:state] || "",
+            digest: r.action.digest)
         }
         return if issues.empty?
 
-        Issues.new(dir: subject.feature.path).write(team: import.team, issues:,
-          project: {name: import.project_name, url: import.project["url"]})
+        Issues.new(dir: subject.feature.path).write(team: import.team,
+          issues:,
+          project: { name: import.project_name, url: import.project["url"] })
       end
     end
   end

data/lib/agentilda/linear/survey.rb

@@ -22,7 +22,7 @@ module Agentilda
       # wrong plan is worse than one nobody adopted at all.
       Match = Data.define(:project, :subject, :rule) do
         # @return [String]
-        def why = {ordinal: "its name carries the plan number", slug: "its name is the plan's slug"}.fetch(rule)
+        def why = { ordinal: "its name carries the plan number", slug: "its name is the plan's slug" }.fetch(rule)
       end
 
       # @param tree [Agentilda::Tree]
@@ -102,7 +102,8 @@ module Agentilda
         }
         return found if found
 
-        raise Error, "no project matches #{reference.inspect}. This team has:\n" +
+        raise Error,
+          "no project matches #{reference.inspect}. This team has:\n" +
           projects.map { |p| "  #{p["name"]}\n    #{p["url"]}" }.join("\n")
       end
 

data/lib/agentilda/linear/unit.rb

@@ -93,10 +93,10 @@ module Agentilda
       # @return [String]
       def self.clean_title(title)
         title.to_s
-          .sub(/\A\[[^\]]*\]\s*/, "")
-          .sub(/\A(?:spec\s*)?\d{1,3}(?:\.\d{2})?\s*[—–:.-]?\s*/i, "")
-          .sub(/\APR[\s_-]?\d+(?:\.\d+)?\s*[—–:.-]?\s*/i, "")
-          .strip
+             .sub(/\A\[[^\]]*\]\s*/, "")
+             .sub(/\A(?:spec\s*)?\d{1,3}(?:\.\d{2})?\s*[—–:.-]?\s*/i, "")
+             .sub(/\APR[\s_-]?\d+(?:\.\d+)?\s*[—–:.-]?\s*/i, "")
+             .strip
       end
 
       private
@@ -260,14 +260,14 @@ module Agentilda
       # @return [String]
       def clean(title)
         title.to_s
-          .sub(/\A\([^)]*\)\s*/, "") # "(010a) — Per-person taxes" — a nickname, not a title
-          .sub(/\A[—–:.-]+\s*/, "")
-          .sub(GLYPH_NOTE, "")
-          .sub(TRAILING_GLYPH, "")
-          .gsub(/[*`]/, "") # before OWN_NUMBER: the number is often inside backticks
-          .sub(/\A_+/, "").sub(/_+\z/, "") # emphasis, but never `signed_off`
-          .sub(OWN_NUMBER, "")
-          .strip
+             .sub(/\A\([^)]*\)\s*/, "") # "(010a) — Per-person taxes" — a nickname, not a title
+             .sub(/\A[—–:.-]+\s*/, "")
+             .sub(GLYPH_NOTE, "")
+             .sub(TRAILING_GLYPH, "")
+             .gsub(/[*`]/, "") # before OWN_NUMBER: the number is often inside backticks
+             .sub(/\A_+/, "").sub(/_+\z/, "") # emphasis, but never `signed_off`
+             .sub(OWN_NUMBER, "")
+             .strip
       end
     end
   end

data/lib/agentilda/linear.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "agentilda/linear/mapping"
+
 module Agentilda
   # `.plans` as Linear projects and issues.
   #
@@ -31,12 +33,9 @@ module Agentilda
       key = prefix.to_s.strip.upcase
       return key if key.match?(KEY)
 
-      raise Error, "#{prefix.inspect} is not a Linear team key. A key is 2–10 characters, " \
-                   "letters and digits, as in TAX or ENG — the part before the dash in TAX-41."
+      raise Error,
+        "#{prefix.inspect} is not a Linear team key. A key is 2–10 characters, " \
+        "letters and digits, as in TAX or ENG — the part before the dash in TAX-41."
     end
   end
 end
-
-%w[mapping fuzzy unit issue survey attribution import api push].each do |part|
-  require File.join(__dir__, "linear", "#{part}.rb")
-end