agentilda 2.0.3 → 2.0.4

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: agentilda
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.0.4
 platform: ruby
 authors:
 - Konstantin Gredeskoul
@@ -294,12 +294,10 @@ files:
 - exe/tilda
 - exe/tilda-rs
 - lib/agentilda.rb
-- lib/agentilda/adoption.rb
-- lib/agentilda/agent.rb
 - lib/agentilda/agents.rb
-- lib/agentilda/board.rb
-- lib/agentilda/brief.rb
-- lib/agentilda/child.rb
+- lib/agentilda/agents/agent.rb
+- lib/agentilda/agents/registry.rb
+- lib/agentilda/agents/roster.rb
 - lib/agentilda/cli.rb
 - lib/agentilda/cli/agents/subcommands/describe.rb
 - lib/agentilda/cli/agents/subcommands/list.rb
@@ -321,24 +319,26 @@ files:
 - lib/agentilda/cli/unblock/unblock.rb
 - lib/agentilda/cli/version/version.rb
 - lib/agentilda/cli/worktree/worktree.rb
-- lib/agentilda/clock.rb
-- lib/agentilda/config.rb
-- lib/agentilda/console.rb
-- lib/agentilda/control.rb
-- lib/agentilda/creator.rb
-- lib/agentilda/dashboard.rb
-- lib/agentilda/dev_work.rb
-- lib/agentilda/diagram.rb
-- lib/agentilda/dispatcher.rb
-- lib/agentilda/documentation.rb
-- lib/agentilda/executor.rb
-- lib/agentilda/feature.rb
-- lib/agentilda/frontmatter.rb
-- lib/agentilda/github.rb
-- lib/agentilda/index.rb
-- lib/agentilda/keyboard.rb
+- lib/agentilda/engine.rb
+- lib/agentilda/engine/board.rb
+- lib/agentilda/engine/dispatcher.rb
+- lib/agentilda/engine/progress_log.rb
+- lib/agentilda/engine/runner.rb
+- lib/agentilda/engine/state_file.rb
+- lib/agentilda/engine/tally.rb
+- lib/agentilda/execution.rb
+- lib/agentilda/execution/child.rb
+- lib/agentilda/execution/clock.rb
+- lib/agentilda/execution/control.rb
+- lib/agentilda/execution/executor.rb
+- lib/agentilda/execution/transcript.rb
 - lib/agentilda/launcher.rb
-- lib/agentilda/ledger.rb
+- lib/agentilda/lifecycle.rb
+- lib/agentilda/lifecycle/adoption.rb
+- lib/agentilda/lifecycle/brief.rb
+- lib/agentilda/lifecycle/creator.rb
+- lib/agentilda/lifecycle/resync.rb
+- lib/agentilda/lifecycle/unblocker.rb
 - lib/agentilda/linear.rb
 - lib/agentilda/linear/api.rb
 - lib/agentilda/linear/attribution.rb
@@ -349,32 +349,39 @@ files:
 - lib/agentilda/linear/push.rb
 - lib/agentilda/linear/survey.rb
 - lib/agentilda/linear/unit.rb
