ace-support-config 0.11.2 → 0.17.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33ca9302021e76335a714f27321b3075dd172056154ed5d1769b6f7b9ea7d6c7
-  data.tar.gz: e06462886d8d07fa3104367a96d129957b8554b8ac4419651f51c220dcd09167
+  metadata.gz: 1f7f5cddbf50a8da6f9f42cc644f193cd9a2898757a3417849fc4104546c8ba2
+  data.tar.gz: 54c887961b4c3473a7a4be0bc5383b2ab4975d2d779c86e98c02e180a298c082
 SHA512:
-  metadata.gz: 5f6377fe1c334cdf394a619c0548966317167789dd3214c87d7cbef778fe069d7e059af7db77d53fcc86aeb0acb445ef4eb644cbfb29e1f2006f73f74aa671ef
-  data.tar.gz: d21e340eb555a7457aabcf55e7ea26120b54b9ed282f7227658810377274501e5fac8ce1b1d0519f8a9868330502a8d0dbae4e2b69afd8805f8b37ac033de699
+  metadata.gz: 5a3291da675776cd51aa9f5d888bc8f001c3f0221206c684551ec0bfaa3cbdfe94361ed3c8a56826bce3cd838a172873cdf31afa95202a4ea0dc6278afce111d
+  data.tar.gz: 570b40415d3a4b63b3762d09fea0b43c74628dd91f286818215aaa388371d26dc586f4ab00316b6c781ae38e1555477cf07a03d0340fa2e4f8d1b9ec7b0463a9

data/CHANGELOG.md

@@ -7,6 +7,94 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.17.1] - 2026-06-30
+
+### Changed
+- Updated `ace-config doctor` skill projection health to ignore disabled provider projections reported by `ace-handbook status`.
+
+## [0.17.0] - 2026-06-30
+
+### Added
+- Added `ace-config doctor` warnings for projects whose root agent guidance or `docs/tools.md` are missing generated agent-engineering guidance markers.
+
+### Fixed
+- Corrected `ace-config-bootstrap-root-files` to sync `ace-support-core` and record from the sandbox root layout where the bootstrap files are actually created.
+
+### Technical
+- Expanded bootstrap sync coverage for generated `docs/tools.md`, cost-bias markers, preservation without `--force`, force refresh, and subdirectory root targeting.
+
+## [0.16.2] - 2026-04-24
+
+### Technical
+- Expanded bootstrap feature coverage so generated `AGENTS.md` and `CLAUDE.md` files must retain ACE provenance, customization, and refresh guidance.
+
+## [0.16.1] - 2026-04-24
+
+### Changed
+- Clarified setup-readiness documentation so `ace-llm --list-providers` remains the provider discovery command while `ace-config doctor` is documented as the quick-start readiness check, including blocker versus warning guidance and `--no-probe` usage.
+
+## [0.16.0] - 2026-04-23
+
+### Changed
+- Renamed `ace-config init` to `ace-config sync` and removed the old `init` command path.
+- Updated quick-start setup guidance to sync only `ace-llm-providers-cli` config by default because other package config should come from packaged `.ace-defaults` unless project overrides are needed.
+
+## [0.15.0] - 2026-04-23
+
+### Changed
+- Extended `ace-config doctor` with informational project `.ace` vs package `.ace-defaults` counts, provider skill projection sync warnings, and streamed fast-check progress before the final report.
+- Updated doctor provider pings to order API targets before CLI targets, use 15-second API timeouts and 30-second CLI timeouts, and distinguish timeout failures from other provider errors.
+
+### Technical
+- Added doctor coverage for config-default counts, skill sync drift, provider timeout selection, timeout row formatting, and progress ordering.
+
+## [0.14.1] - 2026-04-23
+
+### Changed
+- Updated `ace-config doctor` live provider checks to probe deduped `_utility` plus `commit` role candidates, preserving alias labels alongside resolved provider/model names.
+- Changed doctor provider-ping progress and summaries to show pass/fail/running glyphs, live TTY line updates, and explicit passed/total counts for full and partial success.
+
+### Technical
+- Added doctor regression coverage for utility-plus-commit target selection, alias-preserving ping commands, append-only non-TTY progress, and partial-success summary output.
+
+## [0.14.0] - 2026-04-23
+
+### Changed
+- Split `ace-config doctor` output into health checks that control exit status and a concise hygiene summary, with `--hygiene` for full alias/role drift details.
+- Made provider health live by default again through concurrent `ace-llm TARGET "ping" --no-fallback` checks against deduped `_utility` and `commit` role candidates; `--no-probe` disables live pings.
+- Streamed human `ace-config doctor` output so utility provider ping lines show alias labels, resolved model names, and pass counts as checks complete.
+
+### Technical
+- Added doctor coverage for health-only exit status, hidden-by-default hygiene findings, expanded hygiene output, JSON health/hygiene counts, first-role base-provider distillation, and concurrent ping delegation.
+
+## [0.13.0] - 2026-04-22
+
+### Fixed
+- Made `ace-config doctor` fast by default by replacing automatic live probes with structural role-default readiness checks; live probes now require `--probe` and target only resolved role-default providers.
+
+### Technical
+- Added doctor regression coverage for non-live defaults, opt-in provider probes, blocker-gated probes, and role-default target validation.
+
+## [0.12.1] - 2026-04-22
+
+### Fixed
+- Extended `SetupDoctor` stale-alias detection to validate `aliases.global` provider targets (`provider:model`) in addition to provider-local model aliases.
+- Made `.ace-local` artifact-hygiene detection accept equivalent `.gitignore` forms (for example `/.ace-local/`, `.ace-local`, `.ace-local/**`) instead of requiring an exact literal line.
+
+### Technical
+- Added fast-test coverage for stale global alias detection and semantic `.ace-local` ignore pattern acceptance.
+
+## [0.12.0] - 2026-04-22
+
+### Added
+- Added `ace-config doctor` with text/JSON readiness output and `--no-probe` support for non-mutating setup diagnostics.
+
+### Changed
+- Extended `ace-config` command routing and help output to include the new `doctor` workflow.
+
+### Technical
+- Added `SetupDoctor` organism coverage for blocker/warn/skip classification and CLI contract behavior.
+
 ## [0.11.2] - 2026-04-13
 
 ### Fixed

