rigortype 0.2.7 → 0.2.8

data/lib/rigor/cli/docs_command.rb

@@ -4,33 +4,25 @@ require_relative "command"
 
 module Rigor
   class CLI
-    # `rigor docs` — serve the documentation bundled with the
-    # `rigortype` gem OFFLINE (ADR-74). The skills (`rigor skill <name>`)
-    # already ride in the gem; this is the doc twin, so once Rigor is
-    # installed an agent can read the guidance the SKILL-driven UX routes
-    # to without the network. The canonical web copy is
-    # rigor.typedduck.fail/llms.txt; the gem ships `docs/install.md`,
-    # `docs/llms.txt`, and the full user-facing **manual** and
-    # **handbook** (the drive-Rigor chapters — the contributor-facing
-    # ADR / spec / notes corpus stays web-only).
+    # `rigor docs` — serve the documentation bundled with the `rigortype` gem OFFLINE (ADR-74). The skills (`rigor skill
+    # <name>`) already ride in the gem; this is the doc twin, so once Rigor is installed an agent can read the guidance
+    # the SKILL-driven UX routes to without the network. The canonical web copy is rigor.typedduck.fail/llms.txt; the
+    # gem ships `docs/install.md`, `docs/llms.txt`, and the full user-facing **manual** and **handbook** (the
+    # drive-Rigor chapters — the contributor-facing ADR / spec / notes corpus stays web-only).
     #
-    # Grammar (mirrors `rigor skill`): the positional slot is always a
-    # doc *name*; alternative outputs are flags, so a page named `list`
-    # or `path` can never be shadowed by a verb.
+    # Grammar (mirrors `rigor skill`): the positional slot is always a doc *name*; alternative outputs are flags, so a
+    # page named `list` or `path` can never be shadowed by a verb.
     #
     # - `rigor docs`                  — print the bundled `llms.txt` index.
     # - `rigor docs <name>`           — print a doc page to stdout.
     # - `rigor docs --path <name>`    — one-line absolute path, for a Read tool.
     # - `rigor docs --list [<cat>]`   — table of name + path (optionally one category).
     #
-    # `<name>` resolves a category-qualified path (`handbook/03-narrowing`),
-    # a prefixed basename (`03-narrowing`), or a short name (`narrowing`,
-    # when it is unique across categories).
+    # `<name>` resolves a category-qualified path (`handbook/03-narrowing`), a prefixed basename (`03-narrowing`), or a
+    # short name (`narrowing`, when it is unique across categories).
     #
-    # The pre-v0.3.0 verb spellings `rigor docs list` / `rigor docs path
-    # <name>` still work but emit a stderr deprecation notice; they are
-    # removed in v0.3.0 (see docs/ROADMAP.md § "Scheduled CLI
-    # deprecations").
+    # The pre-v0.3.0 verb spellings `rigor docs list` / `rigor docs path <name>` still work but emit a stderr
+    # deprecation notice; they are removed in v0.3.0 (see docs/ROADMAP.md § "Scheduled CLI deprecations").
     class DocsCommand < Command
       USAGE = <<~USAGE
         Usage: rigor docs [<name>] [--path <name>] [--list [<category>]]
@@ -60,16 +52,14 @@ module Rigor
           rigor docs path <name>    ->  rigor docs --path <name>
       USAGE
 
-      # The bundled docs live at `<gem_root>/docs/`. From
-      # `lib/rigor/cli/docs_command.rb` that is three directories up.
+      # The bundled docs live at `<gem_root>/docs/`. From `lib/rigor/cli/docs_command.rb` that is three directories up.
       DOCS_ROOT = File.expand_path("../../../docs", __dir__)
       MANUAL_ROOT = File.join(DOCS_ROOT, "manual")
       HANDBOOK_ROOT = File.join(DOCS_ROOT, "handbook")
       LLMS_INDEX = File.join(DOCS_ROOT, "llms.txt")
 
