hashira 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53480df33daebb25ecac87a601cad36cc6a3d8657a5ccb3cd094c807e1be2c15
-  data.tar.gz: 6034a5afdfa48254a48b989405aed85e8e1d6c4f82dea35649d714edd8ed38ee
+  metadata.gz: 2750af6be7a5e6885421144e92ab4c12e554ece76c110b76d5fd2b52b72a2411
+  data.tar.gz: b2ab7386f4907e297b3cfc623b535808df4f6865423bd9d4f8bae4b487b81317
 SHA512:
-  metadata.gz: 915f8ea2649037c29a4971d4ebc3df94d38c6a976fd4f0792e3e2c80e3c54d23b776a3a511c0dd5fa7552cbbd6463282e9fcd31ba5e510c2a87d82aafbfb6310
-  data.tar.gz: 9b17e6bbc1625f7ed54d02eeb7ba8f345451c931e24cf39bd057bc8a06e92d11167d35a0bd1b883b75750aa533fdb39a1513dcb4359929c86d2cb0e21e285cdd
+  metadata.gz: 6a4c401b5d242175899bcf4e1e6792f74b77139346b336564c2496e1b97dd716b5014f147b94fbc076b1870020893c8d99b8f08dadd0ef5e648fa427a6fb3a91
+  data.tar.gz: 812c604c2cafe644d8ab0692b670f74f1c63dde77a1084f235919c1eee72d1a24c53936c403f7e84c2a46c0145c4bd702c6f183e926f9d5f27135d54b366aca6

data/CHANGELOG.md

@@ -5,6 +5,100 @@ 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.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
+
+- **`--only PATHS` narrows the findings to the files you name.** Meant for
+  hooks: after a formatter, a refactor, or an agent's edit, ask whether *these*
+  files got worse — `hashira --only "$CHANGED" --ratchet`. The whole project is
+  still parsed, because half of what hashira knows is cross-file (which
+  constants are yours, which methods reach into a neighbour, which fragments
+  are clones); reading one file alone would answer differently. A focused
+  ratchet stays quiet about package edges, which belong to no single file, and
+  about findings that disappeared, which only a whole-project run can confirm —
+  it reports what your files introduced or made worse. `--only` refuses
+  `--update-baseline` and the diagram formats, and ignores paths outside the
+  analyzed directories so a hook can hand it every changed file.
+
+### Changed
+
+- **Memoization stops reading as state.** An instance variable named `@_thing`
+  is a cache, not a responsibility: `instance_variable_assumption` no longer
+  reports lazy presence as an assumption, and `too_many_instance_variables`
+  no longer counts derived values against the class. Codebases that memoize
+  behind the `@_` convention will see both smells quieten; codebases that
+  don't are unaffected.
+- **Every object is built the way this tool says to build one.** Constructors
+  only assign, class-method logic dissolves into instances (`Project.detect`
+  and `CLI.run` are plain constructors — `exe/hashira` now calls
+  `CLI.new(argv).status`), factories are named `build`, and hashes acting as
+  objects got names (`SdpViolationFindings::Imbalance`,
+  `DuplicationFinding::Overlap`, `MethodFinding::Effort`). Internal
+  throughout: the command line, the reports, the JSON, and the baseline
+  format are unchanged. Only embedders calling the Ruby API directly are
+  affected.
+- Coupling reads its rule list from `Rule.subclasses`, the way the smells
+  report already read `Check.subclasses`, and parameters stop carrying their
+  node type (`def_node` → `definition`). hashira's own baseline is down to
+  zero findings and one accepted boundary.
+
 ## [0.7.0] - 2026-08-10
 
 ### 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.
@@ -343,13 +349,21 @@ What each one catches:
 - **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.
