hecks 6.0.0 → 7.0.0

data/lib/hecks/hecks/adapters/git_train/settlement.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "reading"
+require_relative "branch_guard"
+
+module Hecks
+  module Adapters
+    class GitTrain
+      # What a boarding does to a checkout before its carriage carries it: brings the branch up to
+      # its remote, and settles an additive shape change into a commit the carriage then pushes.
+      #
+      # It works on the boarded branch only: to change anything, the checkout must have that branch
+      # checked out and clean, and the branch must still name the boarded commit. Its own commit
+      # names the ledger paths it wrote, so nothing already staged is swept in.
+      #
+      # A rebase stops only on the ledger file, which is regenerated rather than merged: the
+      # upstream copy is taken and the ledger is settled after. Any other conflict aborts the
+      # rebase and is reported by path.
+      class Settlement
+        include Reading
+
+        # The shape ledger a Hecks checkout keeps, beside the bluebooks it records.
+        LEDGER = "lib/hecks/hecks/shapes.json"
+
+        # The translation edges an additive settlement writes.
+        EDGES = "lib/hecks/hecks/translations"
+
+        # The ledger's own command for an additive change, run from the checkout.
+        SETTLE = %w[bundle exec exe/hecks conformance_run.check_shape_ledger! --confirm --additive --wait].freeze
+
+        # The drift checks CI runs after a push lands, run here in check mode before the push: the
+        # generated Rust must match a regeneration, and the reserved-name tables and the CI gate
+        # rows must match their projections. Each only compares; none rewrites a file.
+        DRIFT = [
+          %w[bundle exec exe/hecks regeneration_run.regenerate_corpus! --check --wait],
+          %w[bundle exec exe/hecks gate_run.gate! stage=ci only=vocabulary_drift --wait],
+          %w[bundle exec exe/hecks gate_run.gate! stage=ci only=ci_gates --wait]
+        ].freeze
+
+        # How many rebase steps are tried before the rebase is given up as stuck.
+        STEPS = 50
+
+        # @param git [Git] the adapter every git call goes through
+        # @param checkout [String] the repository's top level
+        # @param branch [String] the branch being boarded
+        # @param remote [String] the remote the branch is pushed to
+        # @param drift [Array<Array<String>>] the drift checks a Hecks checkout must pass; the
+        #   `DRIFT` list by default, and a spec replaces it
+        def initialize(git, checkout, branch:, remote:, drift: DRIFT)
+          @git = git
+          @checkout = checkout
+          @branch = branch
+          @remote = remote
+          @drift = drift
+          @guard = BranchGuard.new(git, checkout, branch)
+        end
+
+        # @param boarded [String] the commit the branch named at boarding
+        # @return [String] the commit the branch names now, which the carriage then carries
+        # @raise [ConsoleCapture::Failure] when the branch moved since boarding, the checkout is not
+        #   on the branch or not clean, the rebase conflicts outside the ledger, or the ledger
+        #   cannot be settled
+        def run(boarded)
+          fetch
+          @expected = boarded
+          @guard.unmoved!(boarded)
+          rebasing = !ancestor?(tracking, @branch)
+          @guard.checked_out! if rebasing || ledger? || hecks_checkout?
+          rebase if rebasing
+          settle_ledger if ledger?
+          check_drift if hecks_checkout?
+          @guard.unmoved!(@expected)
+          @expected
+        end
+
+        private
+
+        def tracking = "#{@remote}/#{@branch}"
+
+        def fetch = read("fetch", "--quiet", @remote, "+refs/heads/#{@branch}:refs/remotes/#{tracking}")
+
+        def ledger? = File.exist?(File.join(@checkout, LEDGER))
+
+        def hecks_checkout? = File.exist?(File.join(@checkout, "exe", "hecks"))
+
+        # Rebases the local branch onto its remote. Stops on the ledger, takes the remote's copy of
+        # it, and continues; any other conflicted path aborts the rebase.
+        def rebase
+          @guard.clean!
+          rebase_onto_remote
+        end
+
+        def rebase_onto_remote
+          result = git(["rebase", tracking])
+          STEPS.times do
+            return @expected = @guard.head if result.ok?
+
+            conflicted = read("diff", "--name-only", "--diff-filter=U").lines.map(&:strip)
+            return abort_rebase!(conflicted) unless conflicted == [LEDGER]
+
+            read("checkout", "--ours", "--", LEDGER)
+            read("add", "--", LEDGER)
+            result = git(["-c", "core.editor=true", "rebase", "--continue"])
+          end
+          raise ConsoleCapture::Failure, "rebase onto #{tracking} did not finish in #{STEPS} steps"
+        end
+
+        def abort_rebase!(conflicted)
+          git(["rebase", "--abort"])
+          raise ConsoleCapture::Failure,
+                "#{@branch} does not rebase onto #{tracking}: conflict in #{conflicted.join(", ")}; resolve them by hand"
+        end
+
+        # Runs the ledger's own settlement for an additive change, and commits what it wrote. A
+        # change that is not additive is refused by the settlement, and the refusal stops it.
+        def settle_ledger
+          ledger_untouched!
+          out, err, status = Open3.capture3(*SETTLE, chdir: @checkout)
+          refusal = out.lines.find { |line| line.include?('"refusal": "') }
+          raise ConsoleCapture::Failure, "the shape ledger was not settled: #{refusal.strip}" if refusal
+          raise ConsoleCapture::Failure, "the shape ledger command failed: #{err.strip}" unless status.success?
+
+          commit_ledger
+        end
+
+        # The ledger files must hold no edits of anyone's before the settlement writes its own.
+        def ledger_untouched!
+          return if read("status", "--porcelain", "--", LEDGER, EDGES).empty?
+
+          raise ConsoleCapture::Failure, "#{LEDGER} or #{EDGES} has uncommitted changes; commit or discard them before boarding"
+        end
+
+        # Runs each drift check in check mode. The first that finds drift refuses the boarding and
+        # names the check and the end of what it printed; nothing is rewritten here.
+        def check_drift
+          @drift.each do |argv|
+            out, status = Open3.capture2e(*argv, chdir: @checkout)
+            next if status.success?
+
+            raise ConsoleCapture::Failure, "#{argv.drop(2).join(" ")} found drift; regenerate and commit it first: #{tail(out)}"
+          end
+        end
+
+        # The last three lines of what a check printed, as one line.
+        def tail(out)
+          last = out.lines.last(3)
+          last.join.strip
+        end
+
+        def commit_ledger
+          changed = read("status", "--porcelain", "--", LEDGER, EDGES)
+          return if changed.empty?
+
+          @guard.clean!(except: [LEDGER, EDGES])
+
+          written = [LEDGER, EDGES].select { |path| File.exist?(File.join(@checkout, path)) }
+          read("add", "--", *written)
+          read("commit", "-q", "-m", "Settle the shape ledger before boarding", "--", *written)
+          @expected = @guard.head
+        end
+
+        def git(args) = @git.capture(*args, chdir: @checkout)
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/git_train.rb