-- lib/agentilda/mailbox.rb
-- lib/agentilda/markdown.rb
-- lib/agentilda/ordinal.rb
-- lib/agentilda/progress_log.rb
-- lib/agentilda/publisher.rb
-- lib/agentilda/pull_request.rb
-- lib/agentilda/pull_requests.rb
-- lib/agentilda/reporter.rb
-- lib/agentilda/resync.rb
-- lib/agentilda/roster.rb
-- lib/agentilda/runner.rb
-- lib/agentilda/screen/ratatui.rb
-- lib/agentilda/screen/ratatui/bar.rb
-- lib/agentilda/screen/ratatui/key_translator.rb
-- lib/agentilda/state_file.rb
-- lib/agentilda/state_machine.rb
-- lib/agentilda/status.rb
-- lib/agentilda/subject.rb
-- lib/agentilda/tally.rb
-- lib/agentilda/transcript.rb
-- lib/agentilda/tree.rb
-- lib/agentilda/ui.rb
-- lib/agentilda/unblocker.rb
+- lib/agentilda/plans.rb
+- lib/agentilda/plans/dev_work.rb
+- lib/agentilda/plans/feature.rb
+- lib/agentilda/plans/index.rb
+- lib/agentilda/plans/ledger.rb
+- lib/agentilda/plans/mailbox.rb
+- lib/agentilda/plans/ordinal.rb
+- lib/agentilda/plans/pull_request.rb
+- lib/agentilda/plans/pull_requests.rb
+- lib/agentilda/plans/state_machine.rb
+- lib/agentilda/plans/status.rb
+- lib/agentilda/plans/subject.rb
+- lib/agentilda/plans/tree.rb
+- lib/agentilda/presentation.rb
+- lib/agentilda/presentation/console.rb
+- lib/agentilda/presentation/dashboard.rb
+- lib/agentilda/presentation/diagram.rb
+- lib/agentilda/presentation/documentation.rb
+- lib/agentilda/presentation/keyboard.rb
+- lib/agentilda/presentation/reporter.rb
+- lib/agentilda/presentation/screen/ratatui.rb
+- lib/agentilda/presentation/screen/ratatui/bar.rb
+- lib/agentilda/presentation/screen/ratatui/key_translator.rb
+- lib/agentilda/presentation/viewer.rb
+- lib/agentilda/support/config.rb
+- lib/agentilda/support/frontmatter.rb
+- lib/agentilda/support/markdown.rb
+- lib/agentilda/support/ui.rb
+- lib/agentilda/vcs.rb
+- lib/agentilda/vcs/github.rb
+- lib/agentilda/vcs/publisher.rb
+- lib/agentilda/vcs/worktree.rb
 - lib/agentilda/version.rb
-- lib/agentilda/viewer.rb
-- lib/agentilda/worktree.rb
 homepage: https://github.com/kigster/agentilda
 licenses: []
 metadata:
@@ -395,7 +402,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.21
+rubygems_version: 4.0.22
 specification_version: 4
 summary: 'Agentic specification-driven development: spec, plan, build, review'
 test_files: []

data/lib/agentilda/adoption.rb