data/README.md

@@ -22,13 +22,16 @@
 This package now owns the `ace-config` executable for managing `.ace` configuration files and templates.
 
 ```bash
-ace-config init [GEM] [--force] [--dry-run] [--global] [--verbose]
+ace-config sync [GEM] [--force] [--dry-run] [--global] [--verbose]
+ace-config doctor [--json] [--hygiene] [--probe] [--no-probe] [--verbose] [--quiet] [--no-color]
 ace-config diff [GEM] [--global] [--local] [--file PATH] [--one-line]
 ace-config list [--verbose]
 ace-config version
 ace-config help
 ```
 
+Use `ace-config doctor` after a fresh setup to check quick-start readiness without mutating the project. By default it prints each fast setup check as it completes, streams concurrent `ace-llm TARGET "ping" --no-fallback` results for deduped `_utility` and `commit` role candidates, and then prints a final doctor report. The report separates health warnings from informational config-default drift and hidden-by-default hygiene findings. Add `--hygiene` to print full hygiene details, `--json` for machine-readable output, or `--no-probe` to skip live provider pings.
+
 ## Testing
 
 `ace-support-config` uses the ACE deterministic test taxonomy:

data/docs/demo/ace-config-bootstrap-root-files.tape.yml

@@ -1,5 +1,5 @@
 ---
-description: Showcase ace-config init bootstrapping project-root guidance files from a subdirectory
+description: Showcase ace-config sync bootstrapping project-root guidance files from a subdirectory
 tags:
 - ace-config
 - ace-support-config
@@ -10,17 +10,19 @@ settings:
   height: 700
   format: gif
 scenes:
-- name: Initialize config from a nested working directory
+- name: Sync config from a nested working directory
   commands:
-  - type: mkdir -p repo/subdir && cd repo && git init
+  - type: mkdir -p subdir && git init
     sleep: 3s
-  - type: cd subdir && ace-config init support-core
+  - type: cd subdir && ace-config sync ace-support-core
     sleep: 5s
 - name: Verify bootstrap files landed at the repository root
   commands:
-  - type: cd ../ && find . -maxdepth 2 \\( -name '.gitignore' -o -name 'AGENTS.md' -o -name 'CLAUDE.md' \\) | sort
+  - type: cd ..
+    sleep: 1s
+  - type: ls .gitignore AGENTS.md CLAUDE.md
     sleep: 4s
