agentilda 2.0.1 → 2.0.4

data/lib/agentilda/feature.rb

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-
-require "agentilda/ordinal"
-require "agentilda/status"
-
-module Agentilda
-  # Lowercase in the middle of a title, capitalised at the front.
-  SMALL_WORDS = %w[a an and as at but by for from in into nor of on or per the to via vs with].freeze
-
-  # Slug words that are really acronyms and should shout.
-  ACRONYMS = %w[
-    abac ai api aws cdn ci cd cli cms cors cpu crm css csv db dns dsl e2e ec2 etl gcp gdpr gpu gui
-    html http https iam id ide jwt json k8s llm ml mcp mvp npm oauth orm otp pdf pii poc pr prs qa
-    rbac rds rest rls rpc rss s3 saas sdk seo sns spa sql sqs sre ssh sso ssl ssr tls tui ts tsx ui
-    ux uuid vpc vpn xml yaml
-  ].freeze
-
-  # Words with a house spelling that neither capitalize nor upcase gets right.
-  SPECIAL_CASE = {
-    "github" => "GitHub", "gitlab" => "GitLab", "graphql" => "GraphQL", "ios" => "iOS",
-    "javascript" => "JavaScript", "macos" => "macOS", "nodejs" => "Node.js", "oauth" => "OAuth",
-    "openai" => "OpenAI", "postgres" => "PostgreSQL", "postgresql" => "PostgreSQL",
-    "typescript" => "TypeScript", "uuidv7" => "UUIDv7", "websocket" => "WebSocket"
-  }.freeze
-
-  # Turn a kebab slug into a proper name: `law-as-data` → "Law as Data".
-  #
-  # @param slug [String]
-  # @return [String]
-  def self.titleize(slug)
-    words = slug.to_s.split(/[-_\s.]+/).reject(&:empty?)
-    return "" if words.empty?
-
-    words.each_with_index.map { |word, i|
-      lower = word.downcase
-      if SPECIAL_CASE.key?(lower)
-        SPECIAL_CASE[lower]
-      elsif ACRONYMS.include?(lower)
-        lower.upcase
-      elsif i.positive? && SMALL_WORDS.include?(lower)
-        lower
-      elsif lower.match?(/\A\d+\z/)
-        lower
-      else
-        lower.sub(/\A./, &:upcase)
-      end
-    }.join(" ")
-  end
-
-  # The one place a plan folder's name is spelled out: `NNN.MM-<emoji> → <slug>`.
-  #
-  # The spaced arrow after the emoji is deliberate: an emoji renders two cells
-  # wide and visually swallows a bare dash beside it, so `🔎-refactor` reads
-  # as if the emoji and the slug were touching. Everything that mints or
-  # renames a folder goes through here; {Feature.parse} accepts the older
-  # `--` and single-dash spellings too, and `resync dirs` migrates them on
-  # contact.
-  #
-  # @param ordinal [Agentilda::Ordinal, String]
-  # @param status [Agentilda::Status]
-  # @param slug [String]
-  # @return [String]
-  def self.plan_dirname(ordinal, status, slug) = "#{ordinal}-#{status.emoji} → #{slug}"
-
-  # One `NNN.MM-<emoji> → <slug>` folder, decoded.
-  #
-  # @!attribute [r] ordinal
-  #   @return [Agentilda::Ordinal]
-  # @!attribute [r] status
-  #   @return [Agentilda::Status]
-  # @!attribute [r] slug
-  #   @return [String]
-  # @!attribute [r] dirname
-  #   @return [String] exactly as it is on disk
-  # @!attribute [r] path
-  #   @return [String] absolute
-  Feature = Data.define(:ordinal, :status, :slug, :dirname, :path) do
-    include Comparable
-
-    # Decode a folder name, or return nil when it is not a plan folder.
-    #
-    # @param path [String] absolute path to a candidate directory
-    # @return [Agentilda::Feature, nil]
-    def self.parse(path)
-      dirname = File.basename(path)
-      ordinal = Ordinal.from_dirname(dirname) or return nil
-
-      rest = dirname.sub(/\A[\d.]+[-_]/, "")
-      head, tail = rest.split(/\s*→\s*|[-_]/, 2)
-
-      # A leading segment with no ASCII word character is the status emoji.
-      # The slug strips any further separators: the canonical spelling puts
-      # a spaced arrow after the emoji, and folders from before that rule put
-      # two dashes, or one.
-      status = (Agentilda.status_for_emoji(head) if tail && !head.to_s.empty? && !head.match?(/[A-Za-z0-9]/))
-      slug = status ? tail.sub(/\A[-_\s]+/, "") : rest
-
-      new(ordinal:, status: status || STATUS_BY_KEY.fetch(:new), slug:, dirname:, path:)
-    end
-
-    # @return [String] proper name, e.g. "Law as Data"
-    def title = Agentilda.titleize(slug)
-
-    # The folder name this feature would carry in a given state — the slug
-    # never moves, and the number is always rendered canonically, so this is
-    # also what repairs a folder written `018-⚪️--foo` before the `NNN.MM` rule.
-    #
-    # @param status [Agentilda::Status]
-    # @return [String]
-    def dirname_as(status) = Agentilda.plan_dirname(ordinal, status, slug)
-
-    # The number exactly as the folder writes it, which is not always the
-    # canonical rendering: `018-⚪️--foo` yields "018" where {#ordinal} renders
-    # "018.00".
-    #
-    # @return [String]
-    def dirname_ordinal = dirname.to_s[/\A[\d.]+/].to_s
-
-    # @return [Boolean] whether the number is written in full `NNN.MM` form
-    def padded? = dirname_ordinal == ordinal.to_s
-
-    # Whether the folder is already named the way this tool would name it —
-    # number padded, emoji matching the state it claims, slug unchanged.
-    #
-    # @return [Boolean]
-    def canonical? = dirname == dirname_as(status)
-
-    # @param other [Object]
-    # @return [Integer, nil]
-    def <=>(other) = other.is_a?(self.class) ? [ordinal, dirname] <=> [other.ordinal, other.dirname] : nil
-  end
-end

