hecks 5.0.0 → 7.0.0

data/lib/hecks/hecks/adapters/git_worktree_add.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "git_worktrees"
+require_relative "git_main_pull"
+
+module Hecks
+  module Adapters
+    # The `WorktreeAdding` port's adapter for `Worktree`: opens a linked worktree on a new branch cut from
+    # `main` (pulled first, see {GitMainPull}), at the path named or under the checkout's
+    # `.claude/worktrees`.
+    #
+    # It never checks out `main` in a worktree, never pushes, and never forces. A branch that already exists
+    # is declined by git, and the reason travels back on the record.
+    class GitWorktreeAdd
+      include GitWorktrees
+      include GitMainPull
+
+      # Accepts the arguments every driven adapter is built with and keeps none of them.
+      #
+      # @param aggregate [Object, nil] unused
+      # @param settings [Hash] unused
+      # @param root [String, nil] unused
+      def initialize(aggregate: nil, settings: {}, root: nil)
+        @git = Git.new
+      end
+
+      # Opens the worktree, then reads the sha it stands on.
+      #
+      # @param held [Hash] the `Worktree` record: `checkout` (a directory inside the repository; the current
+      #   directory when absent), `branch` (a new branch name), and `path` (optional)
+      # @return [Hash{Symbol => Hash}] `sha:` the commit it stands on, `report:` where it is
+      # @raise [ConsoleCapture::Failure] on a missing branch, a branch named main, or a directory outside a repository
+      def create(**held)
+        repo = settle(held)
+        branch = branch_named(held)
+        path = plain(held[:path]).to_s.strip
+        path = File.join(repo, ".claude", "worktrees", branch) if path.empty?
+        pulled = pull_main
+        read("worktree", "add", "-b", branch, path, "main")
+        sha = read("rev-parse", "--short", "HEAD", dir: path)
+        { path: { value: path }, sha: { value: sha }, report: { value: "opened #{path} on #{branch}; #{pulled}" } }
+      end
+
+      # Brings local `main` up to date with `origin/main`: a fast-forward, or a rebase of its
+      # unpushed commits when both moved. Refuses a dirty checkout or a rebase in progress.
+      #
+      # @param held [Hash] the `LinkedTree` record: `checkout` (a directory inside the repository)
+      # @return [Hash{Symbol => Hash}] `sha:` where `main` stands, `report:` what was done
+      # @raise [ConsoleCapture::Failure] `cannot pull main: ...` with the reason
+      def pull(**held)
+        settle(held)
+        said = pull_main
+        { sha: { value: read("rev-parse", "--short", "main") }, report: { value: said } }
+      end
+
+      private
+
+      # The branch a worktree is cut on: a name, and never main.
+      def branch_named(held)
+        branch = plain(held[:branch]).to_s.strip
+        raise ConsoleCapture::Failure, "a worktree needs a branch" if branch.empty?
+        raise ConsoleCapture::Failure, "a worktree is not opened on main" if branch == "main"
+
+        branch
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/git_worktrees.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "git"
+require_relative "console_capture"
+require_relative "git_train/reading"
+
+module Hecks
+  module Adapters
+    # What the `Checkout` and `Landing` adapters share: finding a repository from any directory in
+    # it, listing its worktrees, and telling a clean tree from a dirty one.
+    #
+    # An includer sets `@git` (the `Git` adapter) before calling anything here, and `settle` sets
+    # `@checkout` (a repository's top level). Every branch or ref that reaches a command is
+    # checked against `GitRefs::REF_PATTERN` first, so a name cannot carry a flag.
+    module GitWorktrees
+      include GitTrain::Reading
+
+      # One worktree of a repository, as `git worktree list --porcelain` describes it.
+      #
+      # @!attribute [r] path
+      #   @return [String] where it is checked out
+      # @!attribute [r] head
+      #   @return [String, nil] the commit it stands on
+      # @!attribute [r] branch
+      #   @return [String, nil] the branch it has checked out, nil when detached
+      Worktree = Struct.new(:path, :head, :branch)
+
+      # The blank line between two worktrees in `git worktree list --porcelain`.
+      BLOCK_BREAK = /\n\n+/
+
+      private
+
+      # Points the adapter at the repository a directory is in.
+      #
+      # @param held [Hash] the arguments of a command or query; `checkout` names the directory
+      # @return [String] the repository's top level
+      # @raise [ConsoleCapture::Failure] when the directory is not there or not in a repository
+      def settle(held)
+        dir = plain(held[:checkout]) || Dir.pwd
+        raise ConsoleCapture::Failure, "#{dir} is not a directory" unless File.directory?(dir)
+
+        @checkout = read("rev-parse", "--show-toplevel", dir: dir)
+      end
+
+      def worktrees
+        read("worktree", "list", "--porcelain").split(BLOCK_BREAK).map { |block| worktree_of(block) }
+      end
+
+      def worktree_of(block)
+        fields = block.lines.to_h { |line| line.strip.split(" ", 2).then { |key, value| [key, value] } }
+        Worktree.new(fields["worktree"], fields["HEAD"], fields["branch"]&.delete_prefix("refs/heads/"))
+      end
+
+      def primary = worktrees.first
+
+      def worktree_on(branch) = worktrees.find { |tree| tree.branch == branch }
+
+      def current_branch
+        result = @git.capture("symbolic-ref", "--quiet", "--short", "HEAD", chdir: @checkout)
+        return result.out.strip if result.ok?
+
+        raise ConsoleCapture::Failure, "#{@checkout} has no branch checked out"
+      end
+
+      # The paths git lists as changed or untracked in a tree, one porcelain line each.
+      def dirty(dir = @checkout) = read("status", "--porcelain", dir: dir).lines.map(&:rstrip)
+
+      def ref(name)
+        return name if name.to_s.match?(GitRefs::REF_PATTERN)
+
+        raise ConsoleCapture::Failure, "#{name.inspect} is not a branch or ref name"
+      end
+
+      def branch_tip(branch) = read("rev-parse", "--verify", "refs/heads/#{ref(branch)}^{commit}")
+
+      def count(range) = read("rev-list", "--count", range).to_i
+
+      def plain(argument) = argument.is_a?(Hash) ? argument[:value] : argument
+    end
+  end
+end