-  - type: printf '\n.gitignore contents:\n' && cat .gitignore
+  - type: sed -n '1,20p' AGENTS.md
     sleep: 4s
 setup:
 - sandbox

data/docs/demo/ace-config-getting-started.tape.yml

@@ -1,5 +1,5 @@
 ---
-description: Showcase ace-config CLI for listing, initializing, and diffing ace-* gem configurations
+description: Showcase ace-config CLI for listing, syncing, and diffing ace-* gem configurations
 tags:
 - ace-config
 - ace-support-config
@@ -14,9 +14,9 @@ scenes:
   commands:
   - type: ace-config list
     sleep: 3s
-- name: Preview config initialization
+- name: Preview config sync
   commands:
-  - type: ace-config init --dry-run
+  - type: ace-config sync --dry-run
     sleep: 4s
 - name: Diff configs against defaults
   commands:

data/docs/usage.md

@@ -3,8 +3,8 @@ doc-type: user
 title: ace-support-config Usage Guide
 purpose: Documentation for ace-support-config/docs/usage.md
 ace-docs:
-  last-updated: '2026-03-31'
-  last-checked: '2026-03-31'
+  last-updated: '2026-04-22'
+  last-checked: '2026-04-22'
 ---
 
 # ace-support-config Usage Guide
@@ -15,16 +15,48 @@ The `ace-support-config` gem provides a generic configuration cascade system tha
 
 ## ace-config Command
 
-`ace-support-config` ships the `ace-config` CLI for template discovery, initialization, and drift checks.
+`ace-support-config` ships the `ace-config` CLI for template discovery, config sync, and drift checks.
 
 ```bash
-ace-config init [GEM] [--force] [--dry-run] [--global] [--verbose]
+ace-config sync [GEM] [--force] [--dry-run] [--global] [--verbose]
+ace-config doctor [--json] [--hygiene] [--probe] [--no-probe]
 ace-config diff [GEM] [--global] [--local] [--file PATH] [--one-line]
 ace-config list [--verbose]
 ace-config version
 ace-config help
 ```
 
+### Setup Readiness Doctor
+
+Run `ace-config doctor` after `ace-config sync ace-llm-providers-cli` and provider setup to verify that the quick-start
+path is ready without changing files. `ace-llm --list-providers` is still the provider discovery command; doctor is the
+separate readiness command that tells you whether the documented setup can actually execute.
+
+The doctor checks:
+
+- health markers for generated local artifacts and `.ace-local/` gitignore readiness
+- `ace-llm-providers-cli` availability and bundled gem/package readiness
+- `ace-llm --list-providers` discovery for configured providers
+- project `.ace` vs package `.ace-defaults` config-default mode counts
+- usable core role defaults
+- provider-native skill projection sync status from `ace-handbook status`
+- a one-line hygiene summary for configured provider aliases and wider role/default drift
+- concurrent `ace-llm TARGET "ping" --no-fallback` checks for deduped `_utility` and `commit` role candidates
+
+Interpret results as setup blockers versus actionable warnings:
+
+- Missing provider packages, unresolved provider/model configuration, or failed readiness requirements for the active
+  quick-start path are blockers.
+- Missing credentials or missing local CLI account access are reported as setup readiness issues with next actions,
+  not as ACE install corruption.
+- API-only users can still pass doctor when their configured API providers are ready, even if unrelated CLI providers
+  are inactive.
+
+Use `--hygiene` to expand full hygiene findings and `--json` for structured output in automation. By default, doctor
+prints fast health/info checks as they complete, runs concurrent `ace-llm TARGET "ping" --no-fallback` checks for
+deduped `_utility` and `commit` role candidates, and then prints the final report. Use `--no-probe` to skip live
+provider calls when you want a readiness check based only on local setup and configuration.
+
 ## Testing Contract
 
 `ace-support-config` follows the ACE deterministic package targets:

data/lib/ace/support/config/cli.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
 require "optparse"
-require_relative "organisms/config_initializer"
+require_relative "organisms/config_synchronizer"
 require_relative "organisms/config_diff"
+require_relative "organisms/setup_doctor"
 require_relative "models/config_templates"
 
 module Ace
@@ -19,12 +20,14 @@ module Ace
           command = argv.shift
 
           case command
-          when "init"
-            run_init(argv)
+          when "sync"
+            run_sync(argv)
           when "diff"
             run_diff(argv)
           when "list"
             run_list(argv)
