ocak 0.1.0 → 0.3.0

data/lib/ocak/commands/hiz.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'securerandom'
+require_relative '../config'
+require_relative '../claude_runner'
+require_relative '../git_utils'
+require_relative '../issue_fetcher'
+require_relative '../verification'
+require_relative '../planner'
+require_relative '../step_comments'
+require_relative '../logger'
+
+module Ocak
+  module Commands
+    class Hiz < Dry::CLI::Command
+      include Verification
+      include Planner
+      include StepComments
+
+      desc 'Fast-mode: implement an issue with Sonnet, create a PR (no merge)'
+
+      argument :issue, type: :integer, required: true, desc: 'Issue number to process'
+      option :watch, type: :boolean, default: false, desc: 'Stream agent activity to terminal'
+      option :dry_run, type: :boolean, default: false, desc: 'Show pipeline plan without executing'
+      option :verbose, type: :boolean, default: false, desc: 'Increase log detail'
+      option :quiet, type: :boolean, default: false, desc: 'Suppress non-error output'
+
+      STEP_MODELS = {
+        'implementer' => 'sonnet',
+        'reviewer' => 'haiku',
+        'security-reviewer' => 'sonnet'
+      }.freeze
+
+      IMPLEMENT_STEP = { agent: 'implementer', role: 'implement' }.freeze
+
+      REVIEW_STEPS = [
+        { agent: 'reviewer',          role: 'review' },
+        { agent: 'security-reviewer', role: 'security' }
+      ].freeze
+
+      HizState = Struct.new(:issues, :total_cost, :steps_run, :review_results)
+
+      def call(issue:, **options)
+        @config = Config.load
+        issue_number = issue.to_i
+
+        if options[:dry_run]
+          print_dry_run(issue_number)
+          return
+        end
+
+        logger = build_logger(issue_number)
+        watch_formatter = options[:watch] ? WatchFormatter.new : nil
+        claude = ClaudeRunner.new(config: @config, logger: logger, watch: watch_formatter)
+        issues = IssueFetcher.new(config: @config, logger: logger)
+
+        logger.info("=== Hiz (fast mode) for issue ##{issue_number} ===")
+
+        run_fast_pipeline(issue_number, claude: claude, logger: logger, issues: issues)
+      rescue Config::ConfigNotFound => e
+        warn "Error: #{e.message}"
+        exit 1
+      end
+
+      private
+
+      def print_dry_run(issue_number)
+        puts "[DRY RUN] Hiz pipeline for issue ##{issue_number}:"
+        puts '  1. implement (implementer) [sonnet]'
+        puts '  2. review (reviewer) [haiku] || security (security-reviewer) [sonnet]'
+        has_verify = @config.test_command || @config.lint_check_command
+        puts '  3. final-verify (verification)' if has_verify
+      end
+
+      def run_fast_pipeline(issue_number, claude:, logger:, issues:)
+        state = HizState.new(issues, 0.0, 0, {})
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        chdir = @config.project_dir
+
+        post_hiz_start_comment(issue_number, state: state)
+        branch = create_branch(issue_number, chdir)
+
+        failure = run_agents(issue_number, claude: claude, logger: logger, chdir: chdir, state: state)
+        if failure
+          duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time).round
+          post_hiz_summary_comment(issue_number, duration, success: false, failed_phase: failure[:phase],
+                                                           state: state)
+          handle_failure(issue_number, failure[:phase], failure[:output], issues: state.issues, logger: logger)
+          return
+        end
+
+        verification_failure = run_final_verification_step(issue_number, claude: claude, logger: logger,
+                                                                         chdir: chdir, state: state)
+        if verification_failure
+          duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time).round
+          post_hiz_summary_comment(issue_number, duration, success: false, failed_phase: 'final-verify',
+                                                           state: state)
+          handle_failure(issue_number, 'final-verify', verification_failure[:output],
+                         issues: state.issues, logger: logger)
+          return
+        end
+
+        duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time).round
+        post_hiz_summary_comment(issue_number, duration, success: true, state: state)
+        push_and_create_pr(issue_number, branch, logger: logger, chdir: chdir, state: state)
+      end
+
+      def run_agents(issue_number, claude:, logger:, chdir:, state:)
+        result = run_step(IMPLEMENT_STEP, issue_number, claude: claude, logger: logger, chdir: chdir, state: state)
+        state.steps_run += 1
+        state.total_cost += result.cost_usd.to_f
+        unless result.success?
+          logger.error("Implementation failed for issue ##{issue_number}")
+          return { phase: 'implement', output: result.output }
+        end
+
+        state.review_results = run_reviews_in_parallel(issue_number, claude: claude, logger: logger,
+                                                                     chdir: chdir, state: state)
+        nil
+      end
+
+      def create_branch(issue_number, chdir)
+        branch = "hiz/issue-#{issue_number}-#{SecureRandom.hex(4)}"
+        _, stderr, status = Open3.capture3('git', 'checkout', '-b', branch, chdir: chdir)
+        raise "Failed to create branch #{branch}: #{stderr}" unless status.success?
+
+        branch
+      end
+
+      def run_reviews_in_parallel(issue_number, claude:, logger:, chdir:, state:)
+        threads = REVIEW_STEPS.map do |step|
+          Thread.new do
+            run_step(step, issue_number, claude: claude, logger: logger, chdir: chdir, state: state)
+          rescue StandardError => e
+            logger.error("#{step[:role]} thread failed: #{e.message}")
+            nil
+          end
+        end
+
+        results = {}
+        threads.each_with_index do |thread, i|
+          result = thread.value
+          step = REVIEW_STEPS[i]
+          if result
+            state.steps_run += 1
+            state.total_cost += result.cost_usd.to_f
+            results[step[:role]] = result if result.blocking_findings? || result.warnings?
+          end
+          next if result.nil? || result.success?
+
+          logger.warn("#{step[:role]} reported issues but continuing")
+        end
+        results
+      end
+
+      def run_step(step, issue_number, claude:, logger:, chdir:, state:)
+        agent = step[:agent]
+        role = step[:role]
+        model = STEP_MODELS[agent]
+        logger.info("--- Phase: #{role} (#{agent}) [#{model}] ---")
+        post_step_comment(issue_number, "\u{1F504} **Phase: #{role}** (#{agent})", state: state)
+        prompt = build_step_prompt(role, issue_number, nil)
+        result = claude.run_agent(agent, prompt, chdir: chdir, model: model)
+        post_step_completion_comment(issue_number, role, result, state: state)
+        result
+      end
+
+      def run_final_verification_step(issue_number, claude:, logger:, chdir:, state:)
+        return nil unless @config.test_command || @config.lint_check_command
+
+        logger.info('--- Final verification ---')
+        post_step_comment(issue_number, "\u{1F504} **Phase: final-verify** (verification)", state: state)
+        result = run_final_checks(logger, chdir: chdir)
+
+        unless result[:success]
+          logger.warn('Final checks failed, attempting fix...')
+          post_step_comment(issue_number,
+                            "\u{26A0}\u{FE0F} **Final verification failed** \u2014 attempting auto-fix...",
+                            state: state)
+          fix_prompt = "Fix these test/lint failures:\n\n" \
+                       "<verification_output>\n#{result[:output]}\n</verification_output>"
+          claude.run_agent('implementer', fix_prompt,
+                           chdir: chdir, model: STEP_MODELS['implementer'])
+          result = run_final_checks(logger, chdir: chdir)
+        end
+
+        state.steps_run += 1
+        if result[:success]
+          post_step_comment(issue_number, "\u{2705} **Phase: final-verify** completed", state: state)
+          nil
+        else
+          post_step_comment(issue_number, "\u{274C} **Phase: final-verify** failed", state: state)
+          { success: false, phase: 'final-verify', output: result[:output] }
+        end
+      end
+
+      def push_and_create_pr(issue_number, branch, logger:, chdir:, state:)
+        commit_changes(issue_number, chdir, logger: logger)
+
+        _, stderr, status = Open3.capture3('git', 'push', '-u', 'origin', branch, chdir: chdir)
+        unless status.success?
+          logger.error("Push failed: #{stderr}")
+          handle_failure(issue_number, 'push', stderr, issues: state.issues, logger: logger)
+          return
+        end
+
+        issue_data = state.issues.view(issue_number)
+        issue_title = issue_data&.dig('title')
+        pr_title = issue_title ? "Fix ##{issue_number}: #{issue_title}" : "Fix ##{issue_number}"
+        pr_body = build_pr_body(issue_number, state: state)
+
+        stdout, stderr, status = Open3.capture3(
+          'gh', 'pr', 'create',
+          '--title', pr_title,
+          '--body', pr_body,
+          '--head', branch,
+          chdir: chdir
+        )
+
+        if status.success?
+          pr_url = stdout.strip
+          logger.info("PR created: #{pr_url}")
+          puts "PR created: #{pr_url}"
+        else
+          logger.error("PR creation failed: #{stderr}")
+          handle_failure(issue_number, 'pr-create', stderr, issues: state.issues, logger: logger)
+        end
+      end
+
+      def commit_changes(issue_number, chdir, logger:)
+        GitUtils.commit_changes(
+          chdir: chdir,
+          message: "feat: implement issue ##{issue_number} [hiz]",
+          logger: logger
+        )
+      end
+
+      def build_pr_body(issue_number, state:)
+        body = "Automated PR for issue ##{issue_number} (hiz fast mode)\n\nCloses ##{issue_number}"
+        return body if state.review_results.nil? || state.review_results.empty?
+
+        state.review_results.each do |role, result|
+          heading = role == 'review' ? 'Review Findings' : 'Security Review Findings'
+          body += "\n\n---\n\n## #{heading}\n\n#{result.output}"
+        end
+        body
+      end
+
+      def handle_failure(issue_number, phase, output, issues:, logger:)
+        logger.error("Issue ##{issue_number} failed at phase: #{phase}")
+        issues.comment(issue_number,
+                       "Hiz (fast mode) failed at phase: #{phase}\n\n```\n#{output.to_s[0..1000]}\n```")
+        warn "Issue ##{issue_number} failed at phase: #{phase}"
+        _, stderr, status = Open3.capture3('git', 'checkout', 'main', chdir: @config.project_dir)
+        logger.warn("Cleanup checkout to main failed: #{stderr}") unless status.success?
+      end
+
+      def build_logger(issue_number)
+        PipelineLogger.new(log_dir: File.join(@config.project_dir, @config.log_dir), issue_number: issue_number)
+      end
+
+      def post_step_comment(issue_number, body, state:)
+        state.issues&.comment(issue_number, body)
+      rescue StandardError
+        nil
+      end
+
+      def post_step_completion_comment(issue_number, role, result, state:)
+        duration = (result.duration_ms.to_f / 1000).round
+        cost = format('%.3f', result.cost_usd.to_f)
+        if result.success?
+          post_step_comment(issue_number, "\u{2705} **Phase: #{role}** completed \u2014 #{duration}s | $#{cost}",
+                            state: state)
+        else
+          post_step_comment(issue_number, "\u{274C} **Phase: #{role}** failed \u2014 #{duration}s | $#{cost}",
+                            state: state)
+        end
+      end
+
+      def post_hiz_start_comment(issue_number, state:)
+        steps = "implement \u2192 review \u2225 security"
+        steps += " \u2192 verify" if @config.test_command || @config.lint_check_command
+        post_step_comment(issue_number, "\u{1F680} **Hiz (fast mode) started** \u2014 #{steps}", state: state)
+      end
+
+      def post_hiz_summary_comment(issue_number, duration, success:, state:, failed_phase: nil)
+        total = 3 + (@config.test_command || @config.lint_check_command ? 1 : 0)
+        cost = format('%.2f', state.total_cost)
+
+        if success
+          post_step_comment(issue_number,
+                            "\u{2705} **Pipeline complete** \u2014 #{state.steps_run}/#{total} steps run " \
+                            "| 0 skipped | $#{cost} total | #{duration}s",
+                            state: state)
+        else
+          post_step_comment(issue_number,
+                            "\u{274C} **Pipeline failed** at phase: #{failed_phase} \u2014 " \
+                            "#{state.steps_run}/#{total} steps completed | $#{cost} total",
+                            state: state)
+        end
+      end
+    end
+  end
+end