-      # The verb subcommands the flags superseded keep working with a
-      # stderr deprecation notice until this version drops them. Each maps
-      # to the canonical advice printed and the flag it rewrites to.
+      # The verb subcommands the flags superseded keep working with a stderr deprecation notice until this version drops
+      # them. Each maps to the canonical advice printed and the flag it rewrites to.
       LEGACY_VERB_REMOVAL = "v0.3.0"
       LEGACY_VERBS = {
         "list" => { old: "list",        advice: "--list",        flag: "--list" },
@@ -102,8 +92,8 @@ module Rigor
 
       private
 
-      # Translate a deprecated verb spelling into its flag form, warning
-      # once on stderr, so the dispatch above only handles canonical forms.
+      # Translate a deprecated verb spelling into its flag form, warning once on stderr, so the dispatch above only
+      # handles canonical forms.
       def rewrite_legacy_verb!
         spec = LEGACY_VERBS[@argv.first]
         return unless spec
@@ -154,9 +144,8 @@ module Rigor
         doc = resolve_doc(name)
         return doc if doc.is_a?(Integer) # error status, already reported
 
-        # ASCII-only provenance header: the doc body is read with the
-        # external encoding (US-ASCII under a C locale), so a UTF-8 header
-        # would set the output buffer to UTF-8 and clash with the body.
+        # ASCII-only provenance header: the doc body is read with the external encoding (US-ASCII under a C locale), so
+        # a UTF-8 header would set the output buffer to UTF-8 and clash with the body.
         @out.puts("<!-- rigor docs #{doc.fetch(:name)} (rigortype #{Rigor::VERSION}, offline) -->")
         @out.puts
         @out.write(File.read(doc.fetch(:path)))
@@ -173,9 +162,8 @@ module Rigor
         0
       end
 
-      # Resolve a query to a single doc. Exact relative-path and
-      # prefixed-basename aliases are unique; a short (prefix-stripped)
-      # name is accepted only when one category owns it.
+      # Resolve a query to a single doc. Exact relative-path and prefixed-basename aliases are unique; a short
+      # (prefix-stripped) name is accepted only when one category owns it.
       #
       # @return [Hash, Integer] the doc entry, or an error exit status
       #   after the error has been written to `@err`.
@@ -193,10 +181,8 @@ module Rigor
         end
       end
 
-      # Every bundled doc, each carrying the aliases `rigor docs <name>`
-      # accepts and the category used by `--list`. `install.md` sits at
-      # the docs root (category `guide`); the rest are manual / handbook
-      # chapters.
+      # Every bundled doc, each carrying the aliases `rigor docs <name>` accepts and the category used by `--list`.
+      # `install.md` sits at the docs root (category `guide`); the rest are manual / handbook chapters.
       def discover_docs
         paths = [File.join(DOCS_ROOT, "install.md")]
         paths += Dir.glob(File.join(MANUAL_ROOT, "**", "*.md")) # Dir.glob is already sorted
@@ -215,11 +201,11 @@ module Rigor
           relative: relative,
           path: path,
           category: category,
-          # Always-unique addresses: the `docs/`-relative path and the
-          # prefixed basename. `handbook/03-narrowing` and `03-narrowing`.
+          # Always-unique addresses: the `docs/`-relative path and the prefixed basename. `handbook/03-narrowing` and
+          # `03-narrowing`.
           exact_aliases: [relative, base].uniq,
-          # The prefix-stripped short name (`narrowing`); ambiguous when
-          # two categories carry the same chapter slug (`plugins`).
+          # The prefix-stripped short name (`narrowing`); ambiguous when two categories carry the same chapter slug
+          # (`plugins`).
           short_name: short
         }
       end

data/lib/rigor/cli/doctor_command.rb

@@ -18,14 +18,13 @@ require_relative "options"
 
 module Rigor
   class CLI