data/lib/hecks/hecks/adapters/github_pull_requests.adapter

@@ -0,0 +1,7 @@
+# Required by name, not relative to this file: a fuzz or model check boots a copy of this directory,
+# and the implementation must load once, from `lib/`, not from the copy.
+require "hecks/hecks/adapters/github_pull_requests"
+
+Hecks.adapter "GithubPullRequests" do
+  port "GitHubPullRequests"
+end

data/lib/hecks/hecks/adapters/github_pull_requests.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require_relative "console_capture"
+
+module Hecks
+  module Adapters
+    # The `GitHubPullRequests` port's adapter: opens, squash-merges and reads pull requests of the
+    # repository the current directory is in, through `gh`.
+    #
+    # The aggregate has already recorded the request. Nothing here decides whether a pull request
+    # should be opened or merged; it only asks GitHub and reports what GitHub answered. A merge is
+    # always a squash, and `--admin` is never passed, so a branch protection rule is not bypassed.
+    class GithubPullRequests
+      # A pull request number: digits only.
+      NUMBER = /\A\d+\z/
+
+      # @param aggregate [Object, nil] unused
+      # @param settings [Hash] unused
+      # @param root [String, nil] unused
+      # @param runner [#call, nil] runs `gh` with its arguments, answering `[stdout, stderr, success]`;
+      #   the real `gh` when nil. A spec replaces it.
+      def initialize(aggregate: nil, settings: {}, root: nil, runner: nil)
+        @runner = runner || method(:run_gh)
+      end
+
+      # Opens a pull request from a branch onto a base, its title and body taken from the commits.
+      #
+      # @param held [Hash] the `PullRequest` record: `branch` (required), `base` (`main` when absent)
+      # @return [Hash{Symbol => Hash}] `outcome:` (`opened`), `number:`, `url:` and `report:`
+      # @raise [ConsoleCapture::Failure] when no branch is named, or GitHub refuses
+      def create(**held)
+        branch = plain(held[:branch]) or raise ConsoleCapture::Failure, "no branch to open a pull request from"
+        base = plain(held[:base]) || "main"
+        out = gh!("pr", "create", "--head", branch, "--base", base, "--fill")
+        url = pull_request_url(out)
+        number = url&.split("/")&.last
+        raise ConsoleCapture::Failure, "gh pr create printed no pull request URL: #{out.strip.inspect}" unless number
+
+        { outcome: { value: "opened" }, number: { value: number }, url: { value: url },
+          report: { value: "opened ##{number} from #{branch} onto #{base}: #{url}" } }
+      end
+
+      # Squash-merges one open pull request by its number.
+      #
+      # @param held [Hash] the `PullRequest` record: `number` (required)
+      # @return [Hash{Symbol => Hash}] `outcome:` (`merged`), `number:` and `report:`
+      # @raise [ConsoleCapture::Failure] when no number is named, or GitHub refuses
+      def squash(**held)
+        number = pull_request_number(held[:number], "merge")
+        gh!("pr", "merge", number, "--squash")
+
+        { outcome: { value: "merged" }, number: { value: number },
+          report: { value: "squash-merged ##{number}" } }
+      end
+
+      # The state of one pull request, as text: its number, state, URL and checks.
+      #
+      # @param held [Hash] the query's arguments: `number` (required)
+      # @return [Hash{Symbol => String}] `text:` one `name: value` line each
+      # @raise [ConsoleCapture::Failure] when no number is named, or GitHub refuses
+      def status(**held)
+        number = pull_request_number(held[:number], "read")
+        view = JSON.parse(gh!("pr", "view", number, "--json", "number,state,url,mergedAt,statusCheckRollup"))
+        { text: "#{status_lines(view).join("\n")}\n" }
+      end
+
+      private
+
+      def plain(argument) = argument.is_a?(Hash) ? argument[:value] : argument
+
+      # A pull request's number, digits only: gh reads a value that starts with a dash as an option.
+      def pull_request_number(argument, verb)
+        number = plain(argument)
+        return number if number.to_s.match?(NUMBER)
+
+        raise ConsoleCapture::Failure, "no pull request number to #{verb}, or it is not a number: #{number.inspect}"
+      end
+
+      # The first line of gh's output that is a URL; `gh pr create` prints the new pull request's.
+      def pull_request_url(out) = out.lines.find { |line| line.start_with?("https://") }&.strip
+
+      def status_lines(view)
+        checks = Array(view["statusCheckRollup"]).map { |check| "#{check["name"]}=#{check_state(check)}" }
+        ["number: #{view["number"]}", "state: #{view["state"]}", "url: #{view["url"]}",
+         "merged: #{view["mergedAt"] || "no"}", "checks: #{checks.empty? ? "none" : checks.join(", ")}"]
+      end
+
+      # A check's conclusion once it has one, and its state while it is still pending.
+      def check_state(check) = check["conclusion"].to_s.empty? ? check["state"] : check["conclusion"]
+
+      # Runs `gh` and returns its stdout, or raises `ConsoleCapture::Failure` with its reason.
+      def gh!(*arguments)
+        out, err, ok = @runner.call(arguments)
+        return out if ok
+
+        raise ConsoleCapture::Failure, "gh #{arguments.first(2).join(" ")} failed: #{err.strip.empty? ? out.strip : err.strip}"
+      end
+
+      def run_gh(arguments)
+        out, err, status = Open3.capture3("gh", *arguments)
+        [out, err, status.success?]
+      rescue Errno::ENOENT
+        ["", "gh is not installed", false]
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/host_http.rb

