rubyn-code 0.5.1 → 0.7.0

data/lib/rubyn_code/auth/token_store.rb

@@ -11,13 +11,27 @@ module RubynCode
       EXPIRY_BUFFER_SECONDS = 300 # 5 minutes
       KEYCHAIN_SERVICE = 'Claude Code-credentials'
 
+      # Strategy chain: each method returns a token hash or nil.
+      # First non-nil result wins. Adding a new auth source is a one-line entry.
+      LOAD_STRATEGIES = %i[
+        load_from_keychain
+        load_from_credentials_file
+        load_from_file
+        load_from_env
+      ].freeze
+
       class << self
         # Load tokens with fallback chain:
         # 1. macOS Keychain (Claude Code's OAuth token)
-        # 2. Local YAML file (~/.rubyn-code/tokens.yml)
-        # 3. ANTHROPIC_API_KEY environment variable
+        # 2. Claude Code credentials file (~/.claude/.credentials.json)
+        # 3. Local YAML file (~/.rubyn-code/tokens.yml)
+        # 4. ANTHROPIC_API_KEY environment variable
         def load
-          load_from_keychain || load_from_file || load_from_env
+          LOAD_STRATEGIES.each do |strategy|
+            result = send(strategy)
+            return result if result
+          end
+          nil
         end
 
         # Load API key for a given provider. Anthropic uses the full fallback chain.
@@ -68,7 +82,12 @@ module RubynCode
         end
 
         def valid?
-          tokens = self.load
+          valid_tokens?(self.load)
+        end
+
+        # Validate an already-loaded token hash without re-reading the
+        # keychain — lets callers cache the result of `load`.
+        def valid_tokens?(tokens)
           return false unless tokens&.fetch(:access_token, nil)
           return true if tokens[:type] == :api_key
           return true unless tokens[:expires_at]
@@ -88,6 +107,7 @@ module RubynCode
           default
         end
 
+        # macOS only: read from Keychain Services
         def load_from_keychain
           return nil unless RUBY_PLATFORM.include?('darwin')
 
@@ -102,6 +122,21 @@ module RubynCode
           nil
         end
 