data/lib/ocak/commands/init.rb

@@ -5,6 +5,7 @@ require 'fileutils'
 require_relative '../stack_detector'
 require_relative '../agent_generator'
 require_relative '../config'
+require_relative '../issue_fetcher'
 
 module Ocak
   module Commands
@@ -36,6 +37,7 @@ module Ocak
         generate_files(generator, project_dir, options)
         update_settings(project_dir, stack)
         update_gitignore(project_dir)
+        create_labels(project_dir)
 
         puts ''
         print_summary(project_dir, stack, options)
@@ -174,6 +176,15 @@ module Ocak
         puts '  Updated .gitignore'
       end
 
+      def create_labels(project_dir)
+        config = Config.load(project_dir)
+        fetcher = IssueFetcher.new(config: config)
+        fetcher.ensure_labels(config.all_labels)
+        puts '  Created GitHub labels'
+      rescue StandardError => e
+        puts "  Warning: could not create labels: #{e.message}"
+      end
+
       def print_summary(_project_dir, _stack, options)
         puts 'Ocak initialized successfully!'
         puts ''
@@ -194,10 +205,9 @@ module Ocak
         puts '  5. Run the pipeline: ocak run --once'
         puts ''
         puts 'Quick commands:'
-        puts '  ocak run --single 42    Run one issue'
+        puts '  ocak run 42             Run one issue'
         puts '  ocak run --watch        Run with live output'
         puts '  ocak status             Check pipeline state'