@@ -1,197 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-require "parallel"
-
-require "agentilda/status"
-
-module Agentilda
-  # Gives a plan folder to every pull request that has no plan to point at.
-  #
-  # `resync prs` can resolve most pull requests from their branch or their
-  # diff. What it cannot resolve it used to flag for a human — "diff touches
-  # 021.00, 022.00, 024.00 and none is obviously primary" — and stop. That is
-  # honest but not useful: the work exists, it is unspecified, and leaving it
-  # unnumbered means it never appears in the index at all.
-  #
-  # So an orphan is adopted instead. It gets a retroactive plan of its own,
-  # numbered in the gap after the furthest plan it can see, holding the pull
-  # request that produced it.
-  #
-  # == Why the numbering is allocated serially
-  #
-  # The obvious parallel design — every worker reads the highest number and
-  # adds `.01` — is deterministic but not unique, and the collision is the
-  # common case rather than the rare one. Fifteen open pull requests branched
-  # off the same main all see the same highest number and all compute the same
-  # slot. Determinism is not the property that matters here; distinctness is.
-  #
-  # So the pipeline is **gather in parallel, allocate serially, apply in
-  # parallel**. The allocation is pure arithmetic over an array that is
-  # already in memory, so the serial section costs microseconds; the two
-  # expensive phases — reading each branch and writing each folder — keep the
-  # whole fan-out. And because the slots are handed out before any worker
-  # starts, no worker can want a number another worker holds: no locks, no
-  # retries, and the same input produces the same numbers every run.
-  class Adoption
-    # One pull request and the plan it is being given.
-    #
-    # @!attribute [r] pull
-    #   @return [Hash] as returned by {GitHub#pulls}
-    # @!attribute [r] ordinal
-    #   @return [Agentilda::Ordinal] the slot it was allocated
-    # @!attribute [r] major
-    #   @return [Integer] the furthest plan its branch or diff could see
-    # @!attribute [r] path
-    #   @return [String, nil] the folder, once created
-    Adoptee = Data.define(:pull, :ordinal, :major, :path) do
-      # @return [String] the folder name this pull request earns
-      def dirname = Agentilda.plan_dirname(ordinal, STATUS_BY_KEY.fetch(:retroactive), slug)
-
-      # The PR title, stripped of any prefix, as the folder's tail.
-      #
-      # @return [String]
-      def slug = Creator.slugify(pull[:title].to_s.sub(/\A\[[^\]]+\](?:\([A-Z]\))?\s*/, ""))
-
-      # @return [String] a single auditable line
-      def to_s = "##{pull[:number]} → #{dirname}"
-    end
-
-    # @param tree [Agentilda::Tree]
-    # @param github [Agentilda::GitHub]
-    # @param root [String] repository root, for reading branches
-    # @param jobs [Integer] workers for the two parallel phases
-    def initialize(tree:, github: GitHub.new, root: nil, jobs: UI.default_jobs)
-      @tree = tree
-      @github = github
-      @root = root || File.dirname(tree.dir)
-      @jobs = jobs
-    end
-
-    # @return [Agentilda::Tree]
-    attr_reader :tree
-
-    # @return [Agentilda::GitHub]
-    attr_reader :github
-
-    # @return [String]
-    attr_reader :root
-
-    # @return [Integer]
-    attr_reader :jobs
-
-    # Work out what each orphan would be given, without creating anything.
-    #
-    # @param pulls [Array<Hash>] the orphans, from {Resync::Prs}
-    # @return [Array<Agentilda::Adoption::Adoptee>] in pull request order
-    def plan(pulls)
-      allocate(gather(pulls))
-    end
-
-    # Adopt every orphan: create its folder and record its pull request.
-    #
-    # @param pulls [Array<Hash>]
-    # @return [Array<Agentilda::Adoption::Adoptee>] with `path` filled in
-    def call(pulls)
-      adoptees = plan(pulls)
-      return adoptees if adoptees.empty?
-
-      created = Parallel.map(adoptees, in_threads: jobs) { |adoptee| adopt(adoptee) }
-      tree.reload
-      created
-    end
-
-    private
-
-    # Phase one, in parallel: ask each pull request's branch how far the
-    # sequence had got when the work started. Branches are not all rebased
-    # onto the same main, so this is per-branch rather than tree-wide, and it
-    # is a network-free `ls-tree` per pull request.
-    #
-    # @param pulls [Array<Hash>]
-    # @return [Array<Array(Hash, Integer)>] each pull with its major
-    def gather(pulls)
-      ordered = pulls.sort_by { |pull| pull[:number].to_i }
-
-      Parallel.map(ordered, in_threads: jobs) { |pull| [pull, major_for(pull)] }
-    end
-
-    # The furthest whole plan this pull request can see: on its own branch
-    # first, then whatever it touched, then the tree we are standing in. A
-    # pull request whose branch is long gone still has a diff.
-    #
-    # @param pull [Hash]
-    # @return [Integer]
-    def major_for(pull)
-      candidates = Agentilda.plans_on_ref(root, pull[:branch].to_s)
-      candidates = touched(pull) if candidates.empty?
-      candidates = tree.subjects.map { |s| s.feature.ordinal } if candidates.empty?
-
-      candidates.map(&:major).max.to_i
-    end
-
-    # @param pull [Hash]
-    # @return [Array<Agentilda::Ordinal>]
-    def touched(pull)
-      Array(pull[:files]).filter_map { |path|
-        parts = path.to_s.split("/")
-        index = parts.index(Agentilda::PLANS_DIR)
-        index && parts[index + 1] && Ordinal.from_dirname(parts[index + 1])
-      }.uniq
-    end
-
-    # Phase two, serial and deliberately so. Minors are handed out per major,
-    # continuing past every slot the tree already holds, in ascending pull
-    # request order — so the numbers follow the order the work was opened in,
-    # and two pull requests cannot be given the same one.
-    #
-    # @param gathered [Array<Array(Hash, Integer)>]
-    # @return [Array<Agentilda::Adoption::Adoptee>]
-    def allocate(gathered)
-      taken = Hash.new { |h, major| h[major] = minors_taken(major) }
-
-      gathered.filter_map do |pull, major|
-        minor = ((taken[major].max || 0) + 1)
-        next if minor > Ordinal::MAX_MINOR
-
-        taken[major] << minor
-        Adoptee.new(pull:, major:, ordinal: Ordinal.new(major:, minor:), path: nil)
-      end
-    end
-
-    # @param major [Integer]
-    # @return [Array<Integer>] minors already used under this major
-    def minors_taken(major)
-      tree.subjects.map { |s| s.feature.ordinal }.select { |o| o.major == major }.map(&:minor)
-    end
-
-    # Phase three, in parallel: each worker owns a number nobody else can
-    # want, so it can create its folder without coordinating with anyone.
-    #
-    # @param adoptee [Agentilda::Adoption::Adoptee]
-    # @return [Agentilda::Adoption::Adoptee]
-    def adopt(adoptee)
-      path = File.join(tree.dir, adoptee.dirname)
-      return adoptee if File.exist?(path)
-
-      FileUtils.mkdir_p(path)
-      File.write(File.join(path, PullRequests::FILENAME),
-        PullRequests.render([pull_request_for(adoptee)]))
-
-      adoptee.with(path:)
-    end
-
-    # The body is what a specification would be written from, so it is worth
-    # a second request. A failure here costs the description, not the folder.
-    #
-    # @param adoptee [Agentilda::Adoption::Adoptee]
-    # @return [Hash]
-    def pull_request_for(adoptee)
-      pull = adoptee.pull
-      github.pull_request(pull[:number].to_s)
-    rescue Agentilda::Error
-      { number: pull[:number], title: pull[:title], url: pull[:url],
-       state: pull[:state] || "Unknown", body: "" }
-    end
-  end
-end