-    # `rigor doctor` — classify existing project findings into setup-problem
-    # vs clean-run with a routed next action (ADR-77 WD1).
+    # `rigor doctor` — classify existing project findings into setup-problem vs clean-run with a routed next action
+    # (ADR-77 WD1).
     #
     # It is a presentation/aggregation layer over data `rigor check` already
     # produces — no new analysis pass and no new diagnostic rule.  The
-    # command runs a scoped analysis to gather stats, audits the
-    # configuration, validates plugins, and checks baseline drift, then
-    # reports a small fixed set of checks with a hint for each failure.
+    # command runs a scoped analysis to gather stats, audits the configuration, validates plugins, and checks baseline
+    # drift, then reports a small fixed set of checks with a hint for each failure.
     class DoctorCommand < Command # rubocop:disable Metrics/ClassLength
       USAGE = "Usage: rigor doctor [options]"
 
@@ -100,8 +99,8 @@ module Rigor
       end
 
       # ------------------------------------------------------------------
-      # Individual checks — each returns an Array of finding Hashes.
-      # A finding has: :check, :status (:pass/:fail/:warn), :message, :hint
+      # Individual checks — each returns an Array of finding Hashes. A finding has: :check, :status (:pass/:fail/:warn),
+      # :message, :hint
       # ------------------------------------------------------------------
 
       def audit_config(configuration)
@@ -219,8 +218,8 @@ module Rigor
         ]
       end
 
-      # True when Rails is in Gemfile.lock but the config enables no
-      # Rails plugin — the same probe {ProjectStateProbe} uses.
+      # True when Rails is in Gemfile.lock but the config enables no Rails plugin — the same probe {ProjectStateProbe}
+      # uses.
       def rails_unconfigured?(_configuration)
         config_path = Configuration.discover
         return false if config_path.nil?

data/lib/rigor/cli/explain_command.rb

@@ -8,16 +8,13 @@ require_relative "command"
 
 module Rigor
   class CLI
-    # Executes `rigor explain <rule>`. Prints the catalog entry for
-    # one canonical rule id, a legacy alias, or a family wildcard
-    # (`call`, `flow`, `assert`, `dump`, `def`).
+    # Executes `rigor explain <rule>`. Prints the catalog entry for one canonical rule id, a legacy alias, or a family
+    # wildcard (`call`, `flow`, `assert`, `dump`, `def`).
     #
     # Without arguments lists every rule's id and one-line summary.
     #
-    # The command is read-only: no parser, no analyzer, no I/O
-    # beyond the rendered catalog. Useful when a user sees a
-    # diagnostic in the editor and wants to know what the rule
-    # means without leaving the terminal.
+    # The command is read-only: no parser, no analyzer, no I/O beyond the rendered catalog. Useful when a user sees a
+    # diagnostic in the editor and wants to know what the rule means without leaving the terminal.
     class ExplainCommand < Command
       USAGE = "Usage: rigor explain [options] [<rule>]"
 

data/lib/rigor/cli/fused_protection_renderer.rb

@@ -4,11 +4,10 @@ require "json"
 
 module Rigor
   class CLI
-    # Renders a {FusedProtectionReport} (ADR-70) as text or JSON. The text form
-    # leads with the fused protected ratio (caught by *either* a type or a test),
-    # splits it into the two axes, then lists the unprotected breakages ("add a
-    # type or a test here") and the least-protected files. The framing is always
-    # *where to add protection*, never "your code is broken".
+    # Renders a {FusedProtectionReport} (ADR-70) as text or JSON. The text form leads with the fused protected ratio
+    # (caught by *either* a type or a test), splits it into the two axes, then lists the unprotected breakages ("add a
+    # type or a test here") and the least-protected files. The framing is always *where to add protection*, never "your
+    # code is broken".
     class FusedProtectionRenderer
       TOP_CALLS = 15
       TOP_FILES = 10

data/lib/rigor/cli/fused_protection_report.rb

@@ -2,15 +2,13 @@
 
 module Rigor
   class CLI
