hashira 0.8.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 137dafce03e707a097cf684620fbd9c9efc8989347e77b88c13da103102f5da5
-  data.tar.gz: e0ab59d2e1909042c991764b5384217601aaf42b036bd6916042efc2107e0200
+  metadata.gz: 28f5f325c96b2579257212ed846fba744718bf8bbdc16ea46f0f0225abdb15af
+  data.tar.gz: 587bc337f5e0bbd94243d7e6cb7b4d4268a8617d913750fdf85156f0f4168c78
 SHA512:
-  metadata.gz: 2c4895c6d045e05e610fda4c51ce763e0ef876049d933dbd4a3d9f99ac24c8648583a4a3f39e5c2baadfae263736914ba2a428781024ead0410b2d968585b8b8
-  data.tar.gz: dec6a978383a76ad57fdf34c98b5ea4b571775d44baafc0f5c02c3bbe75b7a56e274609c1586fc77af94e93f65f501579a5b6fa09bfd4db3952bb3cb412c153b
+  metadata.gz: 28516d160aa0888bf1e9de0e00f80b1992444554309cc2a414a68dfc3c9272580e314b6593ec4b1a113b50185b7aea99bd82af7c1ac7143da9fb802b115aec46
+  data.tar.gz: eb711b0c77caff20baca0e36d8526126dde23e40bda06c6ed8efe5b1fd62d180e372b3a4447d66ab5be3b19abdf000e34ae94629ea45142373840992589cd6b7

data/CHANGELOG.md

@@ -5,6 +5,86 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.10.0] - 2026-08-30
+
+### Added
+
+- **Interpreted foreign models are verified architecture, not accepted debt.**
+  A baseline can declare a foreign root with `role: interpreted_model`, its one
+  API entrypoint, and a reason. Type dispatch over that model no longer emits
+  `boundary_sprawl`, while a missing root call or a call which bypasses the
+  entrypoint is rejected as misuse. Baseline schema 6 preserves these
+  declarations on `--update-baseline`. Hashira now declares Prism this way and
+  dogfoods with zero findings and zero acceptances.
+
+### Changed
+
+- `boundary_sprawl` now distinguishes a missing adapter from a program which
+  deliberately interprets a foreign data model. Undeclared foreign roots keep
+  the same 12-method, 3-file threshold and behavior.
+
+- Three smell kinds are renamed to name the smell, not the mechanism:
+  `duplicate_method_call` is now `repeated_call`, `too_many_instance_variables`
+  is `state_sprawl`, and `instance_variable_assumption` is `assumed_state`. A
+  saved baseline reports the old kinds as resolved and the new ones as new;
+  accept once to move on.
+
+## [0.9.0] - 2026-08-20
+
+### Fixed
+
+- **A rename stops reading as churn in the ratchet.** A finding is keyed by what
+  it names, so renaming a class reported the twelve findings under it as
+  resolved and new at once, and adding `?` to four predicates did the same. The
+  baseline now records a `traces` map beside `findings` — for each finding, the
+  file it sits in and what its evidence says, with line numbers stripped — and
+  the ratchet pairs a disappeared key with an appeared one carrying the same
+  trace. The match is one for one, so a rename that brought a new finding along
+  still fails, and a renamed method that also got worse still reports WORSE.
+  Acceptance is untouched: `accepted` entries still name a finding by `package`
+  or `digest`. Baselines recorded before this have no traces and behave exactly
+  as they did; the next `--update-baseline` writes them (schema version 5, which
+  older hashira reads too).
+- **A shared namespace stops passing for a shared name.** The duplication
+  near-miss guard raises the mass floor when two sites have no name in common —
+  but `Prism::CallNode` and `Prism::BlockParameterNode` counted `Prism` as
+  common, so two unrelated one-liners that both mention a Prism class slipped
+  under the low floor. A constant is now read by what it points at, not the
+  namespace it sits in.
+- **A nested class is named the way Ruby resolves it.** `class Widget::Broken`
+  written inside `class Widget` was reported as `Widget::Widget::Broken`. The
+  smell census now resolves a compound constant path against the constants the
+  codebase actually declares, the way the coupling graph already did. Findings
+  on such classes change name, so a baseline recorded before this reports them
+  once as resolved-and-new; re-record it with `--update-baseline`.
+
+### Changed
+
+- **`duplicate_method_call` stops flagging calls that are supposed to differ.**
+  `stdout = "".b` next to `stderr = "".b` is two buffers, and
+  `rand(1_000_000_000)` twice is two ids — naming either once writes a bug. The
+  check now excuses calls that mint a fresh value each time (`new`, `dup`,
+  `clone`, `allocate`, `rand`, anything from `SecureRandom` or `Random`, and
+  any call on a literal) and repeats that no single run can reach twice: the
+  two arms of an `if` or `unless`, two `when` or `in` branches, a body and its
+  `rescue`. Nothing can be hoisted across those, and a `raise` has no result to
+  name.
+- **`instance_variable_assumption` asks whether anything assigns, not whether
+  `initialize` does.** Assignment through a mixin, a superclass, an
+  `attr_writer`, a reopening of the class, or a private method the constructor
+  calls all count now — every shape that made the old check report a class that
+  was perfectly fine. What survives is the ivar nothing the class can reach ever
+  sets: a typo, or state another object is expected to install. When a class
+  inherits or includes something the codebase can't see, the check stays quiet
+  rather than guess.
+- **A run of declarative macros is a schema, not a clone.** Two models opening
+  with the same `has_many ..., dependent: :destroy` lines, or two serializers
+  with the same `typelize`/`attribute` pairs, were reported as duplication whose
+  only fix was to hide the schema behind a class method. A fragment built purely
+  from directives — receiverless calls with literal arguments — no longer
+  clusters. A block, a method, a variable, a receiver, or a branch anywhere in
+  the fragment makes it code again.
+
 ## [0.8.0] - 2026-08-15
 
 ### Added