-        puts '  ocak audit              Run codebase audit'
       end
 
       def init_logger

data/lib/ocak/commands/resume.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../config'
+require_relative '../git_utils'
 require_relative '../pipeline_runner'
 require_relative '../pipeline_state'
 require_relative '../claude_runner'
@@ -16,14 +17,23 @@ module Ocak
 
       argument :issue, type: :integer, required: true, desc: 'Issue number to resume'
       option :watch, type: :boolean, default: false, desc: 'Stream agent activity to terminal'
+      option :dry_run, type: :boolean, default: false, desc: 'Show what would re-run without executing'
+      option :verbose, type: :boolean, default: false, desc: 'Increase log detail'
+      option :quiet, type: :boolean, default: false, desc: 'Suppress non-error output'
 
       def call(issue:, **options)
         config = Config.load
         issue_number = issue.to_i
         saved = load_state(config, issue_number)
-        chdir = resolve_worktree(config, saved)
 
         print_resume_info(issue_number, saved, config)
+
+        if options[:dry_run]
+          print_dry_run(saved, config)
+          return
+        end
+
+        chdir = resolve_worktree(config, saved)
         run_resumed_pipeline(config, issue_number, saved, chdir, options)
       rescue Config::ConfigNotFound => e
         warn "Error: #{e.message}"