+        # Linux/other: Claude Code stores OAuth in a plain JSON file
+        def load_from_credentials_file
+          path = Config::Defaults::CLAUDE_CREDENTIALS_FILE
+          return nil unless File.exist?(path)
+
+          warn_insecure_permissions(path)
+
+          oauth = JSON.parse(File.read(path))['claudeAiOauth']
+          return nil unless oauth&.dig('accessToken')
+
+          build_keychain_tokens(oauth)
+        rescue StandardError
+          nil
+        end
+
         def build_keychain_tokens(oauth)
           {
             access_token: oauth['accessToken'],
@@ -137,6 +172,16 @@ module RubynCode
           { access_token: api_key, refresh_token: nil, expires_at: nil, type: :api_key, source: :env }
         end
 
+        # Warn when credentials file has loose permissions (no system ACLs on Linux)
+        def warn_insecure_permissions(path)
+          mode = File.stat(path).mode & 0o777
+          return if mode == 0o600
+
+          warn "[rubyn-code] WARNING: #{path} has mode #{format('%04o', mode)}, expected 0600"
+        rescue StandardError
+          nil # best-effort — don't fail a token load over a stat
+        end
+
         def write_tokens_file(data)
           File.write(tokens_path, YAML.dump(data))
           File.chmod(0o600, tokens_path)

data/lib/rubyn_code/checkpoint/hook.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Checkpoint
+    # A :pre_tool_use hook that snapshots a file's original contents into the
+    # current checkpoint just before a mutating tool changes it. Only the
+    # file-mutating tools are watched; everything else is ignored.
+    class Hook
+      MUTATING_TOOLS = %w[write_file edit_file].freeze
+
+      # @param manager [Checkpoint::Manager]
+      def initialize(manager:)
+        @manager = manager
+      end
+
+      # @return [nil] never blocks the tool (returns no deny decision)
+      def call(tool_name:, tool_input: {}, **_kwargs)
+        return nil unless MUTATING_TOOLS.include?(tool_name.to_s)
+
+        path = tool_input[:path] || tool_input['path']
+        @manager.record_file(path) if path
+        nil
+      end
+    end
+  end
+end

data/lib/rubyn_code/checkpoint/manager.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module RubynCode
+  # Checkpoints let a user rewind a session, mirroring Claude Code's /rewind.
+  # A checkpoint is taken at the start of each user turn and captures:
+  #   - the conversation state (so chat can be rolled back), and
+  #   - the original contents of every file mutated during that turn (so code
+  #     can be restored).
+  #
+  # File contents are captured lazily by Checkpoint::Hook on :pre_tool_use,
+  # just before a mutating tool runs, so only files that actually change are
+  # snapshotted.
+  module Checkpoint
+    # Marker stored for a path that did not exist when first touched, so a
+    # rewind deletes it rather than recreating empty content.
+    ABSENT = :absent
+
+    class Manager
+      MAX_CHECKPOINTS = 30
+
+      def initialize(project_root:)
+        @project_root = project_root
+        @checkpoints = []
+        @seq = 0
+        @current = nil
+      end
+
+      # Open a new checkpoint for a user turn. Captures the conversation as it
+      # stands before the agent acts.
+      #
+      # @param label [String] short description (usually the user's message)
+      # @param conversation [Agent::Conversation]
+      # @return [Integer] the checkpoint id
+      def checkpoint!(label:, conversation:)
+        @seq += 1
+        @current = {
+          id: @seq,
+          label: summarize(label),
+          messages: Array(conversation.messages).dup,
+          files: {}
+        }
+        @checkpoints << @current
+        @checkpoints.shift while @checkpoints.size > MAX_CHECKPOINTS
+        @seq
+      end
+
+      # Record a file's original contents before it is mutated (once per
+      # checkpoint per path). No-op when no checkpoint is open.
+      #
+      # @param path [String] absolute or project-relative path
+      # @return [void]
+      def record_file(path)
+        return unless @current && path
+
+        abs = File.expand_path(path.to_s, @project_root)
+        return if @current[:files].key?(abs)
+
+        @current[:files][abs] = File.file?(abs) ? File.read(abs) : ABSENT
+      rescue StandardError => e
+        RubynCode::Debug.warn("Checkpoint capture failed for #{path}: #{e.message}")
+      end
+
+      # @return [Array<Hash>] {id:, label:, files:} newest last
+      def list
+        @checkpoints.map { |c| { id: c[:id], label: c[:label], files: c[:files].size } }
+      end
+
+      def empty? = @checkpoints.empty?
+
+      def latest_id = @checkpoints.last&.fetch(:id)
+
+      # Restore a checkpoint. Scope :both (default), :code, or :chat.
+      # Checkpoints newer than the restored one are discarded.
+      #
+      # @return [Hash, nil] summary { id:, files_restored: } or nil if not found
+      def restore(id, conversation, scope: :both)
+        checkpoint = @checkpoints.find { |c| c[:id] == id }
+        return nil unless checkpoint
+
+        restored_files = restore_files(checkpoint) if %i[both code].include?(scope)
+        conversation.replace!(checkpoint[:messages].dup) if %i[both chat].include?(scope)
+
+        @checkpoints.reject! { |c| c[:id] > id }
+        @current = nil
+        { id: id, files_restored: restored_files || 0 }
+      end
+
+      private
+
+      def restore_files(checkpoint)
+        checkpoint[:files].each do |abs, content|
+          if content == ABSENT
+            FileUtils.rm_f(abs)
+          else
+            File.write(abs, content)
+          end
+        end
+        checkpoint[:files].size
+      end
+
+      def summarize(label)
+        text = label.to_s.tr("\n", ' ').strip
+        text.length > 60 ? "#{text[0, 57]}…" : text
+      end
+    end
+  end
+end

data/lib/rubyn_code/chisel/debt.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Chisel
+    # Harvests inline deferral markers from the codebase. A marker is a code
+    # comment whose text begins with the lowercase tag "chisel:" and records a
+    # simplification you consciously postponed (e.g. a comment reading
+    # "chisel: collapse this adapter once a second caller exists").
+    #
+    # Finding them is a deterministic grep — stdlib does it, so there's no LLM
+    # round-trip here (Chisel's own ladder, applied to Chisel).
+    module Debt
+      Item = Data.define(:file, :line, :note)
+
+      # The whole line must be a comment whose first token is the lowercase tag:
+      # optional indentation, a `#` or `//` leader, then `chisel:`, then the note.
+      # Anchoring to line-start means a `chisel:` substring inside a string
+      # literal or a trailing code comment is NOT harvested — only a marker on its
+      # own comment line is. Case-sensitive on purpose, so a descriptive comment
+      # that merely starts with "Chisel:" is not a marker.
+      MARKER = %r{\A\s*(?:#|//)\s*chisel:\s*(\S.*)}
+
+      SCAN_EXTENSIONS = %w[.rb .rake .erb .ru .gemspec].freeze
+      SKIP_DIRS = %w[.git node_modules vendor coverage tmp log].freeze
+
+      module_function
+
+      # @param root [String, nil] project root to scan
+      # @return [Array<Item>] markers found, in file/line order
+      def scan(root)
+        return [] unless root
+
+        base = File.expand_path(root)
+        return [] unless Dir.exist?(base)
+
+        source_files(base).flat_map { |path| scan_file(base, path) }
+      end
+
+      # @param base [String] expanded project root (no trailing slash)
+      # @return [Array<String>] absolute paths of scannable source files
+      def source_files(base)
+        pattern = File.join(base, '**', "*{#{SCAN_EXTENSIONS.join(',')}}")
+        Dir.glob(pattern).reject { |path| skip?(base, path) }.sort
+      end
+
+      def skip?(base, path)
+        rel = path.delete_prefix("#{base}/")
+        SKIP_DIRS.any? { |dir| rel == dir || rel.start_with?("#{dir}/") || rel.include?("/#{dir}/") }
+      end
+
+      # @return [Array<Item>] markers in a single file ([] if it can't be read)
+      def scan_file(base, path)
+        rel = path.delete_prefix("#{base}/")
+        items = []
+        File.foreach(path).with_index(1) do |line, number|
+          match = MARKER.match(line)
+          items << Item.new(file: rel, line: number, note: match[1].strip) if match
+        end
+        items
+      rescue StandardError
+        []
+      end
+    end
+  end
+end

data/lib/rubyn_code/chisel/inspection.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Chisel
+    # Builds the over-engineering audit instruction shared by /chisel-review
+    # (scope: :diff) and /chisel-audit (scope: :repo). Both judge by the same
+    # decision ladder and exclude the same safety floor, so the two commands
+    # can never drift apart — they differ only in what code they look at.
+    #
+    # Detection is delegated to the agent and its tools (git_diff, bash, grep,
+    # read_file); this module only assembles the prompt.
+    module Inspection
+      SMELLS = <<~SMELLS.strip
+        Flag code that skips a rung of the ladder:
+        - speculative abstractions, wrappers, or base classes with a single caller
+        - reinvented stdlib or already-installed-gem functionality
+        - needless indirection, configurability, or options nobody uses
+        - dead parameters, unused branches, premature generalization
+        - a class where a method would do; a method where one line would do
+      SMELLS
+
+      OUTPUT_CONTRACT = <<~CONTRACT.strip
+        Return a ranked deletion/simplification list, most impactful first. For
+        each item give:
+        - `file:line`
+        - what it is (one line)
+        - which rung of the ladder it skipped
+        - the concrete simpler form (delete it / inline it / replace with stdlib X)
+
+        If nothing is over-engineered, say so plainly instead of inventing work.
+      CONTRACT
+
+      READ_ONLY_NOTE = 'This is a READ-ONLY review: report the list, do not edit any files.'
+
+      module_function
+
+      # @param scope [Symbol] :diff (review changes) or :repo (audit codebase)
+      # @param target [String, nil] base ref for :diff (default "main"),
+      #   or an optional path to scope :repo
+      # @return [String] the full instruction to send to the agent
+      # @raise [ArgumentError] on an unknown scope
+      def prompt(scope:, target: nil)
+        [lead_in(scope, target), Chisel::LADDER, SMELLS, OUTPUT_CONTRACT, guardrails]
+          .join("\n\n")
+      end
+
+      # Read-only guard + the shared safety floor, reused verbatim from Chisel
+      # so the exclusion list can never drift from the always-on ruleset.
+      #
+      # @return [String]
+      def guardrails
+        "#{READ_ONLY_NOTE}\n\n#{Chisel::SAFETY_FLOOR}\n" \
+          'Those are never over-engineering — leave them even if they add code.'
+      end
+
+      # @return [String]
+      def lead_in(scope, target)
+        case scope
+        when :diff then diff_lead_in(presence(target) || 'main')
+        when :repo then repo_lead_in(presence(target))
+        else raise ArgumentError, "unknown Chisel inspection scope: #{scope.inspect}"
+        end
+      end
+
+      # @param value [#to_s, nil]
+      # @return [String, nil] the trimmed value, or nil if blank
+      def presence(value)
+        str = value.to_s.strip
+        str.empty? ? nil : str
+      end
+
+      def diff_lead_in(base)
+        <<~LEAD.strip
+          Chisel review — find over-engineering in my current changes.
+
+          Gather the diff with `git diff #{base}...` plus any uncommitted changes
+          (`git diff` and `git diff --staged`). Judge ONLY the added or changed
+          lines against the Chisel decision ladder below.
+        LEAD
+      end
+
+      def repo_lead_in(path)
+        scope_line = path ? "Scope the sweep to `#{path}`." : 'Sweep the whole repository.'
+        <<~LEAD.strip
+          Chisel audit — find accumulated over-engineering in this codebase.
+
+          #{scope_line} Use grep and file reads to survey the code, then judge it
+          against the Chisel decision ladder below.
+        LEAD
+      end
+    end
+  end
+end

data/lib/rubyn_code/chisel.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module RubynCode
+  # Chisel is rubyn-code's opt-in "write the minimum that works" enforcement
+  # layer. It is OFF by default and only changes the agent's behavior once a
+  # user turns it on (via `/chisel full` or the config key `chisel_mode`).
+  #
+  # The single source of truth for:
+  #   - which intensity modes exist (off/lite/full/ultra),
+  #   - which mode is currently active (env override → config → default),
+  #   - the ruleset text injected into the system prompt at each intensity.
+  #
+  # The decision ladder is adapted from the open-source `ponytail` plugin and
+  # rebuilt natively here; the safety floor (validation, error/data-loss
+  # handling, security, accessibility) is never on the chopping block.
+  module Chisel
+    # On-demand over-engineering audit shared by /chisel-review and /chisel-audit.
+    autoload :Inspection, 'rubyn_code/chisel/inspection'
+    # Harvests inline `chisel:` deferral markers for /chisel-debt and /chisel-gain.
+    autoload :Debt, 'rubyn_code/chisel/debt'
+
+    MODES = %w[off lite full ultra].freeze
+    DEFAULT_MODE = 'off'
+    ENV_KEY = 'RUBYN_CHISEL_MODE'
+    CONFIG_KEY = 'chisel_mode'
+
+    # The decision ladder — injected at every non-off intensity.
+    LADDER = <<~LADDER.strip
+      # Chisel — write the minimum that works
+
+      Before writing code, stop at the first rung that holds:
+      1. Does this need to exist? If not, don't write it. (YAGNI)
+      2. Does Ruby's stdlib already do it? Use it.
+      3. Does the framework or runtime already do it? Use it.
+      4. Does an already-installed gem do it? Use it — don't add a dependency.
+      5. Is it one line? Write one line.
+      6. Only then: the smallest change that fully solves the task.
+    LADDER
+
+    # Extra guidance layered on at `full` and above.
+    FULL_ADDENDUM = <<~FULL.strip
+      Prefer editing existing code over adding new files, classes, or layers of
+      indirection. Don't introduce an abstraction until a second concrete caller
+      exists — three similar lines beat a premature framework.
+    FULL
+
+    # Extra guidance layered on at `ultra` only.
+    ULTRA_ADDENDUM = <<~ULTRA.strip
+      Be aggressive: question every new method, parameter, option, and file. If
+      you can't name the second caller, inline it. When you finish, briefly note
+      what you deliberately chose NOT to build.
+    ULTRA
+
+    # The safety floor — appended at every non-off intensity, last so it is
+    # never overridden by the "delete more" guidance above it.
+    SAFETY_FLOOR = <<~SAFETY.strip
+      Lazy, not negligent. Never chisel away: input and trust-boundary
+      validation, error and data-loss handling, security, or accessibility.
+    SAFETY
+
+    module_function
+
+    # @param value [#to_s]
+    # @return [Boolean] whether the value is a recognized mode
+    def valid?(value)
+      MODES.include?(value.to_s)
+    end
+
+    # Resolve the active mode: env override → persisted config → default.
+    # Each layer is normalized (trimmed + downcased) the same way the
+    # `/chisel` command normalizes its argument, so `RUBYN_CHISEL_MODE=Full`
+    # and a hand-edited `chisel_mode: " Full "` both resolve cleanly. Any
+    # unrecognized value falls through rather than raising, so a typo can
+    # never break a turn.
+    #
+    # @return [String] one of MODES
+    def mode
+      normalize(ENV.fetch(ENV_KEY, nil)) ||
+        normalize(configured_mode) ||
+        DEFAULT_MODE
+    end
+
+    # Trim + downcase a candidate mode, returning it only if recognized,
+    # otherwise nil so the caller can fall through to the next layer.
+    #
+    # @param value [#to_s, nil]
+    # @return [String, nil]
+    def normalize(value)
+      return nil if value.nil?
+
+      candidate = value.to_s.strip.downcase
+      valid?(candidate) ? candidate : nil
+    end
+
+    # @return [Boolean]
+    def enabled?
+      mode != 'off'
+    end
+
+    # The text Chisel contributes to the system prompt for the active mode.
+    #
+    # @return [String] "" when off; otherwise ladder + intensity addenda +
+    #   safety floor.
+    def prompt_section
+      current = mode
+      return '' if current == 'off'
+
+      parts = [LADDER]
+      parts << FULL_ADDENDUM if %w[full ultra].include?(current)
+      parts << ULTRA_ADDENDUM if current == 'ultra'
+      parts << SAFETY_FLOOR
+      parts.join("\n\n")
+    end
+
+    # The persisted mode from config, or nil if unreadable. Isolated so prompt
+    # assembly never dies on a malformed config file.
+    #
+    # @return [String, nil]
+    def configured_mode
+      # No default needed — chisel_mode lives in Settings::DEFAULT_MAP, so an
+      # unset key already resolves to DEFAULT_MODE.
+      Config::Settings.new.get(CONFIG_KEY)
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/rubyn_code/cli/commands/agents.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # `/agents` — list the sub-agent types available to spawn_agent: the
+      # built-in explore/worker plus any custom agents defined in
+      # .rubyn-code/agents/*.md or ~/.rubyn-code/agents/*.md.
+      class Agents < Base
+        def self.command_name = '/agents'
+        def self.description  = 'List available sub-agent types (built-in + custom)'
+
+        def execute(_args, ctx)
+          catalog = RubynCode::SubAgents::Catalog.new(project_root: ctx.project_root)
+          ctx.renderer.info('Available sub-agent types:')
+          catalog.all.each do |agent|
+            tag = agent.custom? ? '(custom)' : '(built-in)'
+            access = agent.read_only? ? 'read-only' : 'read/write'
+            puts "  #{agent.name.ljust(18)} #{tag} [#{access}] — #{agent.description}"
+          end
+          puts
+          ctx.renderer.info('Define your own in .rubyn-code/agents/<name>.md') if catalog.custom_names.empty?
+          nil
+        rescue StandardError => e
+          ctx.renderer.error("Could not list agents: #{e.message}")
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/commands/chisel.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # Set or report the Chisel intensity. Chisel is the opt-in "write the
+      # minimum that works" enforcement layer; it is off by default and only
+      # changes the agent's behavior once turned on here.
+      class Chisel < Base
+        def self.command_name = '/chisel'
+        def self.description = 'Set or show Chisel intensity (off|lite|full|ultra)'
+
+        def execute(args, ctx)
+          arg = args.first
+          return report(ctx) if arg.nil? || arg.strip.empty?
+
+          mode = arg.strip.downcase
+          return reject(mode, ctx) unless RubynCode::Chisel.valid?(mode)
+
+          persist(mode, ctx)
+        end
+
+        private
+
+        def report(ctx)
+          current = RubynCode::Chisel.mode
+          ctx.renderer.info("Chisel: #{current}")
+          ctx.renderer.info("Modes: #{RubynCode::Chisel::MODES.join(' | ')}")
+          ctx.renderer.info('Set with: /chisel full')
+        end
+
+        def persist(mode, ctx)
+          settings = Config::Settings.new
+          settings.set(RubynCode::Chisel::CONFIG_KEY, mode)
+          settings.save!
+          ctx.renderer.info(confirmation(mode))
+        end
+
+        def confirmation(mode)
+          return 'Chisel off — agent behaves normally.' if mode == 'off'
+
+          "Chisel set to #{mode} — the agent will favor writing the minimum that works."
+        end
+
+        def reject(mode, ctx)
+          ctx.renderer.warning("Unknown Chisel mode: #{mode}")
+          ctx.renderer.info("Valid modes: #{RubynCode::Chisel::MODES.join(', ')}")
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/commands/chisel_audit.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # `/chisel-audit` — sweep the repo (or a path) for accumulated
+      # over-engineering and report a ranked deletion list. Read-only.
+      class ChiselAudit < Base
+        def self.command_name = '/chisel-audit'
+        def self.description = 'Find over-engineering across the repo (/chisel-audit [path])'
+
+        def execute(args, ctx)
+          path = args.first
+          ctx.send_message(RubynCode::Chisel::Inspection.prompt(scope: :repo, target: path))
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/commands/chisel_debt.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # `/chisel-debt` — harvest inline `chisel:` deferral markers from the
+      # codebase into a ledger view so postponed simplifications aren't lost.
+      class ChiselDebt < Base
+        def self.command_name = '/chisel-debt'
+        def self.description = 'List deferred `chisel:` markers in the codebase'
+
+        def execute(_args, ctx)
+          items = RubynCode::Chisel::Debt.scan(ctx.project_root)
+          return ctx.renderer.info('No chisel: debt markers found — clean.') if items.empty?
+
+          ctx.renderer.info("Chisel debt — #{items.size} deferred #{pluralize(items.size, 'simplification')}:")
+          items.each { |item| ctx.renderer.info("  #{item.file}:#{item.line} — #{item.note}") }
+        end
+
+        private
+
+        def pluralize(count, word)
+          count == 1 ? word : "#{word}s"
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/commands/chisel_gain.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # `/chisel-gain` — quick read on Chisel's status and what it buys you.
+      class ChiselGain < Base
+        def self.command_name = '/chisel-gain'
+        def self.description = 'Show Chisel status and reference impact'
+
+        # Measured on a real open-source repo for the approach Chisel is built on;
+        # shown as an attributed reference, not fabricated per-user metrics (which
+        # rubyn-code does not instrument).
+        REFERENCE_IMPACT = 'Reference benchmark for this approach (real FastAPI + React repo): ' \
+                           '~54% less code, ~20% cheaper, ~27% faster.'
+
+        def execute(_args, ctx)
+          mode = RubynCode::Chisel.mode
+          debt = RubynCode::Chisel::Debt.scan(ctx.project_root).size
+
+          ctx.renderer.info("Chisel mode: #{mode}")
+          ctx.renderer.info('Turn it on with /chisel full.') if mode == 'off'
+          ctx.renderer.info("Outstanding chisel: debt markers: #{debt}")
+          ctx.renderer.info(REFERENCE_IMPACT)
+          ctx.renderer.info('Run /chisel-review for concrete cuts in your current diff.')
+        end
+      end
+    end
+  end
+end