@@ -2,8 +2,8 @@
 
 require "stringio"
 require_relative "console_capture"
-require "hecks/cli/smoke_http"
-require "hecks/cli/check_era"
+require "hecks/tools/smoke_http"
+require "hecks/tools/check_era"
 
 module Hecks
   module Adapters
@@ -29,7 +29,7 @@ module Hecks
       # @raise [ConsoleCapture::Failure] when any check failed
       def probe(**held)
         out = StringIO.new
-        status = CLI::SmokeHttp.new(CLI::SmokeHttp.resolve(probe_options(held).compact, ENV), out: out).run
+        status = Tools::SmokeHttp.new(Tools::SmokeHttp.resolve(probe_options(held).compact, ENV), out: out).run
         raise ConsoleCapture::Failure, out.string.strip unless status.zero?
 
         { output: { value: out.string } }
@@ -44,15 +44,16 @@ module Hecks
       #   `mismatch`) and `report:` (the sentence `hecks check_era` prints)
       # @raise [ArgumentError] if no allow-list file or timeout was given
       # @raise [Errno::ENOENT] if the allow-list file cannot be read
-      # @raise [Runtime::EraCheck::ExpectedEra::Unreachable] if the host cannot be reached
-      # @raise [Runtime::EraCheck::ExpectedEra::BadResponse] if it answers no era
+      # @raise [Tools::ExpectedEra::Unreachable] if the host cannot be reached
+      # @raise [Tools::ExpectedEra::BadResponse] if it answers no era
       def fetch(**held)
         file = required(held[:expected], "no allow-list file to compare the era with")
         timeout = required(held[:timeout], "no timeout to wait for the host with")