@@ -51,6 +61,15 @@ module Ocak
         puts ''
       end
 
+      def print_dry_run(saved, config)
+        completed = saved[:completed_steps] || []
+        puts '[DRY RUN] Steps that would re-run:'
+        config.steps.each_with_index do |step, idx|
+          status = completed.include?(idx) ? 'skip (completed)' : 'run'
+          puts "  #{idx + 1}. #{step['role']} (#{step['agent']}) — #{status}"
+        end
+      end
+
       def run_resumed_pipeline(config, issue_number, saved, chdir, options)
         log_dir = File.join(config.project_dir, config.log_dir)
         logger = PipelineLogger.new(log_dir: log_dir, issue_number: issue_number)
@@ -61,9 +80,9 @@ module Ocak
         issues.transition(issue_number, from: config.label_failed, to: config.label_in_progress)
 
         runner = PipelineRunner.new(config: config, options: { watch: options[:watch] })
-        result = runner.send(:run_pipeline, issue_number,
-                             logger: logger, claude: claude, chdir: chdir,
-                             skip_steps: saved[:completed_steps])
+        result = runner.run_pipeline(issue_number,
+                                     logger: logger, claude: claude, chdir: chdir,
+                                     skip_steps: saved[:completed_steps])
 
         ctx = { config: config, issue_number: issue_number, saved: saved, chdir: chdir,
                 issues: issues, claude: claude, logger: logger, watch: watch_formatter }
@@ -84,7 +103,7 @@ module Ocak
 
       def attempt_merge(ctx)
         merger = MergeManager.new(config: ctx[:config], claude: ctx[:claude],
-                                  logger: ctx[:logger], watch: ctx[:watch])
+                                  logger: ctx[:logger], issues: ctx[:issues], watch: ctx[:watch])
         worktree = WorktreeManager::Worktree.new(
           path: ctx[:chdir], branch: ctx[:saved][:branch], issue_number: ctx[:issue_number]
         )
@@ -112,6 +131,11 @@ module Ocak
           exit 1
         end
 
+        unless GitUtils.safe_branch_name?(saved[:branch])
+          warn "Unsafe branch name '#{saved[:branch]}'. Cannot resume."
+          exit 1
+        end
+
         _, _, status = Open3.capture3('git', 'rev-parse', '--verify', saved[:branch], chdir: config.project_dir)
         unless status.success?
           warn "Worktree no longer exists and branch '#{saved[:branch]}' not found. Cannot resume."