+  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
   (`@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.
+- **instance_variable_assumption** — 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 +474,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
@@ -476,6 +501,35 @@ record the decision: update the baseline, or accept it with a reason.
 Improvements fail the build too, and say so cheerfully — an unrecorded gain is one
 the next commit can quietly undo. Re-run `--update-baseline` to lock it in.
 
+### Hooks: ratchet the files you just touched
+
+`--only` narrows the findings to the files you name, so an editor hook, a
+pre-commit hook, or an agent finishing an edit can ask the one question that
+matters there: *did these files get worse?*
+
+```sh
+hashira --only lib/billing/refund.rb,lib/orders/checkout.rb --ratchet
+hashira --only "$(git diff --cached --name-only -- '*.rb' | paste -sd, -)" --ratchet
+```
+
+The whole project is still parsed — that is the point. Half of what hashira knows
+is cross-file (which constants are yours, which methods pick apart a neighbour's
+internals, which fragments are clones of each other), so a file read alone would
+answer differently. `--only` narrows the *report*, never the analysis. On this
+repository a full run is under a second for 129 files; smells alone, a quarter of
+that.
+
+Two things a focused run cannot judge, and so stays quiet about: package edges,
+which belong to no single file, and findings that *disappeared*, which you would
+have to read the whole project to be sure of. It reports what your files
+introduced or made worse, and nothing else. Run the unfocused `--ratchet` in CI —
+that is where removals get celebrated and the baseline gets relocked.
+
+`--only` refuses to combine with `--update-baseline` (which would record a
+baseline missing everything you did not name) or with the diagram formats (which
+draw the graph, not the findings). Paths outside the analyzed directories are
+ignored, so a hook can hand it every changed file without filtering first.
+
 ### Exit codes
 
 A build step should be able to tell a regression from a typo without grepping

data/exe/hashira

@@ -6,4 +6,4 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 require "hashira"
 
-exit Hashira::CLI.run(ARGV)
+exit Hashira::CLI.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,7 +16,15 @@ module Hashira
 
         def identity = digest || package
 
-        def to_h = super.compact
+        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
 end

data/lib/hashira/analysis/syntax.rb

@@ -17,10 +17,10 @@ module Hashira
 
       def label(node) = [node.name.to_s]
 
-      def cbase?(node)
+      def rooted?(node)
         return false unless node.is_a?(Prism::ConstantPathNode)
         parent = node.parent
-        !parent || cbase?(parent)
+        !parent || rooted?(parent)
       end
 
       def anchor(stack, segments, roots)
@@ -33,12 +33,12 @@ module Hashira
         roots.include?(segments.first(1)) ? segments : (stack.last || []) + segments
       end
 
-      def direct(type_node) = statements(type_node).grep(Prism::DefNode)
+      def direct(type) = statements(type).grep(Prism::DefNode)
 
-      def constants(type_node) = statements(type_node).grep(Prism::ConstantWriteNode)
+      def constants(type) = statements(type).grep(Prism::ConstantWriteNode)
 
-      def statements(type_node)
-        body = type_node.body
+      def statements(type)
+        body = type.body
         body.is_a?(Prism::StatementsNode) ? body.body : [body]
       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/churn.rb

@@ -1,18 +1,9 @@
 # frozen_string_literal: true
 
 class Hashira::Churn
-  LOG = %w[log --no-renames --name-only --format=].freeze
   SITES_THAT_DRIFT_APART = 2
 
-  def self.scan(directory) = new(tally(read(directory)))
-
-  def self.read(directory)
-    IO.popen(["git", "-C", directory, *LOG], err: File::NULL, &:read)
-  rescue SystemCallError
-    ""
-  end
-
-  def self.tally(output) = output.split("\n").map(&:strip).reject(&:empty?).tally
+  def self.build(directory) = new(Hashira::GitLog.new(directory).counts)
 
   def initialize(counts)
     @counts = counts

data/lib/hashira/ci/accepted.rb

@@ -7,7 +7,7 @@ class Hashira::CI::Accepted
 
   Entry =
     Data.define(:kind, :package, :digest, :reason) do
-      def self.from(hash)
+      def self.build(hash)
         new(kind: hash["kind"], package: hash["package"], digest: hash["digest"], reason: hash["reason"])
       end
 
@@ -17,16 +17,16 @@ class Hashira::CI::Accepted
 
       def label = reason || "accepted (no reason recorded)"
 
-      def to_h = { kind:, package:, digest:, reason: }.compact
+      def to_h = super.compact
     end
 
-  def self.load(path) = new(Hashira::CI::Baseline.read(path).fetch("accepted", []))
+  def self.build(path) = new(Hashira::CI::Baseline.new(path).accepted)
 
-  def initialize(entries)
-    @entries = entries.map { Entry.from(it) }
+  def initialize(list)
+    @list = list
   end
 
-  def entries = @entries.map(&:to_h)
+  def entries = records.map(&:to_h)
 
   def screen(findings)
     accepted, live = findings.map { [it, reason(it)] }.partition(&:last)
@@ -35,7 +35,9 @@ class Hashira::CI::Accepted
 
   private
 
+  def records = @_records ||= @list.map { Entry.build(it) }
+
   def reason(finding)
-    @entries.find { it.matches?(finding) }&.label
+    records.find { it.matches?(finding) }&.label
   end
 end

data/lib/hashira/ci/baseline.rb

@@ -3,59 +3,79 @@
 require "json"
 
 class Hashira::CI::Baseline
-  SCHEMA_VERSION = 4
+  SCHEMA_VERSION = 5
 
-  def self.load(path, analyzers: [], targets: [])
-    new(path, read(path), Hashira::CI::Scope.new(analyzers:, targets:))
+  def initialize(path, analyzers: [], targets: [])
+    @path = path
+    @analyzers = analyzers
+    @targets = targets
   end
 
-  def self.read(path)
-    return {} unless path && File.exist?(path)
-    recorded = JSON.parse(File.read(path))
-    recorded.is_a?(Hash) ? recorded : raise(JSON::ParserError, "its top level is a list, not an object")
-  end
+  attr_reader :path
 
-  def self.trouble(path)
-    read(path) && nil
-  rescue JSON::ParserError, SystemCallError => error
-    "#{path} is not a usable baseline — #{error.message.lines.first.strip}. Re-record it with --update-baseline"
-  end
+  def exist? = File.exist?(@path)
 
-  def initialize(path, recorded, scope = Hashira::CI::Scope.none)
-    @path = path
-    @recorded = recorded
-    @scope = scope
+  def trouble
+    recorded && nil
+  rescue JSON::ParserError, SystemCallError => error
+    "#{@path} is not a usable baseline — #{error.message.lines.first.strip}. Re-record it with --update-baseline"
   end
 
-  attr_reader :path
+  def edges = recorded.fetch("edges", [])
 
-  def exist? = File.exist?(@path)
+  def findings = keyed(recorded.fetch("findings", {}))
 
-  def edges = @recorded.fetch("edges", [])
+  def marks = findings.to_h { |key, magnitude| [key, Hashira::CI::Mark.new(magnitude:, trace: traces[key])] }
 
-  def findings = self.class.scored(@recorded.fetch("findings", {}))
+  def traces = recorded.fetch("traces", {})
 
-  def self.scored(recorded) = recorded.is_a?(Array) ? recorded.to_h { [it, nil] } : recorded
+  def findings? = recorded.key?("findings")
 
-  def findings? = @recorded.key?("findings")
+  def accepted = recorded.fetch("accepted", [])
 
-  def packaging = @recorded.fetch("packaging", "folder")
+  def packaging = recorded.fetch("packaging", "folder")
 
-  def analyzers = @recorded.fetch("analyzers", wanted[:analyzers])
+  def analyzers = recorded.fetch("analyzers", wanted[:analyzers])
 
-  def targets = @recorded.fetch("targets", wanted[:targets])
+  def targets = recorded.fetch("targets", wanted[:targets])
 
-  def wanted = @scope.to_h
+  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
 
-  def payload(edges, findings, packaging)
-    base = { version: SCHEMA_VERSION, packaging:, **@scope.to_h, edges:, findings: }
-    accepted = Hashira::CI::Accepted.new(@recorded.fetch("accepted", [])).entries
-    accepted.empty? ? base : base.merge(accepted:)
+  def recorded
+    @_recorded ||= read
+  end
+
+  def read
+    return {} unless @path && File.exist?(@path)
+    stored = JSON.parse(File.read(@path))
+    stored.is_a?(Hash) ? stored : raise(JSON::ParserError, "its top level is a list, not an object")
+  end
+
+  def keyed(findings) = findings.is_a?(Array) ? findings.to_h { [it, nil] } : findings
+
+  def scope = Hashira::CI::Scope.new(analyzers: @analyzers, targets: @targets)
+
+  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
+    entries = Hashira::CI::Accepted.new(accepted).entries
+    entries.empty? ? {} : { accepted: entries }
   end
 end

data/lib/hashira/ci/comparison.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Hashira::CI::Comparison
+  def initialize(current, recorded)
+    @current = current
+    @recorded = recorded
+  end
+
+  def diff
+    moved = renamed
+    Hashira::CI::Diff.new(added: fresh - moved.keys, removed: gone - moved.values, worsened: worsened(moved))
+  end
+
+  private
+
+  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
+end

data/lib/hashira/ci/diff.rb

@@ -4,21 +4,6 @@ module Hashira
   module CI
     Diff =
       Data.define(:added, :removed, :worsened) do
-        def self.between(current, recorded)
-          new(
-            added: current.keys - recorded.keys, removed: recorded.keys - current.keys,
-            worsened: grown(current, recorded)
-          )
-        end
-
-        def self.grown(current, recorded)
-          (current.keys & recorded.keys).filter_map { entry(it, recorded[it], current[it]) }
-        end
-
-        def self.entry(key, before, after)
-          [key, before, after] if before.is_a?(Integer) && after.is_a?(Integer) && after > before
-        end
-
         def initialize(worsened: [], **) = super
         def empty? = added.empty? && removed.empty? && worsened.empty?
         def worse? = !added.empty? || !worsened.empty?

data/lib/hashira/ci/gate.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 class Hashira::CI::Gate
-  def initialize(findings, kinds, io: $stdout, err: $stderr)
+  def initialize(findings, kinds, io: $stdout, error: $stderr)
     @findings = findings
     @kinds = kinds
     @io = io
-    @err = err
+    @error = error
   end
 
   def check
@@ -19,7 +19,7 @@ class Hashira::CI::Gate
     offending.each { Hashira::Report::FindingLines.new(it, io: @io).print }
     verdict = "Gate FAILED: #{offending.size} finding(s) — #{tally(offending)}."
     @io.puts("\n#{verdict}")
-    @err.puts(verdict)
+    @error.puts(verdict)
     1
   end
 

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

@@ -14,7 +14,11 @@ class Hashira::CI::Ratchet
     Hashira::CI::Status::CLEAN
   end
 
-  def check = Hashira::CI::RatchetReport.new(@graph, @findings, io: @io).print(drift, delta)
+  def check(focus)
+    compared = focus.narrowing? ? Hashira::CI::Slice.new(@baseline) : Hashira::CI::Sweep.new(@baseline)
+    Hashira::CI::RatchetReport.new(@graph, @findings, io: @io)
+      .print(compared.edges(drift), delta(compared), tally(compared))
+  end
 
   def blocker
     return "no baseline at #{@baseline.path} — run --update-baseline first" unless @baseline.exist?
@@ -56,15 +60,19 @@ class Hashira::CI::Ratchet
 
   def edges = @graph.edges.map(&:to_s)
 
+  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) }
 
-  def delta
-    Hashira::CI::Diff.between(scored, @baseline.findings) if @baseline.findings?
+  def delta(compared)
+    compared.findings(scored) if @baseline.findings?
   end
 end

data/lib/hashira/ci/ratchet_report.rb

@@ -7,8 +7,8 @@ class Hashira::CI::RatchetReport
     @io = io
   end
 
-  def print(edges, findings)
-    return unchanged if quiet?(edges, findings)
+  def print(edges, findings, tally)
+    return unchanged(tally) if quiet?(edges, findings)
     details(edges, findings)
     advice(edges, findings)
     verdict(edges, findings)
@@ -18,8 +18,8 @@ class Hashira::CI::RatchetReport
 
   def quiet?(*diffs) = diffs.compact.all?(&:empty?)
 
-  def unchanged
-    @io.puts("Ratchet OK: #{@graph.edges.size} edges, #{@findings.size} findings, unchanged.")
+  def unchanged(tally)
+    @io.puts("Ratchet OK: #{tally}, unchanged.")
     Hashira::CI::Status::CLEAN
   end
 

data/lib/hashira/ci/scope.rb

@@ -4,7 +4,6 @@ module Hashira
   module CI
     Scope =
       Data.define(:analyzers, :targets) do
-        def self.none = new(analyzers: [], targets: [])
         def to_h = { analyzers: analyzers.map(&:to_s).sort, targets: targets.sort }
       end
   end

data/lib/hashira/ci/slice.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Hashira::CI::Slice
+  SETTLED = Hashira::CI::Diff.new(added: [], removed: [])
+
+  def initialize(baseline)
+    @baseline = baseline
+  end
+
+  def edges(_diff) = SETTLED
+
+  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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Hashira::CI::Sweep
+  def initialize(baseline)
+    @baseline = baseline
+  end
+
+  def edges(diff) = diff
+
+  def findings(marks) = Hashira::CI::Comparison.new(marks, @baseline.marks).diff
+
+  def counts(edges, findings) = [edges, findings]
+end