-        finding = CLI::CheckEra.assess(plain(held[:host]), file, timeout: timeout.to_f)
+        finding = Tools::CheckEra.assess(plain(held[:host]), file, timeout: timeout.to_f)
+        verdict = finding.verdict
 
-        { era: { value: finding.verdict.era }, version: { value: finding.version },
-          verdict: { value: finding.verdict.status.to_s }, report: { value: finding.line } }
+        { era: { value: verdict.era }, version: { value: finding.version },
+          verdict: { value: verdict.status.to_s }, report: { value: finding.line } }
       end
 
       private

data/lib/hecks/hecks/adapters/in_process_access.rb

@@ -7,12 +7,13 @@ module Hecks
     # What the `DomainRuntime` port's adapter does when an `Operation` asks it to give a domain its
     # first administrator.
     module InProcessAccess
-      # Boots the domain and grants the first administrator through its membership chapter.
+      # Boots the domain and grants the first administrator through its membership bluebook.
       #
       # @param held [Hash] the `Operation` record: `subject` (the domain), `email`, and optionally
       #   `name` and `role`
       # @return [Hash{Symbol => Hash}] `output:` the sentence saying who now holds which role
-      # @raise [Runtime::NotFound] if the domain cannot be found or has no membership chapter, or an
+      # @raise [Runtime::NotFound] if the domain cannot be found or has no membership bluebook, or
+      #   an
       #   administrator already exists
       def bootstrap(**held)
         result = FirstAdmin.new(boot(held[:subject])).call(

data/lib/hecks/hecks/adapters/in_process_boot.rb

@@ -5,10 +5,12 @@ require "hecks"
 # A domain wired to PostgresEra needs this plugin loaded explicitly, and the `:shape` projection
 # reads `Runtime::StorageShape` from it (ADR 0033).
 require_relative "../../ports/persistence/plugins/era"
-require_relative "../../cli/stores"
-require_relative "../../cli/shape"
-require_relative "../../cli/history"
+require_relative "../../tools/stores"
+require_relative "../../tools/shape"
+require_relative "../../tools/history"
+require_relative "../../projections/context_map_diagram"
 require_relative "in_process_operations"
+require_relative "in_process_undo"
 require_relative "in_process_access"
 
 module Hecks
@@ -19,7 +21,7 @@ module Hecks
     # Each method returns the text the matching tool prints, so the launcher shows the
     # same bytes; a projection that would have written files answers a map of file name to text
     # instead. Arguments arrive materialized, so a value object is `{ value: "x" }`. A domain or
-    # chapter that cannot be found raises `Runtime::NotFound`, which the launcher words as a
+    # bluebook that cannot be found raises `Runtime::NotFound`, which the launcher words as a
     # refusal.
     #
     # It also answers the asks of journaled commands (`InProcessOperations`): a model check, a run,
@@ -27,6 +29,7 @@ module Hecks
     class InProcessBoot
       include InProcessOperations
       include InProcessAccess
+      include InProcessUndo
 
       # Accepts the arguments every driven adapter is built with and keeps none of them.
       #
@@ -55,21 +58,20 @@ module Hecks
       #   one `<Domain> <label>` line per domain for a directory
       # @raise [Runtime::NotFound] if the path does not exist or holds no bluebook
       def shape(domain:)
-        report(CLI::Shape.render(plain(domain)))
+        report(Tools::Shape.render(plain(domain)))
       end
 
       # @param domain [Hash, String] a domain directory
-      # @return [Hash] `text:` every aggregate's current records as one JSON document
-      # @raise [Runtime::NotFound] if the domain cannot be found
-      def stores(domain:)
+      # @param aggregate [Hash, String, nil] a storage name, to read only that aggregate
+      # @param record [Hash, String, nil] a record id within `aggregate`, to read only that record
+      # @param flat [Hash, Boolean, nil] true unwraps the value objects to their values
+      # @return [Hash] `text:` every aggregate's current records as one JSON document, or what
+      #   `aggregate` and `record` narrow it to
+      # @raise [Runtime::NotFound] if the domain, aggregate or record cannot be found
+      def stores(domain:, aggregate: nil, record: nil, flat: nil)
         registry = boot(domain).registry
-        stores = registry.bluebooks.each_with_object({}) do |(name, bluebook), all|
-          bluebook.aggregates.each do |aggregate|
-            all[aggregate.storage_name] = CLI::Stores.data_for(registry.repository(name, aggregate))
-          end
-        end
-
-        report(JSON.generate(stores))
+        Tools::PersistenceNotice.announce(registry, program: "hecks stores")
+        report(JSON.generate(Tools::Stores.read(registry, plain(aggregate), plain(record), flat: plain(flat) == true)))
       end
 
       # @param domain [Hash, String] a domain directory
@@ -77,15 +79,17 @@ module Hecks
       #   hold, as JSON
       # @raise [Runtime::NotFound] if the domain cannot be found
       def history(domain:)
-        report(JSON.generate(CLI::History.document(boot(domain).registry)))
+        registry = boot(domain).registry
+        Tools::PersistenceNotice.announce(registry, program: "hecks history")
+        report(JSON.generate(Tools::History.document(registry)))
       end
 
       # @param domain [Hash, String] a domain directory
-      # @param chapter [Hash, String] the chapter's name
-      # @return [Hash] `text:` the chapter's declared facts, one sentence a line
-      # @raise [Runtime::NotFound] if the domain or chapter cannot be found
-      def statements(domain:, chapter:)
-        report(Projector.call(:statements, bluebook: chapter_of(domain, chapter)).join("\n"))
+      # @param bluebook [Hash, String] the bluebook's name
+      # @return [Hash] `text:` the bluebook's declared facts, one sentence a line
+      # @raise [Runtime::NotFound] if the domain or bluebook cannot be found
+      def statements(domain:, bluebook:)
+        report(Projector.call(:statements, bluebook: bluebook_of(domain, bluebook)).join("\n"))
       end
 
       # @param domain [Hash, String, nil] a domain directory; the nearest enclosing one when absent
@@ -96,6 +100,30 @@ module Hecks
         document(:narrate, domain, aggregate)
       end
 
+      # @param domain [Hash, String] a domain directory
+      # @return [Hash] `text:` one line per relationship between the contexts the domain holds
+      # @raise [Runtime::NotFound] if the domain cannot be found
+      def relationships(domain:)
+        report(Projections::ContextRelationships.text(registry: boot(domain).registry))
+      end
+
+      # @param domain [Hash, String] a domain directory
+      # @return [Hash] `text:` the declared context map drawn as Mermaid beside the wiring, with
+      #   each finding of holding the wiring to the map as a comment
+      # @raise [Runtime::NotFound] if the domain cannot be found
+      def context_map(domain:)
+        registry = boot(domain).registry
+        edges = Projections::ContextRelationships.call(registry: registry)
+        report(Projections::ContextMapDiagram.report(map: registry.context_maps.first, edges: edges))
+      end
+
+      # @param domain [Hash, String] a domain directory
+      # @return [Hash] `text:` a starting `.world` for the adapters the domain binds
+      # @raise [Runtime::NotFound] if the domain cannot be found
+      def world_skeleton(domain:)
+        report(Projections::WorldSkeleton.call(registry: boot(domain).registry))
+      end
+
       # @param domain [Hash, String, nil] a domain directory; the nearest enclosing one when absent
       # @param aggregate [Hash, String, nil] document only this aggregate
       # @return [Hash] `text:` the domain's usage document
@@ -105,29 +133,29 @@ module Hecks
       end
 
       # @param domain [Hash, String] a domain directory
-      # @param chapter [Hash, String] the chapter's name
+      # @param bluebook [Hash, String] the bluebook's name
       # @return [Array<Hash{Symbol => String}>] one `name:`/`text:` row per diagram file
-      # @raise [Runtime::NotFound] if the domain or chapter cannot be found
-      def project_diagrams(domain:, chapter:)
+      # @raise [Runtime::NotFound] if the domain or bluebook cannot be found
+      def project_diagrams(domain:, bluebook:)
         runtime = boot(domain)
-        name    = plain(chapter)
-        options = { hecksagon: runtime.registry.hecksagon(name) }
+        name    = plain(bluebook)
+        options = { hecksagon: runtime.hecksagon(name) }
 
-        projected_files(Projector.call(:diagrams, bluebook: chapter_in(runtime, name), options: options))
+        projected_files(Projector.call(:diagrams, bluebook: bluebook_in(runtime, name), options: options))
       end
 
       # @param domain [Hash, String] a domain directory
-      # @param chapter [Hash, String] the chapter's name
+      # @param bluebook [Hash, String] the bluebook's name
       # @return [Array<Hash{Symbol => String}>] one `name:`/`text:` row per glossary file
-      # @raise [Runtime::NotFound] if the domain or chapter cannot be found
-      def glossary(domain:, chapter:)
+      # @raise [Runtime::NotFound] if the domain or bluebook cannot be found
+      def glossary(domain:, bluebook:)
         runtime = boot(domain)
-        name    = plain(chapter)
-        markings = runtime.registry.pending_privacy_markings.select do |marking|
+        name    = plain(bluebook)
+        markings = runtime.pending_privacy_markings.select do |marking|
           marking[:domain].to_s.start_with?("#{name}::")
         end
 
-        projected_files(Projector.call(:glossary, bluebook: chapter_in(runtime, name),
+        projected_files(Projector.call(:glossary, bluebook: bluebook_in(runtime, name),
                                                   options:  { markings: markings }))
       end
 
@@ -177,17 +205,18 @@ module Hecks
         Hecks.boot(File.expand_path(path), install_driving: false)
       end
 
-      def chapter_of(domain, chapter)
-        chapter_in(boot(domain), plain(chapter))
+      def bluebook_of(domain, declaration)
+        bluebook_in(boot(domain), plain(declaration))
       end
 
-      def chapter_in(runtime, name)
-        runtime.registry.bluebook(name) or raise Runtime::NotFound, "no chapter named #{name}"
+      def bluebook_in(runtime, name)
+        runtime.bluebook(name) or raise Runtime::NotFound, "no bluebook named #{name}"
       end
 
-      # The domain's own chapter, not a framework member it attached: insertion order.
+      # The domain's own bluebook, not a framework member it attached: insertion order.
       def document(projection, domain, aggregate)
-        bluebook = boot(domain).registry.bluebooks.values.first or raise Runtime::NotFound, "no bluebook loaded"
+        registry = boot(domain).registry
+        bluebook = registry.first_bluebook or raise Runtime::NotFound, "no bluebook loaded"
         name = plain(aggregate)
 
         report(Projector.call(projection, bluebook: bluebook, options: name ? { aggregate: name } : {}))

data/lib/hecks/hecks/adapters/in_process_operations.rb

@@ -4,11 +4,11 @@ require "json"
 require "time"
 require_relative "console_capture"
 require_relative "in_process_operations/tailing"
-require "hecks/cli/run"
-require "hecks/cli/model_check"
-require "hecks/cli/smoke_test"
-require "hecks/cli/behaviors"
-require "hecks/cli/refresh_projections"
+require "hecks/tools/run"
+require "hecks/tools/model_check"
+require "hecks/tools/smoke_test"
+require "hecks/tools/behaviors"
+require "hecks/tools/refresh_projections"
 
 module Hecks
   module Adapters
@@ -16,13 +16,13 @@ module Hecks
     # the asks of `ModelCheckRun` and `Operation`, plus the `Follow` query.
     #
     # An ask is handed the whole record it was made on (its `held_state`), so each method reads the
-    # record's fields, runs the existing `Hecks::CLI::*` entry point captured, and answers the text
+    # record's fields, runs the existing `Hecks::Tools::*` entry point captured, and answers the text
     # it printed. An answer records a success; a raise records a refusal, so a check that finds
     # something, or a run that fails, is refused with the report as its reason.
     module InProcessOperations
       include Tailing
 
-      # The chapters `hecks model_check` sweep when no domain is named need a
+      # The bluebooks `hecks model_check` sweep when no domain is named need a
       # checkout; an installed gem has none.
       CHECKOUT_MARKER = "hecks.gemspec"
 
@@ -43,7 +43,7 @@ module Hecks
         argv = check_argv(held)
 
         text = ConsoleCapture.answer do
-          CLI::ModelCheck.call(argv, program: "hecks model_check", root: checkout_root)
+          Tools::ModelCheck.call(argv, program: "hecks model_check", root: checkout_root)
         end
         { report: { value: text }, checked: { value: text.scan(REPORT_HEADER).size } }
       end
@@ -59,7 +59,7 @@ module Hecks
         script = plain(held[:script])
         argv += script ? [script] : [plain(held[:verb]), *words(held[:arguments])].compact
 
-        output(ConsoleCapture.answer { CLI::Run.call(argv, program: "hecks run") })
+        output(ConsoleCapture.answer_apart { Tools::Run.call(argv, program: "hecks run") })
       end
 
       # Forces every read-model projection the domain declares to catch up.
@@ -68,10 +68,36 @@ module Hecks
       # @return [Hash{Symbol => Hash}] `output:` how many projections were refreshed
       # @raise [Runtime::NotFound] if the domain cannot be found
       def refresh(**held)
-        count = CLI::RefreshProjections.call(boot(held[:subject]))
+        count = Tools::RefreshProjections.call(boot(held[:subject]))
         output("refreshed #{count} projection(s)")
       end
 
+      # Redelivers the reactions a domain's outbox left undelivered. A claimed row (one that
+      # stalled across a crash, whose effect may or may not have run) is redelivered only when
+      # `claimed` says so for every claimed row, or `row` names that one row's delivery id.
+      #
+      # @param held [Hash] the `Operation` record: `subject` (the domain), `claimed` (a switch)
+      #   and `row` (a delivery id)
+      # @return [Hash{Symbol => Hash}] `output:` how many rows were redriven
+      # @raise [Runtime::NotFound] if the domain cannot be found, or no claimed row has `row`
+      def redrive(**held)
+        outbox = Assembly.bind_ported_runtime(boot(held[:subject])).outbox
+        row = plain(held[:row])
+        rows = row ? outbox.redrive_row!(row) : outbox.redrive!(claimed: plain(held[:claimed]) == true)
+        output("redrove #{rows.size} outbox row(s)")
+      end
+
+      # Settles one stalled claimed outbox row as failed, without running its consumer.
+      #
+      # @param held [Hash] the `Operation` record: `subject` (the domain) and `row` (a delivery id)
+      # @return [Hash{Symbol => Hash}] `output:` the row that was abandoned
+      # @raise [Runtime::NotFound] if the domain cannot be found, or no claimed row has `row`
+      def abandon(**held)
+        outbox = boot(held[:subject]).outbox
+        rows = outbox.abandon_row!(plain(held[:row]))
+        output("abandoned #{rows.size} outbox row(s): #{rows.map(&:delivery_id).join(", ")}")
+      end
+
       # Runs a `.behaviors` file, or every one under a directory.
       #
       # @param held [Hash] the `Operation` record: `subject` (the file or directory)
@@ -79,7 +105,7 @@ module Hecks
       # @raise [ConsoleCapture::Failure] when any test failed, errored or did not parse
       def verify(**held)
         argv = [plain(held[:subject])].compact
-        output(ConsoleCapture.answer { CLI::Behaviors.call(argv, program: "hecks run_behaviors") })
+        output(ConsoleCapture.answer { Tools::Behaviors.call(argv, program: "hecks run_behaviors") })
       end
 
       # Boots a wired domain and dispatches one synthesized call per command and report.
@@ -92,11 +118,9 @@ module Hecks
         domain = plain(held[:subject]) || (checkout_root ? nil : Folder.new.domain_root)
         argv = [domain].compact
 
-        output(ConsoleCapture.answer { CLI::SmokeTest.call(argv, root: checkout_root || Dir.pwd) })
+        output(ConsoleCapture.answer { Tools::SmokeTest.call(argv, root: checkout_root || Dir.pwd) })
       end
 
-      # rubocop:disable Metrics/ParameterLists -- the keywords are the `Follow` query's declared arguments
-
       # A domain's event log past a cursor, answered once: what the stream yielded before it
       # ended. Pass the answered `cursor` back as `since` to keep tailing. `wait` bounds the stream
       # and it ends at the first entries, so a call returns as soon as there is something to say.
@@ -110,7 +134,6 @@ module Hecks
       # @return [Hash] the `Tail` row: `cursor:`, `events:` (payloads as JSON text) and `taken_at:`
       # @raise [Runtime::NotFound] if the domain cannot be found or keeps no event log
       def follow(domain:, aggregate: nil, since: nil, from_now: nil, wait: nil, interval: nil)
-        # rubocop:enable Metrics/ParameterLists
         registry = boot(domain).registry
         entries = []
         cursor = stream(domain: domain, aggregate: aggregate, since: since, from_now: from_now,
@@ -122,8 +145,6 @@ module Hecks
         { cursor: cursor, events: entries, taken_at: Time.at(Ports::Clock.now(registry)).utc.iso8601 }
       end
 
-      # rubocop:disable Metrics/ParameterLists -- the keywords are the caller-facing shape of a tail
-
       # Tails a domain's event log, handing each entry to the block as the log shows it, until
       # the block returns `:stop` (or `:batch`: after this check's entries), `limit` entries were
       # handed over, `timeout` seconds pass, or the reader goes away; unbounded, until interrupted.
@@ -138,7 +159,6 @@ module Hecks
       # @raise [Runtime::NotFound] if the domain cannot be found or keeps no event log
       def stream(domain:, aggregate: nil, since: nil, from_now: nil, limit: nil, timeout: nil, interval: nil,
                  registry: nil, &)
-        # rubocop:enable Metrics/ParameterLists
         repository = event_repository(domain, registry)
         tail = Tail.new(plain(since)&.to_i || (plain(from_now) ? repository.events.size : 0), 0, false)
         bounds = Bounds.new(plain(aggregate), plain(limit)&.to_i, deadline_for(timeout), plain(interval))
@@ -164,7 +184,7 @@ module Hecks
       #
       # @raise [Runtime::NotFound] if one does not
       def named_domains(held)
-        argv = plain(held[:domains]).to_s.split(",").map(&:strip).reject(&:empty?)
+        argv = Text.comma_list(plain(held[:domains]))
         missing = argv.reject { |domain| File.exist?(domain) }
         raise Runtime::NotFound, "no such domain #{missing.first.inspect}" if missing.any?
 
@@ -197,7 +217,7 @@ module Hecks
 
       # Says whether `event` passes the aggregate filter: a bare name, case-insensitive, or exact.
       def followed?(event, filter)
-        filter.nil? || event.aggregate.to_s.split("::").last.casecmp?(filter) || event.aggregate == filter
+        filter.nil? || Naming.demodulise(event.aggregate).casecmp?(filter) || event.aggregate == filter
       end
     end
   end