data/README.md

@@ -288,6 +288,12 @@ it does inside Ruby:
 - **Lists aren't clones.** A run of identically shaped statements — a require
   block, a routes file, a column of registrations — is skipped, so windows cut
   out of one don't report a match at every offset.
+- **Declarations aren't clones either.** A fragment built only from directives —
+  receiverless macro calls with literal arguments, the `has_many` /
+  `validates` / `attribute` spine of a model or a serializer — is a schema, not
+  copied logic; extracting it only hides what the class declares. Two models
+  that open the same way are two models. As soon as a fragment carries logic —
+  a block, a method, a variable, a receiver, a branch — it counts again.
 - **Clusters, not pairs.** All copies of one thing collapse into a single
   finding with N sites, so the report reads as "fix this once," not a wall of
   pairwise matches.
@@ -334,7 +340,9 @@ What each one catches:
   the method" needs a destination you own.
 - **boundary_sprawl** — 12+ methods across 3+ files each type-guard against the
   same foreign root (`Prism`, `ActiveRecord`, ...). One method inspecting a
-  foreign type is a fact of life; a sprawl of them is a missing adapter.
+  foreign type is a fact of life; a sprawl of them usually means a missing
+  adapter. An analyzer or interpreter which deliberately understands a foreign
+  data model can declare and verify that boundary instead.
 - **utility_function** — a public instance method that touches no instance state;
   it isn't really a method of this class. Private stateless helpers are fine, and
   `module_function` modules are exempt — that's what they're for.
@@ -342,14 +350,22 @@ What each one catches:
   caller already knew which branch it wanted.
 - **data_clump** — the same two-plus parameters travel through three or more
   methods; a value object is missing.
-- **duplicate_method_call** — the identical receiver-and-arguments call repeated
-  inside one method; name the result once.
+- **repeated_call** — the identical receiver-and-arguments call repeated
+  inside one method; name the result once. Quiet wherever naming it would be
+  wrong: calls that mint a fresh value every time (`"".b`, `rand`, `dup`,
+  `SecureRandom.hex`) are meant to differ, and a repeat no single run can reach
+  twice — the two arms of an `if`, two `when` branches, a body and its `rescue`
+  — has nothing to hoist.
 - **repeated_conditional** — one class testing the same condition in three or
   more places; polymorphism is overdue.