@@ -120,7 +144,11 @@ module Ocak
 
         worktrees = WorktreeManager.new(config: config)
         wt = worktrees.create(saved[:issue_number], setup_command: config.setup_command)
-        Open3.capture3('git', 'checkout', saved[:branch], chdir: wt.path)
+        _, stderr, status = Open3.capture3('git', 'checkout', saved[:branch], chdir: wt.path)
+        unless status.success?
+          warn "Failed to checkout branch '#{saved[:branch]}': #{stderr}"
+          exit 1
+        end
         wt.path
       end
     end

data/lib/ocak/commands/run.rb

@@ -13,32 +13,49 @@ module Ocak
     class Run < Dry::CLI::Command
       desc 'Run the issue processing pipeline'
 
+      argument :issue, type: :integer, required: false, desc: 'Issue number (single-issue mode)'
+
       option :watch, type: :boolean, default: false, desc: 'Stream agent activity to terminal'
-      option :single, type: :integer, desc: 'Run a single issue without worktrees'
       option :dry_run, type: :boolean, default: false, desc: 'Show what would happen'
       option :once, type: :boolean, default: false, desc: 'Process current batch and exit'
       option :max_parallel, type: :integer, desc: 'Max concurrent pipelines'
       option :poll_interval, type: :integer, desc: 'Seconds between polls'
+      option :manual_review, type: :boolean, default: false,
+                             desc: 'Create PRs without auto-merge; wait for human review'
+      option :audit, type: :boolean, default: false,
+                     desc: 'Run auditor as post-pipeline gate; create PR with findings if issues found'
+      option :fast, type: :boolean, default: false,
+                    desc: 'Lean pipeline — skip security, document, audit steps'
+      option :verbose, type: :boolean, default: false, desc: 'Increase log detail'
+      option :quiet, type: :boolean, default: false, desc: 'Suppress non-error output'
 
-      def call(**options)
+      def call(issue: nil, **options)
         config = Config.load
 
         # CLI options override config
         config.override(:max_parallel, options[:max_parallel]) if options[:max_parallel]
         config.override(:poll_interval, options[:poll_interval]) if options[:poll_interval]
+        config.override(:manual_review, true) if options[:manual_review]
+        config.override(:audit_mode, true) if options[:audit]
+
+        log_level = resolve_log_level(options)
 
         runner = PipelineRunner.new(
           config: config,
           options: {
             watch: options[:watch],
-            single: options[:single],
+            single: issue&.to_i,
             dry_run: options[:dry_run],
-            once: options[:once]
+            once: options[:once],
+            fast: options[:fast],
+            log_level: log_level
           }
         )
 
         setup_signal_handlers(runner)
         runner.run
+        runner.print_shutdown_summary if runner.shutting_down?
+        exit 130 if runner.shutting_down?
       rescue Config::ConfigNotFound => e
         warn "Error: #{e.message}"
         exit 1
@@ -46,12 +63,17 @@ module Ocak
 
       private
 
+      def resolve_log_level(options)
+        return :quiet if options[:quiet]
+        return :verbose if options[:verbose]
+
+        :normal
+      end
+
       def setup_signal_handlers(runner)
         %w[INT TERM].each do |signal|
           trap(signal) do
-            warn "\nReceived #{signal}, shutting down gracefully..."
             runner.shutdown!
-            exit 0
           end
         end
       end

data/lib/ocak/commands/status.rb

@@ -3,6 +3,7 @@
 require 'open3'
 require 'json'
 require_relative '../config'
+require_relative '../run_report'
 require_relative '../worktree_manager'
 
 module Ocak
@@ -10,9 +11,24 @@ module Ocak
     class Status < Dry::CLI::Command
       desc 'Show pipeline status'
 
-      def call(**)
+      option :report, type: :boolean, default: false, desc: 'Show run reports'
+
+      def call(**options)
         config = Config.load
 
+        if options[:report]
+          show_reports(config)
+        else
+          show_default_status(config)
+        end
+      rescue Config::ConfigNotFound => e
+        warn "Error: #{e.message}"
+        exit 1
+      end
+
+      private
+
+      def show_default_status(config)
         puts 'Pipeline Status'
         puts '=' * 40
         puts ''