-    # ADR-70 — aggregates per-file {Protection::MutationScanner::FusedFileResult}
-    # into a project-level **fused** protection report: how many type-visible
-    # breakages were caught by the type checker, how many of the *type-survivors*
-    # were caught by the test suite, and which sites neither axis caught — the
-    # ranked "add a type OR a test here" list.
+    # ADR-70 — aggregates per-file {Protection::MutationScanner::FusedFileResult} into a project-level **fused**
+    # protection report: how many type-visible breakages were caught by the type checker, how many of the
+    # *type-survivors* were caught by the test suite, and which sites neither axis caught — the ranked "add a type OR a
+    # test here" list.
     #
-    # Framing (ADR-63 / ADR-62 Criterion A, extended): the payload is the
-    # **attribution** — which protection axis is missing — never raw survival.
-    # An unprotected site is "add protection here", never "your code is broken".
+    # Framing (ADR-63 / ADR-62 Criterion A, extended): the payload is the **attribution** — which protection axis is
+    # missing — never raw survival. An unprotected site is "add protection here", never "your code is broken".
     FusedFileProtection = Data.define(:path, :type_killed, :test_killed, :unprotected, :ratio)
     UnprotectedBreakage = Data.define(:method_name, :count, :examples)
 

data/lib/rigor/cli/lsp_command.rb

@@ -9,8 +9,8 @@ module Rigor
   class CLI
     # Executes the `rigor lsp` command.
     #
-    # Starts a long-running LSP server over stdio (JSON-RPC).
-    # See `docs/design/20260517-language-server.md` for the design.
+    # Starts a long-running LSP server over stdio (JSON-RPC). See `docs/design/20260517-language-server.md` for the
+    # design.
     class LspCommand < Command
       USAGE = "Usage: rigor lsp [options]"
 
@@ -29,13 +29,10 @@ module Rigor
         require_relative "../configuration"
         require "language_server-protocol"
 
-        # STDIN is read frame-by-frame via the gem's `Io::Reader`;
-        # STDOUT is wrapped in `SynchronizedWriter` so concurrent
-        # writes from the main dispatch thread + the Debouncer's
-        # async threads don't interleave frames. The Loop runs
-        # until either STDIN hits EOF or `server.exited?`; the
-        # process then exits with the server's recorded code
-        # (0 after a clean shutdown+exit, 1 otherwise).
+        # STDIN is read frame-by-frame via the gem's `Io::Reader`; STDOUT is wrapped in `SynchronizedWriter` so
+        # concurrent writes from the main dispatch thread + the Debouncer's async threads don't interleave frames. The
+        # Loop runs until either STDIN hits EOF or `server.exited?`; the process then exits with the server's recorded
+        # code (0 after a clean shutdown+exit, 1 otherwise).
         writer = LanguageServer::SynchronizedWriter.new(
           ::LanguageServer::Protocol::Transport::Io::Writer.new($stdout)
         )
@@ -46,19 +43,14 @@ module Rigor
 
       private
 
-      # Builds the full collaborator graph from a fresh
-      # `Configuration` + `ProjectContext`. Returns `[server,
-      # loop]` so the caller drives the loop and reads
-      # `server.exit_code` for the process exit status.
+      # Builds the full collaborator graph from a fresh `Configuration` + `ProjectContext`. Returns `[server, loop]` so
+      # the caller drives the loop and reads `server.exit_code` for the process exit status.
       def build_server(writer:, config_path:) # rubocop:disable Metrics/MethodLength
         configuration = Configuration.load(config_path)
-        # ProjectContext caches Environment + Cache::Store across
-        # requests so hover / publish hit the warm path. Invalidated
-        # by `workspace/didChangeWatchedFiles` and
-        # `workspace/didChangeConfiguration`.
+        # ProjectContext caches Environment + Cache::Store across requests so hover / publish hit the warm path.
+        # Invalidated by `workspace/didChangeWatchedFiles` and `workspace/didChangeConfiguration`.
         project_context = LanguageServer::ProjectContext.new(configuration: configuration)