data/lib/agentilda/agent.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module Agentilda
-  # One specialist, loaded from `~/.agents/agents/<name>.md`.
-  #
-  # The definition files are the single source of truth for who does what: the
-  # frontmatter says which plan states this agent handles and what it may write,
-  # and the body is the prompt. Nothing about a specialty is duplicated in Ruby.
-  #
-  # @!attribute [r] name
-  #   @return [String]
-  # @!attribute [r] description
-  #   @return [String]
-  # @!attribute [r] handles
-  #   @return [Array<Symbol>] plan states this agent is offered work from
-  # @!attribute [r] advances_to
-  #   @return [Symbol, nil] the state it is expected to reach; nil = read-only
-  # @!attribute [r] model
-  #   @return [String, nil]
-  # @!attribute [r] allowed_tools
-  #   @return [Array<String>]
-  # @!attribute [r] may
-  #   @return [Array<String>] commands lifted from {Executor::FORBIDDEN_COMMANDS}
-  #     for this agent alone. Nothing in {Executor::UNGRANTABLE} can be lifted.
-  # @!attribute [r] timeout
-  #   @return [Integer, nil] seconds before this agent is abandoned; nil
-  #     defers to the executor's run-wide default
-  # @!attribute [r] ledger
-  #   @return [Array<String>] the documents this agent signs, in the order
-  #     it reaches them; the last entry it wrote is where it stands
-  # @!attribute [r] rounds
-  #   @return [Integer] how many times it may be invoked on one plan in one
-  #     state before the plan parks; a Completed never earns another
-  # @!attribute [r] effort
-  #   @return [String, nil] passed to `claude --effort`
-  # @!attribute [r] starts_as
-  #   @return [Symbol, nil] the state the harness renames the plan into the
-  #     moment this agent is dispatched, where the topology permits it
-  # @!attribute [r] holds_at
-  #   @return [Symbol, nil] the state the plan takes when this agent completes
-  #     while its partner on the same plan is still running
-  Agent = Data.define(:name,
-    :description,
-    :handles,
-    :advances_to,
-    :model,
-    :allowed_tools,
-    :may,
-    :network,
-    :timeout,
-    :prompt,
-    :path,
-    :ledger,
-    :rounds,
-    :effort,
-    :starts_as,
-    :holds_at) do
-    def initialize(ledger: [], rounds: 1, effort: nil, starts_as: nil, holds_at: nil, **rest) = super
-
-    # @return [Boolean] whether this agent changes anything on disk
-    def read_only? = advances_to.nil?
-
-    # @param status [Agentilda::Status]
-    # @return [Boolean]
-    def handles?(status) = handles.include?(status.key)
-
-    # The word after the hyphen: `researcher`, `backend`. What the screen's
-    # agent column shows, the name being too long for it.
-    #
-    # @return [String]
-    def role = name.split("-", 2).last.to_s
-  end
-
-  # More rounds than this costs tokens and buys nothing: an agent that has
-  # not finished in five tries is not going to on the sixth.
-  Agent::MAX_ROUNDS = 5
-end