@@ -22,13 +38,8 @@ module Ocak
         show_worktrees(config)
         puts ''
         show_recent_logs(config)
-      rescue Config::ConfigNotFound => e
-        warn "Error: #{e.message}"
-        exit 1
       end
 
-      private
-
       def show_issues(config)
         puts 'Issues:'
 
@@ -72,6 +83,109 @@ module Ocak
         end
       end
 
+      def show_reports(config)
+        reports = RunReport.load_all(project_dir: config.project_dir)
+
+        if reports.empty?
+          puts 'No run reports found.'
+          return
+        end
+
+        sorted = reports.sort_by { |r| r[:started_at].to_s }.reverse
+        show_recent_runs(sorted)
+        puts ''
+        show_aggregates(sorted)
+      end
+
+      def show_recent_runs(reports)
+        puts 'Recent Runs (last 10):'
+        reports.first(10).each do |r|
+          icon = r[:success] ? "\u2705" : "\u274C"
+          steps_str = step_count_str(r)
+          date = format_report_date(r[:started_at])
+          failed = r[:success] ? '' : "  (failed: #{r[:failed_phase]})"
+          cost = format('$%.2f', r[:total_cost_usd].to_f)
+          puts "  ##{r[:issue_number]}  #{icon}  #{r[:total_duration_s]}s  #{cost}  #{steps_str}  #{date}#{failed}"
+        end
+      end
+
+      def show_aggregates(reports)
+        recent = reports.first(20)
+        puts "Aggregates (last #{recent.size} runs):"
+
+        avg_cost = recent.sum { |r| r[:total_cost_usd].to_f } / recent.size
+        avg_duration = recent.sum { |r| r[:total_duration_s].to_i } / recent.size
+        success_count = recent.count { |r| r[:success] }
+        success_rate = (success_count.to_f / recent.size * 100).round
+
+        puts "  Avg cost:      $#{format('%.2f', avg_cost)}"
+        puts "  Avg duration:  #{avg_duration}s"
+        puts "  Success rate:  #{success_rate}%"
+
+        show_slowest_step(recent)
+        show_most_skipped(recent)
+      end
+
+      def show_slowest_step(reports)
+        durations, costs = collect_step_metrics(reports)
+        return if durations.empty?
+
+        name, dur_values = durations.max_by { |_, vals| vals.sum.to_f / vals.size }
+        avg_dur = (dur_values.sum.to_f / dur_values.size).round
+        avg_cost = costs[name].sum / costs[name].size
+        puts "  Slowest step:  #{name} (avg #{avg_dur}s, $#{format('%.2f', avg_cost)})"
+      end
+
+      def collect_step_metrics(reports)
+        durations = Hash.new { |h, k| h[k] = [] }
+        costs = Hash.new { |h, k| h[k] = [] }
+
+        reports.each do |r|
+          (r[:steps] || []).each do |s|
+            next unless s[:status] == 'completed'
+
+            durations[s[:role]] << s[:duration_s].to_i
+            costs[s[:role]] << s[:cost_usd].to_f
+          end
+        end
+
+        [durations, costs]
+      end
+
+      def show_most_skipped(reports)
+        skip_counts = Hash.new(0)
+        total_counts = Hash.new(0)
+
+        reports.each do |r|
+          (r[:steps] || []).each do |s|
+            total_counts[s[:role]] += 1
+            skip_counts[s[:role]] += 1 if s[:status] == 'skipped'
+          end
+        end
+
+        skipped_roles = skip_counts.select { |_, count| count.positive? }
+        return if skipped_roles.empty?
+
+        most = skipped_roles.max_by { |role, count| count.to_f / total_counts[role] }
+        name = most[0]
+        rate = (most[1].to_f / total_counts[name] * 100).round
+        puts "  Most skipped:  #{name} (#{rate}% skip rate)"
+      end
+
+      def step_count_str(report)
+        steps = report[:steps] || []
+        completed = steps.count { |s| s[:status] == 'completed' }
+        "#{completed}/#{steps.size} steps"
+      end
+
+      def format_report_date(iso_str)
+        return 'unknown' unless iso_str
+
+        Time.parse(iso_str).strftime('%Y-%m-%d %H:%M')
+      rescue ArgumentError
+        iso_str.to_s[0..15]
+      end
+
       def fetch_issue_count(label, config)
         stdout, _, status = Open3.capture3(
           'gh', 'issue', 'list',