@@ -2,11 +2,15 @@
 
 require_relative "git"
 require_relative "console_capture"
+require_relative "push_size"
 require_relative "git_train/reading"
 require_relative "git_train/bench"
 require_relative "git_train/local_branch"
 require_relative "git_train/carriage"
 require_relative "git_train/survey"
+require_relative "git_train/settlement"
+require_relative "git_train/mint_step"
+require_relative "git_train/launcher_shape"
 
 module Hecks
   module Adapters
@@ -15,37 +19,55 @@ module Hecks
     # A boarding takes an exclusive `flock` on a file in the repository's common git directory, so
     # every worktree of one repository waits in the same line, and holds it until its push ends.
     # Waiting costs nothing: the pre-push checks of one push run at a time instead of all at once.
+    #
+    # Holding the line, a boarding names the commit the branch holds (`boarded`), checks that the
+    # train runs that commit's shape (`LauncherShape`), runs the Hecks mint (`MintStep`), then
+    # settles and pushes: one step after the other, so a refusal stops the boarding before
+    # anything is pushed. What is pushed is that commit, settled, and nothing else: a branch that
+    # moved meanwhile is refused.
     class GitTrain
       include Reading
 
       # The lock's file, in the repository's common git directory.
       LOCK_FILE = "hecks-push-train.lock"
 
-      # Accepts the arguments every driven adapter is built with and keeps none of them.
+      # Accepts the arguments every driven adapter is built with.
       #
       # @param aggregate [Object, nil] unused
       # @param settings [Hash] unused
       # @param root [String, nil] unused
-      def initialize(aggregate: nil, settings: {}, root: nil)
+      # @param options [Hash] `mint:` the mint a boarding runs first (the Hecks domain's if none);
+      #   `domain:` the launcher's Hecks domain directory the train's shape is read from (the one
+      #   this code runs from by default); `registry:` the booted registry whose world names the
+      #   push size
+      def initialize(aggregate: nil, settings: {}, root: nil, **options)
+        @registry = options.delete(:registry)
+        @mint = options.delete(:mint) || MintStep.new
+        @domain = options.delete(:domain) || JournalStore::HeldMint::DOMAIN
         @git = Git.new
       end
 
-      # Waits for the push ahead in the same repository, then carries the boarded commit.
+      # Waits for the push ahead in the same repository, runs the Hecks mint, then carries the
+      # boarded commit.
       #