-- **too_many_instance_variables** — more than four per class. Memoization
+- **state_sprawl** — more than four per class. Memoization
   (`@x ||=`) doesn't count as state.
-- **instance_variable_assumption** — an ivar read that no `initialize` ever
-  assigns; the reader is assuming another method ran first.
+- **assumed_state** — an ivar read that nothing the class can
+  reach ever assigns: not `initialize`, not another of its own methods, not an
+  `attr_writer`, not a reopening of the class, not a module it mixes in or a
+  class it inherits. Usually a typo, or state some other object is expected to
+  install. Silent when the class inherits or includes something the codebase
+  can't see, because the assignment may live in there.
 - **manual_dispatch** — `respond_to?` then send: a type check wearing a duck
   costume.
 - **module_initialize** — `initialize` in a mixin; construction order becomes
@@ -460,6 +476,17 @@ WORSE FINDING (was 13, now 24):
 Baselines written by earlier versions still work: they record identity only, so
 they ratchet on appearance until the next `--update-baseline` records magnitudes.
 
+It also records a *trace* of each finding — the file it sits in and what it says,
+with the line numbers left out. A finding is keyed by what it names
+(`Class#method`), so renaming a class, or adding a `?` to four predicates, would
+otherwise report every finding under it as resolved and new in the same breath.
+When a key disappears and another appears carrying the same trace, the ratchet
+reads them as one finding that changed name. The match is one for one: a rename
+that *brought* a new finding with it still fails, and a renamed method that also
+got more complex still reports WORSE. Moving the file changes the trace, because
+that is a relocation rather than a rename — re-record it. Baselines without
+traces behave exactly as they did before.
+
 A regression prints in full, with the evidence that introduced it:
 
 ```console
@@ -522,6 +549,34 @@ English, so the codes are distinct:
 baseline is stale. Failing on `1` while treating `3` as a nudge lets a build
 block regressions without blocking progress.
 
+### Declaring interpreted models
+
+Some foreign models are the subject of the program rather than a dependency to
+hide. A compiler interprets an AST; a serializer interprets a schema. Declare
+that architecture in the baseline instead of accepting a `boundary_sprawl`
+finding:
+
+```json
+"boundaries": [
+  {
+    "root": "Prism",
+    "role": "interpreted_model",
+    "entrypoint": "lib/my_tool/trees.rb",
+    "reason": "the Prism AST is the input model"
+  }
+]
+```
+
+Type dispatch over that root no longer counts as boundary sprawl. The
+declaration is checked, not waived: the root API must be called, every such call
+must go through the named entrypoint, and every field needs a value. A missing,
+unknown, unused, or bypassed declaration exits as misuse. `--update-baseline`
+preserves declarations.
+
+This is deliberately narrower than acceptance. A declared boundary says what
+architecture the project conforms to; an accepted finding records why a real
+violation is allowed to remain.
+
 ### Accepting by design
 
 Anything deliberate goes in the baseline with a reason. It leaves reports and

data/exe/hashira

@@ -6,4 +6,4 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 require "hashira"
 
-exit Hashira::CLI.new(ARGV).status
+exit Hashira::CLI::Session.new(ARGV).status

data/lib/hashira/analysis/finding.rb

@@ -4,6 +4,8 @@ module Hashira
   module Analysis
     MAGNITUDES = { "complexity" => :cognitive, "duplication" => :mass, "boundary_sprawl" => :count }.freeze
 
+    TRACKS = [/ \(lines? [\d, ]+\)/, /:[\d, -]+\z/, /:\d+(?=:)/].freeze
+
     Finding =
       Data.define(:kind, :package, :detail, :evidence, :cycle, :digest) do
         def initialize(cycle: nil, digest: nil, detail: nil, **rest) = super
@@ -14,6 +16,14 @@ module Hashira
 
         def identity = digest || package
 
+        def trace
+          "#{kind}|#{plain(site)}|#{evidence.map { plain(it) }.join(";")}" unless digest
+        end
+
+        def site = detail.to_h[:site].to_s
+
+        def plain(text) = TRACKS.reduce(text) { |left, mark| left.gsub(mark, "") }
+
         def to_h = super.merge(detail: detail&.to_h).compact
       end
   end

data/lib/hashira/analysis/type_walk.rb

@@ -7,6 +7,10 @@ module Hashira
     module TypeWalk
       module_function
 
+      def roots(trees)
+        trees.each_value.with_object(Set.new) { |tree, set| each(tree) { |_node, full| set << full } }
+      end
+
       def each(node, stack = [], roots: nil, &)
         return descend(node, stack, roots, &) unless type?(node)
         full = Syntax.anchor(stack, Syntax.segments(node.constant_path), roots)

data/lib/hashira/boundaries.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Boundaries
+  ROLE = "interpreted_model"
+
+  Declaration =
+    Data.define(:root, :role, :entrypoint, :reason) do
+      def verify
+        missing = members.find { !present?(public_send(it)) }
+        root, role, _entrypoint, _reason = deconstruct
+        raise(Hashira::Error, "boundary #{root || "(unknown)"} #{missing} is missing") if missing
+        raise(Hashira::Error, "boundary #{root} has unknown role #{role.inspect}") unless role == Hashira::Boundaries::ROLE
+      end
+      private
+      def present?(value) = value.is_a?(String) && !value.empty?
+    end
+
+  def initialize(records, trees)
+    @records = records
+    @trees = trees
+  end
+
+  def interpreted
+    return @_interpreted if @_interpreted
+    verify
+    @_interpreted = entries.map(&:root)
+  end
+
+  private
+
+  def entries = @_entries ||= @records.map { declaration(it) }
+
+  def declaration(record)
+    raise(Hashira::Error, "boundary declaration is not an object") unless record.is_a?(Hash)
+    Declaration.new(*%w[root role entrypoint reason].map { record[it] })
+  end
+
+  def verify
+    entries.each do
+      it.verify
+      route(it)
+    end
+  end
+
+  def route(entry)
+    root, _role, entrypoint, _reason = entry.deconstruct
+    files = calls(root)
+    raise(Hashira::Error, "boundary #{root} has no root calls") if files.empty?
+    bypasses = files.reject { same?(it, entrypoint) }
+    raise(Hashira::Error, "boundary #{root} bypasses #{entrypoint}: #{bypasses.join(", ")}") unless bypasses.empty?
+  end
+
+  def calls(root)
+    @trees.filter_map { |file, tree| file if Hashira::Analysis::NodeWalk.collect(tree).any? { invocation?(it, root) } }
+  end
+
+  def invocation?(node, root)
+    node.is_a?(Prism::CallNode) && Hashira::Analysis::Syntax.segments(node.receiver).first == root
+  end
+
+  def same?(file, entrypoint) = File.expand_path(file) == File.expand_path(entrypoint)
+end

data/lib/hashira/ci/baseline.rb

@@ -3,7 +3,7 @@
 require "json"
 
 class Hashira::CI::Baseline
-  SCHEMA_VERSION = 4
+  SCHEMA_VERSION = 6
 
   def initialize(path, analyzers: [], targets: [])
     @path = path
@@ -25,10 +25,16 @@ class Hashira::CI::Baseline
 
   def findings = keyed(recorded.fetch("findings", {}))
 
+  def marks = findings.to_h { |key, magnitude| [key, Hashira::CI::Mark.new(magnitude:, trace: traces[key])] }
+
+  def traces = recorded.fetch("traces", {})
+
   def findings? = recorded.key?("findings")
 
   def accepted = recorded.fetch("accepted", [])
 
+  def boundaries = recorded.fetch("boundaries", [])
+
   def packaging = recorded.fetch("packaging", "folder")
 
   def analyzers = recorded.fetch("analyzers", wanted[:analyzers])
@@ -37,8 +43,8 @@ class Hashira::CI::Baseline
 
   def wanted = scope.to_h
 
-  def write(edges, findings, packaging:)
-    File.write(@path, JSON.pretty_generate(payload(edges, findings, packaging)) << "\n")
+  def write(edges, marks, packaging:)
+    File.write(@path, JSON.pretty_generate(payload(edges, marks, packaging)) << "\n")
   end
 
   private
@@ -57,9 +63,22 @@ class Hashira::CI::Baseline
 
   def scope = Hashira::CI::Scope.new(analyzers: @analyzers, targets: @targets)
 
-  def payload(edges, findings, packaging)
-    base = { version: SCHEMA_VERSION, packaging: }.merge(scope.to_h).merge(edges:, findings:)
-    kept = Hashira::CI::Accepted.new(accepted).entries
-    kept.empty? ? base : base.merge(accepted: kept)
+  def payload(edges, marks, packaging)
+    stem(packaging).merge(edges:, findings: sized(marks)).merge(traced(marks)).merge(kept)
+  end
+
+  def stem(packaging) = { version: SCHEMA_VERSION, packaging: }.merge(scope.to_h)
+
+  def sized(marks) = marks.transform_values(&:magnitude)
+
+  def traced(marks)
+    found = marks.transform_values(&:trace).compact
+    found.empty? ? {} : { traces: found }
   end
+
+  def kept
+    optional(:accepted, Hashira::CI::Accepted.new(accepted).entries).merge(optional(:boundaries, boundaries))
+  end
+
+  def optional(name, values) = values.empty? ? {} : { name => values }
 end

data/lib/hashira/ci/comparison.rb

@@ -7,17 +7,26 @@ class Hashira::CI::Comparison
   end
 
   def diff
-    current = @current.keys
-    recorded = @recorded.keys
-    Hashira::CI::Diff.new(added: current - recorded, removed: recorded - current, worsened:)
+    moved = renamed
+    Hashira::CI::Diff.new(added: fresh - moved.keys, removed: gone - moved.values, worsened: worsened(moved))
   end
 
   private
 
-  def worsened
-    (@current.keys & @recorded.keys).filter_map { entry(it, @recorded[it], @current[it]) }
+  def fresh = @current.keys - @recorded.keys
+
+  def gone = @recorded.keys - @current.keys
+
+  def renamed = fresh.to_h { [it, pool[@current[it].trace]&.shift] }.compact
+
+  def pool = @_pool ||= gone.group_by { @recorded[it].trace }.except(nil)
+
+  def worsened(moved)
+    paired(moved).filter_map { |key, was| entry(key, @recorded[was].magnitude, @current[key].magnitude) }
   end
 
+  def paired(moved) = (@current.keys & @recorded.keys).to_h { [it, it] }.merge(moved)
+
   def entry(key, before, after)
     [key, before, after] if before.is_a?(Integer) && after.is_a?(Integer) && after > before
   end

data/lib/hashira/ci/{edge_diff_report.rb → edge_changes.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class Hashira::CI::EdgeDiffReport
+class Hashira::CI::EdgeChanges
   def initialize(graph, io: $stdout)
     @graph = graph
     @io = io

data/lib/hashira/ci/{finding_diff_report.rb → finding_changes.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class Hashira::CI::FindingDiffReport
+class Hashira::CI::FindingChanges
   def initialize(findings, io: $stdout)
     @findings = findings
     @io = io

data/lib/hashira/ci/mark.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Hashira
+  module CI
+    Mark = Data.define(:magnitude, :trace)
+  end
+end

data/lib/hashira/ci/ratchet.rb

@@ -63,9 +63,11 @@ class Hashira::CI::Ratchet
   def tally(compared) = compared.counts("#{@graph.edges.size} edges", "#{@findings.size} findings").join(", ")
 
   def scored
-    @_scored ||= @findings.group_by(&:signature).sort.to_h { |key, group| [key, group.filter_map(&:magnitude).max] }
+    @_scored ||= @findings.group_by(&:signature).sort.to_h { |key, group| [key, mark(group)] }
   end
 
+  def mark(group) = Hashira::CI::Mark.new(magnitude: group.filter_map(&:magnitude).max, trace: group.first.trace)
+
   def drift = Hashira::CI::Diff.new(added: fresh, removed: @baseline.edges - edges)
 
   def fresh = @graph.edges.reject { @baseline.edges.include?(it.to_s) }

data/lib/hashira/ci/ratchet_report.rb

@@ -26,8 +26,8 @@ class Hashira::CI::RatchetReport
   def verdict(*diffs) = diffs.compact.any?(&:worse?) ? Hashira::CI::Status::WORSE : Hashira::CI::Status::BETTER
 
   def details(edges, findings)
-    Hashira::CI::EdgeDiffReport.new(@graph, io: @io).print(edges)
-    Hashira::CI::FindingDiffReport.new(@findings, io: @io).print(findings) if findings
+    Hashira::CI::EdgeChanges.new(@graph, io: @io).print(edges)
+    Hashira::CI::FindingChanges.new(@findings, io: @io).print(findings) if findings
   end
 
   def advice(*diffs)

data/lib/hashira/ci/slice.rb

@@ -9,9 +9,13 @@ class Hashira::CI::Slice
 
   def edges(_diff) = SETTLED
 
-  def findings(scored) = Hashira::CI::Comparison.new(scored, seen(scored)).diff
-
-  def seen(scored) = @baseline.findings.slice(*scored.keys)
+  def findings(marks) = Hashira::CI::Comparison.new(marks, seen(marks, traces(marks))).diff.with(removed: [])
 
   def counts(_edges, findings) = [findings]
+
+  private
+
+  def traces(marks) = marks.each_value.filter_map(&:trace)
+
+  def seen(marks, traces) = @baseline.marks.select { |key, mark| marks.key?(key) || traces.include?(mark.trace) }
 end

data/lib/hashira/ci/sweep.rb

@@ -7,7 +7,7 @@ class Hashira::CI::Sweep
 
   def edges(diff) = diff
 
-  def findings(scored) = Hashira::CI::Comparison.new(scored, @baseline.findings).diff
+  def findings(marks) = Hashira::CI::Comparison.new(marks, @baseline.marks).diff
 
   def counts(edges, findings) = [edges, findings]
 end

data/lib/hashira/cli/flag.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class Hashira::CLI
+module Hashira::CLI
   BLANK = %i[arg field parse mode].to_h { [it, nil] }.freeze
 
   Flag =

data/lib/hashira/cli/flags.rb

@@ -8,7 +8,7 @@ require_relative "package_by"
 require_relative "skip"
 require_relative "top"
 
-class Hashira::CLI
+module Hashira::CLI
   FLAGS = [
     Flag.new(
       name: "--format", arg: "FORMAT", parse: Format, mode: :parsed,

data/lib/hashira/cli/options.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class Hashira::CLI
+module Hashira::CLI
   Options =
     Data.define(:directories, :mode, :baseline, :fail_on, :skip, :only, :packaging, :top, :compact) do
       def self.parse(argv) = CommandLine.new(argv).options
@@ -13,13 +13,23 @@ class Hashira::CLI
       end
 
       def pipeline
-        chosen = Hashira::Project.new(directories)
-        told = Hashira::Report::Notices.new
-        told.scanning(chosen.files.size)
-        told.rails if directories.empty? && File.exist?("config/application.rb")
-        Hashira::Pipeline.new(chosen, enabled: analyzers, packaging:, only:)
+        chosen = Hashira::Project.new(directories, boundaries: decisions.boundaries)
+        announce(chosen)
+        Hashira::Pipeline.new(chosen, enabled: analyzers, packaging:, only:).verify
       end
 
       def analyzers = Hashira::Pipeline::ANALYZERS - skip
+      private
+      def decisions
+        recorded = Hashira::CI::Baseline.new(baseline)
+        raise(Hashira::Error, recorded.trouble) if recorded.trouble
+        recorded
+      end
+
+      def announce(project)
+        told = Hashira::Report::Notices.new
+        told.scanning(project.files.size)
+        told.rails if directories.empty? && File.exist?("config/application.rb")
+      end
     end
 end

data/lib/hashira/cli/run.rb

@@ -17,12 +17,7 @@ class Hashira::CLI::Run
 
   def findings = @_findings ||= accepted.screen(@pipeline.findings)
 
-  def accepted
-    path = @options.baseline
-    stop = Hashira::CI::Baseline.new(path).trouble
-    raise(Hashira::Error, stop) if stop
-    Hashira::CI::Accepted.build(path)
-  end
+  def accepted = Hashira::CI::Accepted.build(@options.baseline)
 
   def update
     ratchet.update

data/lib/hashira/{cli.rb → cli/session.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class Hashira::CLI
+class Hashira::CLI::Session
   MISUSE = 2
   BROKEN = 70
 
@@ -9,7 +9,7 @@ class Hashira::CLI
   end
 
   def status
-    dispatch(Options.parse(@argv))
+    dispatch(Hashira::CLI::Options.parse(@argv))
   rescue Hashira::Error => error
     failure(error)
   rescue StandardError => error
@@ -18,14 +18,16 @@ class Hashira::CLI
 
   private
 
-  def dispatch(options) = usage?(options) ? Usage.public_send(options.mode) : timed(options)
+  def dispatch(options)
+    usage?(options) ? Hashira::CLI::Usage.public_send(options.mode) : timed(options)
+  end
 
-  def usage?(options) = Usage::PAGES.include?(options.mode)
+  def usage?(options) = Hashira::CLI::Usage::PAGES.include?(options.mode)
 
   def timed(options)
     started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
     pipeline = options.pipeline
-    Run.new(pipeline, options).status.tap do
+    Hashira::CLI::Run.new(pipeline, options).status.tap do
       Hashira::Report::Notices.new.finished(pipeline.project.files.size, elapsed(started))
     end
   end

data/lib/hashira/coupling/{cycle_findings.rb → cycle.rb}

@@ -2,7 +2,7 @@
 
 require_relative "rule"
 
-class Hashira::Coupling::CycleFindings < Hashira::Coupling::Rule
+class Hashira::Coupling::Cycle < Hashira::Coupling::Rule
   KIND = "cycle"
 
   def list

data/lib/hashira/coupling/definitions.rb

@@ -14,16 +14,10 @@ class Hashira::Coupling::Definitions
 
   def packages = @trees.keys.map { @project.package(it) }.uniq
 
-  def roots
-    @_roots ||= @trees.each_value.with_object(Set.new) { |tree, set| survey(tree, set) }
-  end
+  def roots = @_roots ||= Hashira::Analysis::TypeWalk.roots(@trees)
 
   private
 
-  def survey(tree, set)
-    Hashira::Analysis::TypeWalk.each(tree) { |_node, full| set << full }
-  end
-
   def scan(file, tree)
     package = @project.package(file)
     Hashira::Analysis::TypeWalk.each(tree, roots: roots) do |node, full|

data/lib/hashira/coupling/{roll_call_findings.rb → echo.rb}

@@ -2,7 +2,7 @@
 
 require_relative "rule"
 
-class Hashira::Coupling::RollCallFindings < Hashira::Coupling::Rule
+class Hashira::Coupling::Echo < Hashira::Coupling::Rule
   KIND = "roll_call"
 
   def list = rolls.map { entry(it) }

data/lib/hashira/coupling/{sdp_violation_findings.rb → imbalance.rb}

@@ -2,10 +2,10 @@
 
 require_relative "rule"
 
-class Hashira::Coupling::SdpViolationFindings < Hashira::Coupling::Rule
+class Hashira::Coupling::Imbalance < Hashira::Coupling::Rule
   KIND = "sdp_violation"
 
-  Imbalance = Data.define(:from, :to, :from_instability, :to_instability)
+  Gap = Data.define(:from, :to, :from_instability, :to_instability)
 
   def list
     ranked.map { |from, to| violation(from, to) }
@@ -20,7 +20,7 @@ class Hashira::Coupling::SdpViolationFindings < Hashira::Coupling::Rule
   end
 
   def detail(from, to)
-    Imbalance.new(from:, to:, from_instability: instability(from), to_instability: instability(to))
+    Gap.new(from:, to:, from_instability: instability(from), to_instability: instability(to))
   end
 
   def instability(package) = metrics[package].instability