data/lib/agentilda/board.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module Agentilda
-  # What the screen draws: everything about the run, as values, refreshed
-  # once a second by the dispatcher. The screen paints it and knows nothing
-  # about threads; the dispatcher builds it and knows nothing about cells.
-  #
-  # @!attribute [r] rows
-  #   @return [Array<Agentilda::Board::Row>] one per agent invocation still
-  #     worth showing: running, or finished within the last few seconds
-  Board = Data.define(:started_at,
-    :status,
-    :plans,
-    :up,
-    :down,
-    :rows,
-    :root,
-    :running,
-    :live_up,
-    :live_down,
-    :selected,
-    :dialog,
-    :help,
-    :about,
-    :hidden) do
-    def initialize(selected: nil, dialog: nil, help: false, about: nil, hidden: 0, **rest) = super
-  end
-
-  # @!attribute [r] key
-  #   @return [String] `"001.00/leah-researcher"`, what selection and the
-  #     keyboard address a row by
-  # @!attribute [r] file
-  #   @return [String] the document holding the agent's latest ledger line
-  # @!attribute [r] pr
-  #   @return [Hash, nil] `{number:, url:, rejected:}` once the plan is at
-  #     the review stage
-  # @!attribute [r] state
-  #   @return [Symbol] :running, :done, :failed or :stuck
-  # @!attribute [r] phase
-  #   @return [Symbol, nil] the clock's phase while running
-  # @!attribute [r] frame
-  #   @return [Integer] spinner frame counter
-  # @!attribute [r] history
-  #   @return [Array<String>] what the agent has said, newest first, for
-  #     `run --scroll-height` to show more than the latest line of
-  Board::Row = Data.define(:key,
-    :at,
-    :ordinal,
-    :file,
-    :agent,
-    :role,
-    :round,
-    :rounds,
-    :model,
-    :remaining,
-    :phase,
-    :up,
-    :down,
-    :message,
-    :state,
-    :pr,
-    :frame,
-    :bold,
-    :elapsed,
-    :subagents,
-    :history) do
-    def initialize(pr: nil, phase: nil, remaining: nil, frame: 0, bold: false, message: nil,
-      elapsed: 0, subagents: 0, history: [], **rest)
-      super
-    end
-
-    # @param history [Array<String>] newest first
-    # @param text [String, nil]
-    # @return [Array<String>] +text+ on top, unless it is empty or repeats
-    #   the newest line: an agent restating its activity is not news
-    def self.remember(history, text)
-      text = text.to_s.strip
-      return history if text.empty? || history.first == text
-
-      [text, *history].first(Board::Row::HISTORY)
-    end
-
-    # @return [Boolean]
-    def running? = state == :running
-  end
-
-  # Statuses a row keeps, whatever the screen shows of them. A cap, so a
-  # long-running agent's chatter cannot grow without bound. Outside the
-  # `Data.define` block, whose constants would land on Agentilda instead.
-  Board::Row::HISTORY = 50
-end