data/lib/agentilda/github.rb

@@ -1,168 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "tty/command"
-
-module Agentilda
-  # The `gh` CLI, wrapped thinly.
-  #
-  # It is a seam rather than a convenience: every example in the suite injects
-  # a double here, so nothing in the tests reaches the network or a real
-  # repository.
-  class GitHub
-    # Fields asked of `gh pr list`.
-    FIELDS = %w[number title url headRefName files state isDraft mergedAt].freeze
-
-    # @param command [TTY::Command] runner, injectable for tests
-    # @param limit [Integer] how many pull requests to fetch
-    def initialize(command: TTY::Command.new(printer: :null), limit: 200)
-      @command = command
-      @limit = limit
-    end
-
-    # Every pull request, normalised into plain hashes.
-    #
-    # @param state [String] "open", "closed", "merged" or "all"
-    # @return [Array<Hash>] `{number:, title:, url:, branch:, files:}`
-    def pulls(state: "all")
-      out = UI.spinning("Fetching pull requests from GitHub") {
-        @command.run("gh",
-          "pr",
-          "list",
-          "--state",
-          state,
-          "--limit",
-          @limit.to_s,
-          "--json",
-          FIELDS.join(",")).out
-      }
-
-      # `gh` can exit 0 having printed NOTHING — most often when it cannot reach
-      # the credential store, as in a non-interactive shell that has no keyring
-      # access, or when GH_TOKEN is set to something invalid and shadows a
-      # working login. Left alone this parses as a JSON error and reports as
-      # "bad output", sending you to look at the wrong thing entirely.
-      raise Error, no_output_message if out.to_s.strip.empty?
-
-      JSON.parse(out).map do |pr|
-        {
-          number: pr["number"],
-          title:  pr["title"].to_s,
-          url:    pr["url"],
-          branch: pr["headRefName"].to_s,
-          files:  Array(pr["files"]).map { |f| f["path"] }.compact,
-          state:  self.class.state_label(pr),
-          open:   pr["mergedAt"].nil? && pr["state"].to_s.upcase == "OPEN"
-        }
-      end
-    rescue TTY::Command::ExitError, JSON::ParserError => e
-      raise Error, "could not list pull requests via `gh`: #{e.message.lines.first.to_s.strip}"
-    end
-
-    # @return [String] the diagnosis for a silent `gh`
-    def no_output_message
-      <<~MESSAGE.strip
-        `gh` produced no output and did not report an error.
-
-        That is almost always authentication rather than an empty repository:
-
-          - Check `gh auth status`. An invalid GH_TOKEN in the environment
-            shadows a working keyring login and fails without saying so.
-
-          - A non-interactive shell may have no access to the system keyring
-            even when an interactive one does.
-
-        Verify with: gh pr list --state all --limit 1
-      MESSAGE
-    end
-
-    # Fields asked of `gh pr view`, which unlike `pr list` can be told about
-    # one pull request in another repository.
-    VIEW_FIELDS = %w[number title url state isDraft mergedAt body].freeze
-
-    # A reference to one pull request: a bare number, a `#`-prefixed number,
-    # or a full URL to a GitHub pull request or a GitLab merge request.
-    REF = %r{\A(?:\#?\d+|https?://\S+?/(?:pull|merge_requests)/\d+/?)\z}
-
-    # Split and validate a `--prs` value before any of it reaches the network,
-    # so a typo fails in a hundredth of a second with the offending token named
-    # rather than after four round trips with a `gh` diagnostic.
-    #
-    # @param text [String] e.g. "12,15,18" or "https://…/pull/12, #15"
-    # @return [Array<String>] references, in the order given, de-duplicated
-    # @raise [Agentilda::Error] on anything that is not a reference
-    def self.parse_refs(text)
-      refs = text.to_s.split(",").map(&:strip).reject(&:empty?)
-      raise Error, "no pull requests given" if refs.empty?
-
-      bad = refs.reject { |r| r.match?(REF) }
-      unless bad.empty?
-        raise Error, "not a pull request number or URL: #{bad.join(", ")}"
-      end
-
-      refs.uniq
-    end
-
-    # One pull request, by number or URL.
-    #
-    # @param ref [String] "12", "#12" or "https://github.com/o/r/pull/12"
-    # @return [Hash] `{number:, title:, url:, state:, body:}`
-    # @raise [Agentilda::Error]
-    def pull_request(ref)
-      out = @command.run("gh", "pr", "view", ref.to_s, "--json", VIEW_FIELDS.join(",")).out
-      raise Error, no_output_message if out.to_s.strip.empty?
-
-      pr = JSON.parse(out)
-      {
-        number: pr["number"],
-        title:  pr["title"].to_s,
-        url:    pr["url"].to_s,
-        state:  self.class.state_label(pr),
-        body:   pr["body"].to_s
-      }
-    rescue TTY::Command::ExitError, JSON::ParserError => e
-      raise Error, "could not read pull request #{ref}: #{e.message.lines.first.to_s.strip}"
-    end
-
-    # Several pull requests, in the order asked for.
-    #
-    # @param refs [Array<String>]
-    # @return [Array<Hash>]
-    def pull_requests(refs)
-      UI.stepping(refs, "Fetching pull requests") { |ref| ref }
-      refs.map { |ref| pull_request(ref) }
-    end
-
-    # `gh` speaks in enums; `pull-requests.md` speaks in the words the state
-    # machine parses. Translate once, here, rather than at each call site.
-    #
-    # @param pr [Hash] a decoded `gh pr view` payload
-    # @return [String] one of the labels in {PullRequests::STATES}
-    def self.state_label(pr)
-      return "Merged 🟣" if pr["mergedAt"]
-      return "WIP 🟡" if pr["isDraft"]
-
-      case pr["state"].to_s.upcase
-      when "OPEN" then "Open 🟡"
-      when "CLOSED" then "Closed 🔴"
-      else "Unknown"
-      end
-    end
-
-    # Change a pull request's title.
-    #
-    # @param number [Integer]
-    # @param title [String]
-    # @return [void]
-    def retitle(number:, title:)
-      @command.run("gh", "pr", "edit", number.to_s, "--title", title)
-    rescue TTY::Command::ExitError => e
-      raise Error, "could not retitle ##{number}: #{e.message.lines.first.to_s.strip}"
-    end
-
-    # @return [Boolean] whether `gh` is installed and authenticated
-    def available?
-      @command.run!("gh", "auth", "status").success?
-    end
-  end
-end

data/lib/agentilda/index.rb

@@ -1,206 +0,0 @@
-# frozen_string_literal: true
-
-require "cgi"
-require "erb"
-
-module Agentilda
-  # `agentilda index` — the project's plans as one browsable page.
-  #
-  # {Reporter} answers "what is the state of things" in a terminal, in columns,
-  # for someone standing at a prompt. This answers "what is this project, and
-  # where is everything" for someone arriving at the repository on the web: the
-  # goal of each plan in its own words, every pull request as a link, and every
-  # document in the folder one click away.
-  #
-  # It is generated for the same reason the conventions document is. A
-  # hand-written index of twenty plans cannot survive a rename, and renaming is
-  # exactly what `resync dirs` exists to do — the first hand-made INDEX.md this
-  # replaced had all 82 of its links pointing at folder names that had been
-  # padded to `NNN.MM` underneath it.
-  class Index
-    # The file this writes, relative to the `.plans` directory.
-    FILENAME = "INDEX.md"
-
-    # Documents that get a proper name rather than their filename.
-    ARTIFACT_NAMES = {
-      "spec.md"          => "Spec",
-      "plan.md"          => "Plan",
-      "pull-requests.md" => "Pull Requests",
-      "linear.md"        => "Linear",
-      "blocked.md"       => "Blocked",
-      "delayed.md"       => "Deferred",
-      "rewrite.md"       => "Rewrite",
-      "deployed.md"      => "Deployed",
-      "rollback.md"      => "Rollback",
-      "discarded.md"     => "Discarded"
-    }.freeze
-
-    # @param tree [Agentilda::Tree]
-    # @param project [String, nil] the heading; defaults to the repository name
-    def initialize(tree:, project: nil)
-      @tree = tree
-      @project = project
-    end
-
-    # @return [Agentilda::Tree]
-    attr_reader :tree
-
-    # @return [String] the project's name, titleized from its directory
-    def project = @project ||= Agentilda.titleize(File.basename(File.dirname(tree.dir)))
-
-    # @return [String] the whole document
-    def render
-      [heading, *tree.subjects.map { |subject| section(subject) }].join("\n") + footer
-    end
-
-    # Write it next to the plans it describes.
-    #
-    # @param path [String, nil] override the destination
-    # @return [String] where it was written
-    def write(path = nil)
-      path ||= File.join(tree.dir, FILENAME)
-      File.write(path, render)
-      path
-    end
-
-    private
-
-    # @return [String]
-    def heading
-      <<~MARKDOWN
-        # Project #{project}
-
-        > [!IMPORTANT]
-        > **This file is auto generated.** To regenerate it, run `agentilda index`.
-        > Editing it by hand lasts until the next `resync dirs` renames a folder.
-
-        ## Current specifications and their status
-
-      MARKDOWN
-    end
-
-    # One plan: a heading that carries its number and state, then a table.
-    #
-    # Raw HTML rather than a markdown table because the cells are not one-liners
-    # — a goal is a paragraph or two and a plan may have a dozen pull requests,
-    # neither of which a pipe-delimited row can hold.
-    #
-    # @param subject [Agentilda::Subject]
-    # @return [String]
-    def section(subject)
-      feature = subject.feature
-
-      <<~MARKDOWN
-        ## #{feature.ordinal} — #{feature.status.emoji} #{escape(feature.title)}
-
-        <table>
-          <thead>
-            <tr>
-              <th align="left">Status</th>
-              <th align="left">Pull Requests</th>
-              <th align="left">What it is</th>
-              <th align="left">Artifacts</th>
-            </tr>
-          </thead>
-          <tbody>
-            <tr>
-              <td valign="top">#{status_cell(subject)}</td>
-              <td valign="top">#{pulls_cell(subject)}</td>
-              <td valign="top">#{goal_cell(subject)}</td>
-              <td valign="top">#{artifacts_cell(feature)}</td>
-            </tr>
-          </tbody>
-        </table>
-
-      MARKDOWN
-    end
-
-    # The emoji and the words, kept on one line — a status that wraps mid-label
-    # makes the column look like two states rather than one.
-    #
-    # @param subject [Agentilda::Subject]
-    # @return [String]
-    def status_cell(subject)
-      cell = "#{subject.status.emoji}&nbsp;#{escape(subject.status.label)}"
-      return cell if subject.consistent?
-
-      "#{cell}<br><sub>⚠️ #{escape(subject.violation)}</sub>"
-    end
-
-    # @param subject [Agentilda::Subject]
-    # @return [String]
-    def pulls_cell(subject)
-      prs = subject.pull_requests
-      return "<em>—</em>" if prs.empty?
-
-      items = prs.map { |pr|
-        "<li>#{link(pr.url, pr.label)} #{escape(pr.state)}</li>"
-      }
-      "<ul>#{items.join}</ul>"
-    end
-
-    # @param subject [Agentilda::Subject]
-    # @return [String]
-    def goal_cell(subject)
-      paragraphs = subject.goal
-      return "<em>No specification yet.</em>" if paragraphs.empty?
-
-      paragraphs.map { |p| "<p>#{inline(p)}</p>" }.join
-    end
-
-    # Markdown inside a raw HTML block is not parsed — GitHub stops parsing
-    # markdown the moment it sees a block-level tag — so a goal quoted verbatim
-    # would show its own `**` and backticks. Only the three that carry meaning
-    # are translated; single-underscore emphasis is deliberately left alone,
-    # because `deleted_at` is more common in these documents than italics.
-    #
-    # @param text [String] markdown, unescaped
-    # @return [String] HTML
-    def inline(text)
-      escape(text)
-        .gsub(/\[([^\]]+)\]\((https?:[^)\s]+)\)/) { %(<a href="#{$2}">#{$1}</a>) }
-        .gsub(/\*\*([^*]+)\*\*/) { "<strong>#{$1}</strong>" }
-        .gsub(/`([^`]+)`/) { "<code>#{$1}</code>" }
-        .tr("\n", " ")
-    end
-
-    # Every document in the folder, linked. The folder name is percent-encoded
-    # because it contains an emoji, and a raw one in an href is a broken link
-    # on GitHub.
-    #
-    # @param feature [Agentilda::Feature]
-    # @return [String]
-    def artifacts_cell(feature)
-      files = Dir.children(feature.path).select { |f| File.file?(File.join(feature.path, f)) }
-      return "<em>empty</em>" if files.empty?
-
-      # The documents that carry the lifecycle come first, in lifecycle order;
-      # whatever else the folder holds follows alphabetically.
-      known = ARTIFACT_NAMES.keys
-      files = files.sort_by { |f| [known.index(f) || known.size, f] }
-
-      items = files.map { |file|
-        href = "#{ERB::Util.url_encode(feature.dirname)}/#{ERB::Util.url_encode(file)}"
-        "<li>#{link(href, ARTIFACT_NAMES.fetch(file, file))}</li>"
-      }
-      "<ul>#{items.join}</ul>"
-    end
-
-    # @return [String]
-    def footer
-      counts = tree.subjects.each_with_object(Hash.new(0)) { |s, h| h[s.status] += 1 }
-                   .map { |status, n| "#{status.emoji} #{n}" }.join(" &nbsp; ")
-
-      "\n---\n\n#{tree.subjects.size} #{tree.subjects.size == 1 ? "plan" : "plans"} &nbsp; #{counts}\n"
-    end
-
-    # @param href [String]
-    # @param text [String]
-    # @return [String]
-    def link(href, text) = %(<a href="#{escape(href)}">#{escape(text)}</a>)
-
-    # @param text [String]
-    # @return [String]
-    def escape(text) = CGI.escapeHTML(text.to_s)
-  end
-end

data/lib/agentilda/keyboard.rb

@@ -1,156 +0,0 @@
-# frozen_string_literal: true
-
-require "io/console"
-
-module Agentilda
-  # Listens for single keypresses while a run is in flight, and turns them
-  # into {Control} broadcasts.
-  #
-  # The listener is a thread reading STDIN in raw mode, which only makes
-  # sense when STDIN is a terminal: piped input must never be eaten one byte
-  # at a time, and a run under cron has nobody at the keys. {.listen} returns
-  # nil in both cases and every caller treats nil as "no keyboard".
-  #
-  # Raw mode swallows Ctrl-C along with everything else, so ETX is forwarded
-  # to the main thread as the Interrupt it would have been — the listener
-  # must never make a run harder to kill than it was without one.
-  class Keyboard
-    # Key → what it does, rendered by {#help} and dispatched by {#handle}.
-    BINDINGS = [
-      ["h", "this help"],
-      ["?", "about agentilda"],
-      ["s", "select the next running agent; arrows move the selection"],
-      ["k", "mark the selected agent to be killed (STOP, 15s, then kill -9)"],
-      ["x", "extend the selected agent's clock by 10 minutes, per press"],
-      ["ENTER", "apply the pending changes in the dialog"],
-      ["ESC", "discard the dialog, then clear the selection"],
-      ["w", "ask every running agent to wrap up as fast as possible"],
-      ["n", "ask agents to write out what they have and stop; the loop continues"],
-      ["q", "write out, stop everything, and quit after a #{Control::GRACE}s grace"],
-      ["ctrl-c", "agents leave a resume note and stop, then quit; press again to abort now"]
-    ].freeze
-
-    # @param input [IO]
-    # @param sink [Agentilda::Console, nil] where the table keys go; nil
-    #   when there is no screen, in which case they do nothing
-    # @return [Agentilda::Keyboard, nil] a running listener, or nil when
-    #   STDIN is not a terminal
-    def self.listen(input: $stdin, sink: nil)
-      return nil unless input.tty?
-
-      new(input:, sink:).start
-    end
-
-    # @param input [IO]
-    # @param sink [Agentilda::Console, nil]
-    def initialize(input: $stdin, sink: nil)
-      @input = input
-      @sink = sink
-    end
-
-    # @return [self]
-    def start
-      @thread = Thread.new do
-        Thread.current.report_on_exception = false
-        loop { handle(read_key) }
-      rescue IOError, Errno::EIO
-        # STDIN went away; a keyboard with no keys just stops listening.
-      end
-      self
-    end
-
-    # @return [void]
-    def stop
-      @thread&.kill
-      @thread = nil
-      restore
-    end
-
-    # `getch` puts the terminal in raw mode for the length of one read and
-    # restores it afterwards — but the listener spends almost all its life
-    # blocked inside that read, and {#stop} kills it there, which leaves
-    # the mode behind. Raw mode has output post-processing off, so a "\n"
-    # written after it drops a line without returning the cursor to column
-    # zero: the run report then starts wherever the previous line ended and
-    # staircases down the screen. Nothing else puts the mode back, so this
-    # does.
-    #
-    # @return [void]
-    def restore
-      @input.cooked! if @input.tty?
-    rescue IOError, SystemCallError
-      # No terminal left to put back; there is nothing to restore it to.
-    end
-
-    # @param key [String, nil]
-    # @return [void]
-    def handle(key)
-      case key
-      when "h" then @sink ? @sink.toggle_help : UI.popup("Keys", help)
-      when "?" then @sink ? @sink.toggle_about : UI.popup("About", about)
-      when "s", "\e[B" then @sink&.select_next
-      when "\e[A" then @sink&.select_prev
-      when "k" then @sink&.toggle_kill
-      when "x" then @sink&.extend
-      when "\r", "\n" then @sink&.apply
-      when "\e" then @sink&.escape
-      when "w" then acted("w — agents asked to wrap up") { Control.wrap_up! }
-      when "n" then acted("n — agents asked to write out and stop") { Control.stop! }
-      when "q" then acted("q — quitting; #{Control::GRACE}s grace to write out") { Control.quit! }
-      when "\u0003" then interrupt
-      end
-    end
-
-    # @return [String] the bindings, one per line, widest key first
-    def help
-      width = BINDINGS.map { |key, _| key.length }.max
-      BINDINGS.map { |key, does| "#{key.ljust(width)}   #{does}" }.join("\n")
-    end
-
-    # @return [String] the version and a reminder of how to leave
-    def about = "Agentilda Version #{Agentilda::VERSION}\n\nThanks for using this! Press 'q' to exit and stop all agents."
-
-    private
-
-    # ESC alone and ESC-[-A are the same first byte. Wait a few
-    # milliseconds for the rest before deciding it was a bare ESC.
-    #
-    # @return [String]
-    def read_key
-      key = @input.getch
-      return key unless key == "\e"
-
-      if IO.select([@input], nil, nil, 0.05)
-        rest = @input.read_nonblock(2, exception: false)
-        return "\e#{rest}" if rest.is_a?(String)
-      end
-      key
-    end
-
-    # Raw mode swallows the signal, so the key stands in for it: the first
-    # press lets agents write down where they got to, the second aborts.
-    #
-    # @return [void]
-    def interrupt
-      return Thread.main.raise(Interrupt) if Control.interrupted?
-
-      acted("ctrl-c — agents leaving resume notes; #{Control::GRACE}s grace, ctrl-c again to abort") { Control.interrupt! }
-    end
-
-    # A keypress with no acknowledgement looks like a keypress that did
-    # nothing, so each one says what it just asked for.
-    #
-    # @param note [String]
-    # @return [void]
-    def acted(note)
-      yield
-      UI.log(note)
-      # Under the dashboard, RatatuiRuby.run owns the alternate screen and
-      # repaints it continuously, so this raw `$stderr` write either never
-      # appears or is immediately overwritten — `UI.log` above is the only
-      # guaranteed record of w/n/q there. The line still matters without a
-      # screen (a dry run, a pipe), where this is all the feedback there is.
-      UI.line(note)
-    end
-  end
-end