-      # @param held [Hash] the `PushTrain` record: `branch`, `remote`, `checkout` (a directory
-      #   inside the repository; the current directory when none is named) and `full_gate` (the
-      #   push runs the whole pre-push stage, which the hook reads as `hecks.fullGate`)
-      # @return [Hash{Symbol => Hash}] `outcome:` (`pushed` or `carried`), `checkout:`, `boarded:`,
-      #   `pushed:` and `report:`
-      # @raise [ConsoleCapture::Failure] when the checkout is not a repository, the branch and the
-      #   remote's conflict, or the push is refused
+      # @param held [Hash] the `SendTrain` record: `run`, `confirm`, `branch`, `remote`, `checkout`
+      #   (a directory inside the repository; the current directory when none is named) and
+      #   `full_gate` (the whole pre-push stage, which the hook reads as `hecks.fullGate`)
+      # @return [Hash{Symbol => Hash}] `outcome:`, `checkout:`, `boarded:` (the commit named at
+      #   boarding), `pushed:` and `report:`, which opens with what the mint did
+      # @raise [ConsoleCapture::Failure] when the checkout is not a repository, the branch moved
+      #   since boarding, the train is not at the boarded commit, the branch and the remote's
+      #   conflict, or the push is refused
+      # @raise [Runtime::WiringError] when the mint refuses, before anything is pushed
       def carry(**held)
         @checkout = toplevel(plain(held[:checkout]) || Dir.pwd)
-        carriage = Carriage.new(@git, @checkout, branch: plain(held[:branch]) || "main",
-                                                 remote: plain(held[:remote]) || "origin",
-                                                 config: gate_config(held))
-        boarded = carriage.local_head
-        in_turn { carriage.carry(boarded) }
+        in_turn do
+          size = push_size(held)
+          boarded = boarded_commit(held)
+          LauncherShape.new(@git, @checkout, domain: @domain).check!(boarded)
+          minted = @mint.run(run: plain(held[:run]), confirm: plain(held[:confirm]))
+          after_mint(minted, boarded, settle_and_carry(held, boarded), size)
+        end
       end
 
       # Lists every checkout under a directory whose default branch has commits its remote does
@@ -64,6 +86,42 @@ module Hecks
 
       private
 
+      # The commit the branch names as the boarding begins, read once the line is held.
+      def boarded_commit(held)
+        Carriage.new(@git, @checkout, branch: branch_of(held), remote: remote_of(held)).local_head
+      end
+
+      # Brings the branch up to its remote and settles the shape ledger, then carries the settled
+      # commit.
+      def settle_and_carry(held, boarded)
+        branch = branch_of(held)
+        remote = remote_of(held)
+        settled = Settlement.new(@git, @checkout, branch: branch, remote: remote).run(boarded)
+        carriage = Carriage.new(@git, @checkout, branch: branch, remote: remote, config: gate_config(held))
+        [carriage.carry(settled), settled]
+      end
+
+      # What the push is, said before it is made: how many commits go and, past the world's
+      # threshold, the size sentence. It only says; a push of any size is carried.
+      def push_size(held)
+        ahead = read("rev-list", "--count", "#{remote_of(held)}/#{branch_of(held)}..#{branch_of(held)}").to_i
+        sentence = PushSize.sentence(ahead, PushSize.thresholds(@registry))
+        sentence.empty? ? "pushing #{ahead} commits" : "pushing #{ahead} commits; #{sentence}"
+      end
+
+      def branch_of(held) = plain(held[:branch]) || "main"
+
+      def remote_of(held) = plain(held[:remote]) || "origin"
+
+      # The carriage's answer, its report opened with what the mint did and naming the boarded
+      # commit (and the settled one when settlement moved the branch).
+      def after_mint(minted, boarded, carried, size = nil)
+        answer, settled = carried
+        named = settled == boarded ? "boarded #{boarded[0, 9]}" : "boarded #{boarded[0, 9]}, settled to #{settled[0, 9]}"
+        report = "#{"#{size}\n" if size}#{minted}, then #{named}: #{answer.dig(:report, :value)}"
+        answer.merge(boarded: { value: boarded }, report: { value: report })
+      end
+
       # A git hook takes no arguments, so the argument reaches the pre-push hook as git
       # configuration, for this push only (`git -c`).
       def gate_config(held) = plain(held[:full_gate]) == true ? ["-c", "hecks.fullGate=true"] : []

data/lib/hecks/hecks/adapters/git_worktree_add.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/git_worktree_add"
+
+Hecks.adapter "GitWorktreeAdd" do
+  port "WorktreeAdding"
+end

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/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,12 +44,12 @@ 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 [CLI::ExpectedEra::Unreachable] if the host cannot be reached
-      # @raise [CLI::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: verdict.era }, version: { value: finding.version },

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

@@ -5,11 +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
@@ -28,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.
       #
@@ -56,7 +58,7 @@ 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
@@ -68,8 +70,8 @@ module Hecks
       # @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
-        CLI::PersistenceNotice.announce(registry, program: "hecks stores")
-        report(JSON.generate(CLI::Stores.read(registry, plain(aggregate), plain(record), flat: plain(flat) == true)))
+        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
@@ -78,8 +80,8 @@ module Hecks
       # @raise [Runtime::NotFound] if the domain cannot be found
       def history(domain:)
         registry = boot(domain).registry
-        CLI::PersistenceNotice.announce(registry, program: "hecks history")
-        report(JSON.generate(CLI::History.document(registry)))
+        Tools::PersistenceNotice.announce(registry, program: "hecks history")
+        report(JSON.generate(Tools::History.document(registry)))
       end
 
       # @param domain [Hash, String] a domain directory