-        # Single source of truth for buffer state — threaded to
-        # Server + all three providers.
+        # Single source of truth for buffer state — threaded to Server + all three providers.
         buffer_table = LanguageServer::BufferTable.new
         debouncer = LanguageServer::Debouncer.new
         publisher = LanguageServer::DiagnosticPublisher.new(

data/lib/rigor/cli/mcp_command.rb

@@ -8,13 +8,11 @@ module Rigor
   class CLI
     # Executes the `rigor mcp` command.
     #
-    # Starts a long-running MCP (Model Context Protocol) server over stdio.
-    # The server exposes Rigor's analysis tools as MCP tool calls over a
-    # newline-delimited JSON-RPC 2.0 stream. See ADR-33.
+    # Starts a long-running MCP (Model Context Protocol) server over stdio. The server exposes Rigor's analysis tools as
+    # MCP tool calls over a newline-delimited JSON-RPC 2.0 stream. See ADR-33.
     #
-    # Slice 1 ships the stdio transport with seven read-only tools:
-    # rigor_check, rigor_type_of, rigor_triage, rigor_annotate,
-    # rigor_sig_gen, rigor_explain, rigor_coverage.
+    # Slice 1 ships the stdio transport with seven read-only tools: rigor_check, rigor_type_of, rigor_triage,
+    # rigor_annotate, rigor_sig_gen, rigor_explain, rigor_coverage.
     class McpCommand < Command
       USAGE = "Usage: rigor mcp [options]"
 

data/lib/rigor/cli/mutation_protection_renderer.rb

@@ -4,10 +4,9 @@ require "json"
 
 module Rigor
   class CLI
-    # Renders a {MutationProtectionReport} (ADR-63 Tier 2) as text or JSON. The
-    # text form leads with the effectiveness ratio (caught breakages), then the
-    # breakages Rigor missed ("add a type here"), then the least-effective files.
-    # The framing is always *where to add a type*, never "your code is broken".
+    # Renders a {MutationProtectionReport} (ADR-63 Tier 2) as text or JSON. The text form leads with the effectiveness
+    # ratio (caught breakages), then the breakages Rigor missed ("add a type here"), then the least-effective files. The
+    # framing is always *where to add a type*, never "your code is broken".
     class MutationProtectionRenderer
       TOP_CALLS = 15
       TOP_FILES = 10

data/lib/rigor/cli/mutation_protection_report.rb

@@ -2,16 +2,13 @@
 
 module Rigor
   class CLI
-    # ADR-63 Tier 2 — aggregates per-file {Protection::MutationScanner}
-    # results into a project-level *effectiveness* report: the kill ratio (when
-    # a type-visible bug was introduced, how often Rigor caught it), the per-file
-    # breakdown, and a ranked "add a type here" list keyed by the method whose
-    # breakage Rigor most often *missed* — the sites where a receiver annotation
-    # would buy real catching power.
+    # ADR-63 Tier 2 — aggregates per-file {Protection::MutationScanner} results into a project-level *effectiveness*
+    # report: the kill ratio (when a type-visible bug was introduced, how often Rigor caught it), the per-file
+    # breakdown, and a ranked "add a type here" list keyed by the method whose breakage Rigor most often *missed* — the
+    # sites where a receiver annotation would buy real catching power.
     #
-    # The framing is load-bearing (ADR-63 Criterion A / ADR-62 Criterion A): the
-    # number is *effectiveness*, the survivors are *missed breakages / where to
-    # add a type*, never "your code is broken".
+    # The framing is load-bearing (ADR-63 Criterion A / ADR-62 Criterion A): the number is *effectiveness*, the
+    # survivors are *missed breakages / where to add a type*, never "your code is broken".
     FileEffectiveness = Data.define(:path, :killed, :survived, :ratio)
     MissedBreakage = Data.define(:method_name, :count, :examples)
 

data/lib/rigor/cli/options.rb

@@ -6,28 +6,22 @@ module Rigor
   class CLI
     # Shared option plumbing for the subcommands.
     #
-    # Today it owns the editor-mode surface that `rigor check` and
-    # `rigor type-of` both expose: the `--tmp-file` / `--instead-of` flag
-    # pair and the buffer-binding resolution that validates it. That
-    # resolution used to be copied verbatim into both `Rigor::CLI` and
-    # `TypeOfCommand`, so a fix to one (the paired-flag check, the
-    # readability check, the error wording) could silently miss the
-    # other. Centralising it keeps the two editor-mode entry points in
+    # Today it owns the editor-mode surface that `rigor check` and `rigor type-of` both expose: the `--tmp-file` /
+    # `--instead-of` flag pair and the buffer-binding resolution that validates it. That resolution used to be copied
+    # verbatim into both `Rigor::CLI` and `TypeOfCommand`, so a fix to one (the paired-flag check, the readability
+    # check, the error wording) could silently miss the other. Centralising it keeps the two editor-mode entry points in
     # lockstep.
     module Options
       module_function
 
-      # Defines the standard `--config=PATH` flag on `parser`, writing the
-      # path into `options[:config]`. Used by every subcommand that loads a
-      # `.rigor.yml`; the few whose `--config` help text is intentionally
-      # bespoke (`diff`, `mcp`, `show-bleedingedge`) keep their own
-      # `parser.on` rather than this shared wording.
+      # Defines the standard `--config=PATH` flag on `parser`, writing the path into `options[:config]`. Used by every
+      # subcommand that loads a `.rigor.yml`; the few whose `--config` help text is intentionally bespoke (`diff`,
+      # `mcp`, `show-bleedingedge`) keep their own `parser.on` rather than this shared wording.
       def add_config(parser, options)
         parser.on("--config=PATH", "Path to the Rigor configuration file") { |value| options[:config] = value }
       end
 
-      # Defines the `--tmp-file` / `--instead-of` editor-mode flag pair
-      # on `parser`, writing into `options`.
+      # Defines the `--tmp-file` / `--instead-of` editor-mode flag pair on `parser`, writing into `options`.
       def add_editor_mode(parser, options)
         parser.on("--tmp-file=PATH",
                   "Editor mode: read source bytes from PATH instead of --instead-of (paired)") do |value|
@@ -39,11 +33,9 @@ module Rigor
         end
       end
 
-      # Resolves the editor-mode buffer binding from parsed `options`:
-      # returns nil when neither editor-mode flag is set, a
-      # `Analysis::BufferBinding` when the pair is valid, or
-      # `:usage_error` (after writing the reason to `err`) when the flags
-      # are unpaired or the temp file is unreadable.
+      # Resolves the editor-mode buffer binding from parsed `options`: returns nil when neither editor-mode flag is set,
+      # a `Analysis::BufferBinding` when the pair is valid, or `:usage_error` (after writing the reason to `err`) when
+      # the flags are unpaired or the temp file is unreadable.
       def resolve_buffer_binding(options, err:)
         tmp = options[:tmp_file]
         instead = options[:instead_of]

data/lib/rigor/cli/plugin_command.rb

@@ -4,23 +4,17 @@ require_relative "command"
 
 module Rigor
   class CLI
-    # `rigor plugin` (singular) — discover and read the plugin source
-    # bundled with the `rigortype` gem.
+    # `rigor plugin` (singular) — discover and read the plugin source bundled with the `rigortype` gem.
     #
-    # Rigor ships ~30 production plugins under `plugins/` and a set of
-    # tutorial plugins under `examples/`. When Rigor is installed via
-    # `mise` / `gem install` the gem checkout is on disk, so a plugin
-    # author (or an AI coding agent following the `rigor-plugin-author`
-    # skill) can read a real, working plugin as a worked example —
-    # instead of guessing the `Rigor::Plugin::Base` surface from prose.
-    # This command outputs the absolute paths so they can be found and
-    # read regardless of where the gem landed.
+    # Rigor ships ~30 production plugins under `plugins/` and a set of tutorial plugins under `examples/`. When Rigor is
+    # installed via `mise` / `gem install` the gem checkout is on disk, so a plugin author (or an AI coding agent
+    # following the `rigor-plugin-author` skill) can read a real, working plugin as a worked example — instead of
+    # guessing the `Rigor::Plugin::Base` surface from prose. This command outputs the absolute paths so they can be
+    # found and read regardless of where the gem landed.
     #
-    # It is deliberately distinct from `rigor plugins` (plural), which
-    # reports the activation status of the plugins configured in *your*
-    # `.rigor.yml`. This command (singular) browses the plugins bundled
-    # in the *toolchain*. Mnemonic: "plugins" = my config; "plugin" =
-    # the catalogue I can learn from.
+    # It is deliberately distinct from `rigor plugins` (plural), which reports the activation status of the plugins
+    # configured in *your* `.rigor.yml`. This command (singular) browses the plugins bundled in the *toolchain*.
+    # Mnemonic: "plugins" = my config; "plugin" = the catalogue I can learn from.
     #
     # Subcommands:
     #
@@ -39,13 +33,10 @@ module Rigor
     #
     # `rigor plugin` with no subcommand is an alias for `list`.
     #
-    # **Docker / cross-filesystem note.** Every path printed is resolved
-    # at runtime from this file's location, so it is correct *on the
-    # filesystem where `rigor` runs*. If you run `rigor` inside a
-    # container but read files from the host (or vice versa), the paths
-    # will not resolve — read them from the same environment that ran
-    # the command (`rigor plugin print` inlines the body for exactly
-    # this case: it works with no file-reading tool at all).
+    # **Docker / cross-filesystem note.** Every path printed is resolved at runtime from this file's location, so it is
+    # correct *on the filesystem where `rigor` runs*. If you run `rigor` inside a container but read files from the host
+    # (or vice versa), the paths will not resolve — read them from the same environment that ran the command (`rigor
+    # plugin print` inlines the body for exactly this case: it works with no file-reading tool at all).
     class PluginCommand < Command
       USAGE = <<~USAGE
         Usage: rigor plugin <subcommand> [args]
@@ -67,9 +58,8 @@ module Rigor
           rigor plugin root
       USAGE
 
-      # The bundled plugins/examples/source live at `<gem_root>/...`.
-      # From `lib/rigor/cli/plugin_command.rb` the gem root is three
-      # directories up (matching SkillCommand::SKILLS_ROOT).
+      # The bundled plugins/examples/source live at `<gem_root>/...`. From `lib/rigor/cli/plugin_command.rb` the gem
+      # root is three directories up (matching SkillCommand::SKILLS_ROOT).
       GEM_ROOT     = File.expand_path("../../..", __dir__)
       PLUGINS_ROOT = File.join(GEM_ROOT, "plugins")
       EXAMPLES_ROOT = File.join(GEM_ROOT, "examples")
@@ -168,9 +158,8 @@ module Rigor
         0
       end
 
-      # The header that precedes the plugin body when an author runs
-      # `rigor plugin print <name>`. `# `-prefixed so the combined
-      # output stays readable; the Ruby body below it is unchanged.
+      # The header that precedes the plugin body when an author runs `rigor plugin print <name>`. `# `-prefixed so the
+      # combined output stays readable; the Ruby body below it is unchanged.
       def render_print_header(plugin)
         dir = plugin.fetch(:path)
         sig = File.join(dir, "sig")
@@ -202,8 +191,7 @@ module Rigor
         end
       end
 
-      # Match the directory name with or without the conventional
-      # `rigor-` prefix, so both `rigor-activerecord` and
+      # Match the directory name with or without the conventional `rigor-` prefix, so both `rigor-activerecord` and
       # `activerecord` resolve.
       def find(name)
         all = discover(PLUGINS_ROOT) + discover(EXAMPLES_ROOT)