+          when "doctor"
+            run_doctor(argv)
           when "version", "--version"
             show_version
           when "help", "--help", "-h"
@@ -39,16 +42,16 @@ module Ace
 
         private
 
-        def run_init(argv)
+        def run_sync(argv)
           options = {}
 
           parser = OptionParser.new do |opts|
             opts.banner = <<~BANNER.chomp
               NAME
-                ace-config init - Initialize configuration for ace-* gems
+                ace-config sync - Sync configuration for ace-* gems
 
               USAGE
-                ace-config init [GEM] [OPTIONS]
+                ace-config sync [GEM] [OPTIONS]
 
               OPTIONS
             BANNER
@@ -65,12 +68,12 @@ module Ace
           parser.parse!(argv)
           gem_name = argv.shift
 
-          initializer = Organisms::ConfigInitializer.new(**options)
+          synchronizer = Organisms::ConfigSynchronizer.new(**options)
 
           if gem_name
-            initializer.init_gem(gem_name)
+            synchronizer.sync_gem(gem_name)
           else
-            initializer.init_all
+            synchronizer.sync_all
           end
         end
 
@@ -160,8 +163,48 @@ module Ace
             end
           end
 
-          puts "\nUse 'ace-config init [GEM]' to initialize a specific gem's configuration"
-          puts "Use 'ace-config init' to initialize all configurations"
+          puts "\nUse 'ace-config sync [GEM]' to sync a specific gem's configuration"
+          puts "Use 'ace-config sync' to sync all configurations"
+        end
+
+        def run_doctor(argv)
+          options = {json: false, no_probe: false, probe: false, hygiene: false, verbose: false, no_color: false, quiet: false}
+
+          parser = OptionParser.new do |opts|
+            opts.banner = <<~BANNER.chomp
+              NAME
+                ace-config doctor - Check setup readiness for quick-start workflows
+
+              USAGE
+                ace-config doctor [OPTIONS]
+
+              OPTIONS
+            BANNER
+            opts.on("--json", "Output checks as JSON") { options[:json] = true }
+            opts.on("--hygiene", "Show full hygiene findings") { options[:hygiene] = true }
+            opts.on("-v", "--verbose", "Show full diagnostic detail") { options[:verbose] = true }
+            opts.on("-q", "--quiet", "Suppress output; use exit status only") { options[:quiet] = true }
+            opts.on("--no-color", "Disable colored output") { options[:no_color] = true }
+            opts.on("--probe", "Run live provider probes (default)") { options[:probe] = true }
+            opts.on("--no-probe", "Disable live provider probes") { options[:no_probe] = true }
+            opts.on("-h", "--help", "Show this help") do
+              puts opts
+              exit
+            end
+          end
+
+          parser.parse!(argv)
+
+          exit_code = Organisms::SetupDoctor.new.run(
+            json: options[:json],
+            no_probe: options[:no_probe],
+            probe: options[:probe],
+            hygiene: options[:hygiene],
+            verbose: options[:verbose],
+            colors: !options[:no_color],
+            quiet: options[:quiet]
+          )
+          exit(exit_code) if exit_code.positive?
         end
 
         def show_version
@@ -177,9 +220,10 @@ module Ace
               ace-config COMMAND [OPTIONS]
 
             COMMANDS
-              init [GEM]                        Initialize configuration for specific gem or all
+              sync [GEM]                        Sync configuration for specific gem or all
               diff [GEM]                        Compare configs with examples
               list                              List available ace-* gems with example configs
+              doctor                            Check setup readiness for quick-start workflows
               version                           Show version
               help                              Show this help
 

data/lib/ace/support/config/molecules/setup_doctor_reporter.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ace
+  module Support
+    module Config
+      module Molecules
+        class SetupDoctorReporter
+          COLORS = {
+            red: "\e[31m",
+            yellow: "\e[33m",
+            green: "\e[32m",
+            blue: "\e[34m",
+            cyan: "\e[36m",
+            reset: "\e[0m",
+            bold: "\e[1m"
+          }.freeze
+
+          ICONS = {
+            doctor: "🏥",
+            stats: "📊",
+            success: "✅",
+            error: "❌",
+            warning: "⚠️",
+            info: "ℹ️"
+          }.freeze
+
+          STATUS_GLYPHS = {
+            "pass" => "✓",
+            "warn" => "○",
+            "blocker" => "✗",
+            "skip" => "○",
+            "info" => "○"
+          }.freeze
+
+          STATUS_COLORS = {
+            "pass" => :green,
+            "warn" => :yellow,
+            "blocker" => :red,
+            "skip" => :yellow,
+            "info" => :cyan
+          }.freeze
+
+          def self.format_results(results, format: :terminal, hygiene: false, verbose: false, colors: true)
+            case format.to_sym
+            when :json
+              JSON.pretty_generate(results)
+            else
+              new(results, hygiene: hygiene, verbose: verbose, colors: colors).format_terminal
+            end
+          end
+
+          def initialize(results, hygiene:, verbose:, colors:)
+            @results = results
+            @hygiene = hygiene
+            @verbose = verbose
+            @colors = colors
+          end
+
+          def format_terminal
+            output = []
+            output << "\n#{colorize("#{ICONS[:doctor]} Setup Health Check", :bold)}"
+            output << "=" * 40
+            output.concat(format_overview)
+            output.concat(format_readiness)
+            output.concat(format_info)
+            output.concat(format_provider_pings)
+            output.concat(format_issues)
+            output << "=" * 40
+            output << format_summary_line
+            output << "\n#{colorize("Completed in #{format_duration(@results[:duration])}", :blue)}" if @results[:duration]
+            output << final_status_line
+            output.join("\n")
+          end
+
+          private
+
+          def format_overview
+            stats = @results[:stats] || {}
+            [
+              "",
+              colorize("#{ICONS[:stats]} Overview", :cyan),
+              "-" * 20,
+              "  Health checks: #{stats[:health_checks] || health_checks.length}",
+              "  Info checks: #{stats[:info_checks] || info_checks.length}",
+              "  Utility providers checked: #{stats[:provider_targets] || provider_outcomes.length}",
+              "  Hygiene findings: #{stats[:hygiene_findings] || 0}"
+            ]
+          end
+
+          def format_readiness
+            rows = health_checks.reject { |check| check[:id] == "probe-readiness" }
+            return [] if rows.empty?
+
+            output = ["", colorize("Readiness", :cyan), "-" * 20]
+            rows.each do |check|
+              output << "  #{status_glyph(check[:status])} #{check[:message]}"
+              if check[:status] == "blocker" || check[:status] == "warn" || @verbose
+                Array(check[:details]).each { |detail| output << "    - #{detail}" }
+                output << "    Next: #{check[:next_action]}" if check[:next_action]
+              end
+            end
+            output
+          end
+
+          def format_info
+            return [] if info_checks.empty?
+
+            output = ["", colorize("Info", :cyan), "-" * 20]
+            info_checks.each do |check|
+              output << "  #{status_glyph(check[:status])} #{check[:message]}"
+              if @verbose
+                Array(check[:details]).each { |detail| output << "    - #{detail}" }
+                output << "    Next: #{check[:next_action]}" if check[:next_action]
+              end
+            end
+            output
+          end
+
+          def format_provider_pings
+            check = health_checks.find { |row| row[:id] == "probe-readiness" }
+            return [] unless check
+
+            output = ["", colorize("Utility Provider Pings", :cyan), "-" * 20]
+            output << "  #{status_glyph(check[:status])} #{check[:message]}"
+            details = provider_outcomes.any? ? provider_outcomes.map { |outcome| provider_outcome_line(outcome) } : Array(check[:details])
+            details.each { |detail| output << "    #{detail}" }
+            output << "    Next: #{check[:next_action]}" if check[:next_action]
+            output
+          end
+
+          def format_issues
+            blockers = health_checks.select { |check| check[:status] == "blocker" }
+            warnings = health_checks.select { |check| check[:status] == "warn" }
+            hygiene_warnings = hygiene_checks.reject { |check| check[:status] == "pass" }
+
+            if blockers.empty? && warnings.empty? && hygiene_warnings.empty?
+              return ["", colorize("#{ICONS[:success]} No issues found", :green)]
+            end
+
+            output = ["", colorize("Issues Found:", :yellow), "-" * 20]
+            output.concat(format_issue_group("#{ICONS[:error]} Blockers", blockers, :red, include_details: true))
+            output.concat(format_issue_group("#{ICONS[:warning]} Warnings", warnings, :yellow, include_details: true))
+            output.concat(format_hygiene_group(hygiene_warnings))
+            output
+          end
+
+          def format_issue_group(title, checks, color, include_details:)
+            return [] if checks.empty?
+
+            output = ["", colorize("#{title} (#{checks.length})", color)]
+            checks.each_with_index do |check, index|
+              output << "#{index + 1}. #{check[:message]}"
+              if include_details
+                Array(check[:details]).each { |detail| output << "   - #{detail}" }
+              end
+              output << "   Next: #{check[:next_action]}" if check[:next_action]
+            end
+            output
+          end
+
+          def format_hygiene_group(checks)
+            finding_count = @results.dig(:hygiene, :finding_count) || 0
+            return [] if finding_count.zero?
+
+            if !@hygiene && !@verbose
+              return [
+                "",
+                colorize("#{ICONS[:warning]} Hygiene", :yellow),
+                "1. Hygiene findings detected (#{finding_count}); rerun with --hygiene for details"
+              ]
+            end
+
+            output = ["", colorize("#{ICONS[:warning]} Hygiene (#{finding_count})", :yellow)]
+            issue_number = 1
+            checks.each do |check|
+              output << "#{issue_number}. #{check[:message]}"
+              Array(check[:details]).each { |detail| output << "   - #{detail}" }
+              output << "   Next: #{check[:next_action]}" if check[:next_action]
+              issue_number += 1
+            end
+            output
+          end
+
+          def format_summary_line
+            health = @results[:health] || {}
+            hygiene = @results[:hygiene] || {}
+            info = @results[:info] || {}
+            parts = []
+            parts << colorize("#{health[:blocker_count]} blockers", health[:blocker_count].to_i.positive? ? :red : :green)
+            parts << colorize("#{health[:warning_count]} warnings", health[:warning_count].to_i.positive? ? :yellow : :green)
+            parts << colorize("#{info[:count]} info", :cyan)
+            parts << colorize("#{hygiene[:finding_count]} hygiene findings", hygiene[:finding_count].to_i.positive? ? :yellow : :green)
+            parts.join(", ")
+          end
+
+          def final_status_line
+            if @results[:valid]
+              if @results.dig(:health, :warning_count).to_i.positive? || @results.dig(:hygiene, :finding_count).to_i.positive?
+                colorize("Setup check passed with warnings", :yellow)
+              else
+                colorize("Setup check passed", :green)
+              end
+            else
+              colorize("Setup check failed", :red)
+            end
+          end
+
+          def provider_outcome_line(outcome)
+            elapsed = outcome[:elapsed_ms] ? " in #{outcome[:elapsed_ms]}ms" : ""
+            glyph = outcome[:status] == "pass" ? status_glyph(outcome[:status]) : colorize("✗", :red)
+            suffix = if outcome[:status] == "pass"
+              elapsed
+            elsif outcome[:failure_type] == "timeout"
+              " timed out after #{outcome[:timeout_seconds]}s"
+            else
+              " failed"
+            end
+            "#{glyph} #{target_display(outcome)}#{suffix}"
+          end
+
+          def target_display(target)
+            label = target[:label].to_s
+            selector = target[:selector].to_s
+            label = selector if label.empty?
+            selector.empty? || selector == label ? label : "#{label} (#{selector})"
+          end
+
+          def status_glyph(status)
+            glyph = STATUS_GLYPHS.fetch(status.to_s, STATUS_GLYPHS["warn"])
+            colorize(glyph, STATUS_COLORS.fetch(status.to_s, :yellow))
+          end
+
+          def health_checks
+            @health_checks ||= checks.select { |check| check[:kind] == "health" }
+          end
+
+          def hygiene_checks
+            @hygiene_checks ||= checks.select { |check| check[:kind] == "hygiene" }
+          end
+
+          def info_checks
+            @info_checks ||= checks.select { |check| check[:kind] == "info" }
+          end
+
+          def provider_outcomes
+            @provider_outcomes ||= Array(health_checks.find { |row| row[:id] == "probe-readiness" }&.fetch(:outcomes, []))
+          end
+
+          def checks
+            @results[:checks] || []
+          end
+
+          def format_duration(duration)
+            return "0ms" unless duration
+
+            duration < 1 ? "#{(duration * 1000).round}ms" : "#{duration.round(2)}s"
+          end
+
+          def colorize(text, color)
+            return text unless @colors && COLORS[color]
+
+            "#{COLORS[color]}#{text}#{COLORS[:reset]}"
+          end
+        end
+      end
+    end
+  end
+end