ocak 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f09506ff0c348c7f0822da37268c614ea209b9ca8edb643b7a4619df96113a3
-  data.tar.gz: 90a52276424ab7f2dbaa19643ca22ffde525460089d7f2b3f97670c638b43f2b
+  metadata.gz: bb7c3ddd6ff9b6dacc60c4ee6f3fabae90089eace4e457a28e824be15a901cda
+  data.tar.gz: c9b5a76e36361dddb4731fff6298388f0246421272923951f83fdcebde9e5d4b
 SHA512:
-  metadata.gz: 04fd822b0fc96ae9f845d97c431a40552c081d56475925069c2158685d126fb816ef87ddd9946b041c2bf624e9e6676a92c2ab30da2b8d10128eebb7a133a57b
-  data.tar.gz: 111a2c5c925cbad3919f65a92ed3d0d16c88acfd934d0e8d1baf97b21d966a53822129255f28f1941b692bd03eb455eff8ca186555d9e78b2cce189085f53853
+  metadata.gz: 9f37e6ad101953a378c73a1c76817e194386424174a87841d9f13321a4b465c5708ecb374f0526d2e2744bbcd19bd2473727ea288205dd731325ba80164fcec8
+  data.tar.gz: 18301a7948e7b979f7ee0daecd75369477ddbcd147d12d67305fdc55a7aeab44e371bd41859135f5c8105d5886ff49663f77cc61afaad9b9872a13581bac15f1

data/README.md

@@ -173,6 +173,19 @@ When `--manual-review` is enabled, PRs sit open for human review. After leaving
 4. Remove the `auto-reready` label
 5. Comment "Feedback addressed. Please re-review."
 
+### Local Issues (Offline Mode)
+
+Ocak can run without GitHub. Set `issues.backend: local` in `ocak.yml` (or just create `.ocak/issues/` and it auto-detects). Issues are stored as numbered markdown files with YAML frontmatter.
+
+```bash
+ocak issue create "Add retry logic to API client" --label auto-ready
+ocak issue list
+ocak issue view 1
+ocak run 1 --watch
+```
+
+Issues live in `.ocak/issues/0001.md`, `.ocak/issues/0002.md`, etc. Labels, complexity, and pipeline comments are all tracked in the file. Merging goes straight to main (no PRs) via `LocalMergeManager`.
+
 ### Graceful Shutdown
 
 `Ctrl+C` once — current agent step finishes, then the pipeline stops. WIP gets committed, labels reset to `auto-ready`, and resume commands are printed.
@@ -199,6 +212,10 @@ stack:
     - "bundle exec brakeman -q"
     - "bundle exec bundler-audit check"
 
+# Issue backend (omit for GitHub, or set to "local" for offline mode)
+issues:
+  backend: github          # or "local" — auto-detected if .ocak/issues/ exists
+
 # Pipeline settings
 pipeline:
   max_parallel: 5
@@ -398,6 +415,16 @@ ocak clean                           Remove stale worktrees
      --all                          Clean worktrees and logs
      --keep N                       Only remove artifacts older than N days
 
+ocak issue create TITLE [options]    Create a local issue
+     --body TEXT                     Issue body (opens $EDITOR if omitted)
+     --label LABEL                  Add label (repeatable)
+     --complexity full|simple       Set complexity (default: full)
+
+ocak issue list [--label LABEL]      List local issues
+ocak issue view ISSUE                View a local issue
+ocak issue edit ISSUE                Open issue in $EDITOR
+ocak issue close ISSUE               Mark issue as completed
+
 ocak design [DESCRIPTION]            Launch interactive issue design session
 ocak audit [SCOPE]                   Print instructions for /audit skill
 ocak debt                            Print instructions for /debt skill

data/lib/ocak/agent_generator.rb

@@ -3,6 +3,7 @@
 require 'erb'
 require 'fileutils'
 require 'open3'
+require_relative 'claude_runner'
 
 module Ocak
   class AgentGenerator
@@ -161,7 +162,7 @@ module Ocak
       stdout, _, status = Open3.capture3(
         'claude', '-p',
         '--output-format', 'text',
-        '--model', 'haiku',
+        '--model', ClaudeRunner::MODEL_HAIKU,
         '--allowedTools', 'Read,Glob,Grep',
         '--', prompt,
         chdir: @project_dir

data/lib/ocak/batch_processing.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Ocak
+  # Batch processing logic — process_issues, run_batch, process_one_issue, build_issue_result.
+  # Extracted from PipelineRunner to reduce file size.
+  module BatchProcessing
+    private
+
+    def process_issues(ready_issues, logger:, issues:)
+      if ready_issues.size > @config.max_issues_per_run
+        logger.warn("Capping to #{@config.max_issues_per_run} issues (found #{ready_issues.size})")
+        ready_issues = ready_issues.first(@config.max_issues_per_run)
+      end
+
+      claude = build_claude(logger)
+      batches = @executor.plan_batches(ready_issues, logger: logger, claude: claude)
+
+      batches.each_with_index do |batch, idx|
+        batch_issues = batch['issues'][0...@config.max_parallel]
+        logger.info("Running batch #{idx + 1}/#{batches.size} (#{batch_issues.size} issues)")
+
+        if @options[:dry_run]
+          batch_issues.each { |i| logger.info("[DRY RUN] Would process issue ##{i['number']}: #{i['title']}") }
+          next
+        end
+
+        run_batch(batch_issues, logger: logger, issues: issues)
+      end
+    end
+
+    def run_batch(batch_issues, logger:, issues:)
+      worktrees = WorktreeManager.new(config: @config, logger: logger)
+
+      threads = batch_issues.map do |issue|
+        Thread.new { process_one_issue(issue, worktrees: worktrees, issues: issues) }
+      end
+      results = threads.map(&:value)
+
+      unless @shutting_down
+        merger = build_merge_manager(logger: logger, issues: issues)
+        results.select { |r| r[:success] }.each do |result|
+          merge_completed_issue(result, merger: merger, issues: issues, logger: logger)
+        end
+      end
+
+      results.each do |result|
+        next unless result[:worktree]
+        next if result[:interrupted]
+
+        worktrees.remove(result[:worktree])
+      rescue StandardError => e
+        logger.warn("Failed to clean worktree for ##{result[:issue_number]}: #{e.message}")
+      end
+
+      programming_error = results.find { |r| r[:programming_error] }&.dig(:programming_error)
+      raise programming_error if programming_error
+    end
+
+    def process_one_issue(issue, worktrees:, issues:)
+      issue_number = issue['number']
+      logger = build_logger(issue_number: issue_number)
+      claude = build_claude(logger)
+      worktree = nil
+
+      @active_mutex.synchronize do
+        @active_issues << issue_number
+      end
+      issues.transition(issue_number, from: @config.label_ready, to: @config.label_in_progress)
+      worktree = worktrees.create(issue_number, setup_command: @config.setup_command)
+      logger.info("Created worktree at #{worktree.path} (branch: #{worktree.branch})")
+
+      complexity = @options[:fast] ? 'simple' : issue.fetch('complexity', 'full')
+      result = run_pipeline(issue_number, logger: logger, claude: claude, chdir: worktree.path,
+                                          complexity: complexity, skip_merge: true)
+
+      build_issue_result(result, issue_number: issue_number, worktree: worktree, issues: issues,
+                                 logger: logger)
+    rescue StandardError => e
+      handle_process_error(e, issue_number: issue_number, logger: logger, issues: issues)
+      result = { issue_number: issue_number, success: false, worktree: worktree, error: e.message }
+      # NameError includes NoMethodError
+      result[:programming_error] = e if e.is_a?(NameError) || e.is_a?(TypeError)
+      result
+    ensure
+      @active_mutex.synchronize { @active_issues.delete(issue_number) }
+    end
+
+    def build_issue_result(result, issue_number:, worktree:, issues:, logger: nil)
+      if result[:interrupted]
+        handle_interrupted_issue(issue_number, worktree&.path, result[:phase],
+                                 logger: logger || build_logger(issue_number: issue_number), issues: issues)
+        { issue_number: issue_number, success: false, worktree: worktree, interrupted: true }
+      elsif result[:success]
+        { issue_number: issue_number, success: true, worktree: worktree,
+          audit_blocked: result[:audit_blocked], audit_output: result[:audit_output] }
+      else
+        report_pipeline_failure(issue_number, result, issues: issues, config: @config, logger: logger)
+        { issue_number: issue_number, success: false, worktree: worktree }
+      end
+    end
+  end
+end

data/lib/ocak/claude_runner.rb

@@ -28,15 +28,19 @@ module Ocak
       'planner' => 'Read,Glob,Grep,Bash'
     }.freeze
 
+    MODEL_HAIKU  = ENV.fetch('OCAK_MODEL_HAIKU',  'haiku')
+    MODEL_SONNET = ENV.fetch('OCAK_MODEL_SONNET', 'sonnet')
+    MODEL_OPUS   = ENV.fetch('OCAK_MODEL_OPUS',   'opus')
+
     AGENT_MODELS = {
-      'planner' => 'haiku',
-      'reviewer' => 'sonnet',
-      'security-reviewer' => 'sonnet',
-      'auditor' => 'sonnet',
-      'documenter' => 'sonnet',
-      'merger' => 'sonnet',
-      'implementer' => nil,
-      'pipeline' => nil
+      'planner' => MODEL_SONNET,
+      'reviewer' => MODEL_OPUS,
+      'security-reviewer' => MODEL_SONNET,
+      'auditor' => MODEL_SONNET,
+      'documenter' => MODEL_SONNET,
+      'merger' => MODEL_SONNET,
+      'implementer' => MODEL_SONNET,
+      'pipeline' => MODEL_OPUS
     }.freeze
 
     TIMEOUT = 600 # 10 minutes per agent invocation

data/lib/ocak/cli.rb

@@ -10,6 +10,11 @@ require_relative 'commands/status'
 require_relative 'commands/clean'
 require_relative 'commands/resume'
 require_relative 'commands/hiz'
+require_relative 'commands/issue/create'
+require_relative 'commands/issue/list'
+require_relative 'commands/issue/view'
+require_relative 'commands/issue/edit'
+require_relative 'commands/issue/close'
 
 module Ocak
   module CLI
@@ -25,6 +30,14 @@ module Ocak
       register 'clean',  Ocak::Commands::Clean
       register 'resume', Ocak::Commands::Resume
       register 'hiz',    Ocak::Commands::Hiz
+
+      register 'issue' do |prefix|
+        prefix.register 'create', Ocak::Commands::Issue::Create
+        prefix.register 'list',   Ocak::Commands::Issue::List
+        prefix.register 'view',   Ocak::Commands::Issue::View
+        prefix.register 'edit',   Ocak::Commands::Issue::Edit
+        prefix.register 'close',  Ocak::Commands::Issue::Close
+      end
     end
   end
 end

data/lib/ocak/command_runner.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Ocak
+  module CommandRunner
+    CommandResult = Struct.new(:stdout, :stderr, :status) do
+      def success?
+        status&.success? == true
+      end
+
+      def output
+        stdout.strip
+      end
+
+      def error
+        stderr[0...500]
+      end
+    end
+
+    private
+
+    def run_git(*, chdir: nil)
+      run_command('git', *, chdir: chdir)
+    end
+
+    def run_gh(*, chdir: nil)
+      run_command('gh', *, chdir: chdir)
+    end
+
+    def run_command(*, chdir: nil)
+      opts = chdir ? { chdir: chdir } : {}
+      stdout, stderr, status = Open3.capture3(*, **opts)
+      CommandResult.new(stdout, stderr, status)
+    rescue Errno::ENOENT => e
+      CommandResult.new('', e.message, nil)
+    end
+  end
+end

data/lib/ocak/commands/hiz.rb

@@ -5,7 +5,7 @@ require 'securerandom'
 require_relative '../config'
 require_relative '../claude_runner'
 require_relative '../git_utils'
-require_relative '../issue_fetcher'
+require_relative '../issue_backend'
 require_relative '../pipeline_executor'
 require_relative '../step_comments'
 require_relative '../logger'
@@ -24,9 +24,9 @@ module Ocak
       option :quiet, type: :boolean, default: false, desc: 'Suppress non-error output'
 
       HIZ_STEPS = [
-        { agent: 'implementer', role: 'implement', model: 'sonnet' },
-        { agent: 'reviewer', role: 'review', model: 'haiku', parallel: true },
-        { agent: 'security-reviewer', role: 'security', model: 'sonnet', parallel: true }
+        { agent: 'implementer', role: 'implement', model: ClaudeRunner::MODEL_SONNET },
+        { agent: 'reviewer', role: 'review', model: ClaudeRunner::MODEL_HAIKU, parallel: true },
+        { agent: 'security-reviewer', role: 'security', model: ClaudeRunner::MODEL_SONNET, parallel: true }
       ].freeze
 
       HizState = Struct.new(:issues, :total_cost, :steps_run, :review_results)
@@ -43,7 +43,7 @@ module Ocak
         @logger = 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)
+        issues = IssueBackend.build(config: @config, logger: logger)
 
         logger.info("=== Hiz (fast mode) for issue ##{issue_number} ===")
 
@@ -81,7 +81,7 @@ module Ocak
         executor = PipelineExecutor.new(config: @config, issues: issues)
         result = executor.run_pipeline(
           issue_number, logger: logger, claude: claude, chdir: chdir,
-                        steps: HIZ_STEPS, verification_model: 'sonnet',
+                        steps: HIZ_STEPS, verification_model: ClaudeRunner::MODEL_SONNET,
                         post_start_comment: false, post_summary_comment: false
         )
 
@@ -190,7 +190,8 @@ module Ocak
           sanitized = output.to_s[0..1000].gsub('```', "'''")
           issues.comment(issue_number,
                          "Hiz (fast mode) failed at phase: #{phase}\n\n```\n#{sanitized}\n```")
-        rescue StandardError
+        rescue StandardError => e
+          logger&.debug("Failure comment failed: #{e.message}")
           nil
         end
         warn "Issue ##{issue_number} failed at phase: #{phase}"

data/lib/ocak/commands/init.rb

@@ -183,6 +183,11 @@ module Ocak
 
       def create_labels(project_dir)
         config = Config.load(project_dir)
+        if config.local_issues?
+          puts '  Skipped label creation (local issue backend)'
+          return
+        end
+
         fetcher = IssueFetcher.new(config: config)
         fetcher.ensure_labels(config.all_labels)
         puts '  Created GitHub labels'

data/lib/ocak/commands/issue/close.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../../config'
+require_relative '../../local_issue_fetcher'
+
+module Ocak
+  module Commands
+    module Issue
+      class Close < Dry::CLI::Command
+        desc 'Close a local issue (sets completed label)'
+
+        argument :issue, type: :integer, required: true, desc: 'Issue number'
+
+        def call(issue:, **)
+          config = Config.load
+          fetcher = LocalIssueFetcher.new(config: config)
+          issue_number = issue.to_i
+
+          data = fetcher.view(issue_number)
+          unless data
+            warn "Issue ##{issue} not found."
+            exit 1
+          end
+
+          fetcher.remove_label(issue_number, config.label_ready)
+          fetcher.remove_label(issue_number, config.label_in_progress)
+          fetcher.add_label(issue_number, config.label_completed)
+
+          puts "Closed issue ##{issue_number}: #{data['title']}"
+        rescue Config::ConfigNotFound => e
+          warn "Error: #{e.message}"
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/ocak/commands/issue/create.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative '../../config'
+require_relative '../../local_issue_fetcher'
+
+module Ocak
+  module Commands
+    module Issue
+      class Create < Dry::CLI::Command
+        desc 'Create a local issue'
+
+        argument :title, type: :string, required: true, desc: 'Issue title'
+        option :body, type: :string, default: '', desc: 'Issue body (opens $EDITOR if omitted)'
+        option :label, type: :array, default: [], desc: 'Labels to add (repeatable)'
+        option :complexity, type: :string, default: 'full', desc: 'Issue complexity (full or simple)'
+
+        def call(title:, **options)
+          config = Config.load
+          fetcher = LocalIssueFetcher.new(config: config)
+
+          body = options[:body]
+          body = read_from_editor(title) if body.empty?
+
+          number = fetcher.create(
+            title: title,
+            body: body,
+            labels: options[:label],
+            complexity: options[:complexity]
+          )
+
+          path = File.join('.ocak', 'issues', format('%04d.md', number))
+          puts "Created issue ##{number} (#{path})"
+        rescue Config::ConfigNotFound => e
+          warn "Error: #{e.message}"
+          exit 1
+        end
+
+        private
+
+        def read_from_editor(title)
+          editor = ENV.fetch('EDITOR', 'vi')
+          require 'tempfile'
+          file = Tempfile.new(['ocak-issue', '.md'])
+          file.write("#{title}\n\n")
+          file.close
+
+          system(editor, file.path)
+          content = File.read(file.path)
+          # Strip the title line if it's still there
+          lines = content.lines
+          lines.shift if lines.first&.strip == title
+          lines.join.strip
+        ensure
+          file&.unlink
+        end
+      end
+    end
+  end
+end

data/lib/ocak/commands/issue/edit.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative '../../config'
+
+module Ocak
+  module Commands
+    module Issue
+      class Edit < Dry::CLI::Command
+        desc 'Edit a local issue in $EDITOR'
+
+        argument :issue, type: :integer, required: true, desc: 'Issue number'
+
+        def call(issue:, **)
+          config = Config.load
+          path = File.join(config.project_dir, '.ocak', 'issues', format('%04d.md', issue.to_i))
+
+          unless File.exist?(path)
+            warn "Issue ##{issue} not found at #{path}"
+            exit 1
+          end
+
+          editor = ENV.fetch('EDITOR', 'vi')
+          system(editor, path)
+        rescue Config::ConfigNotFound => e
+          warn "Error: #{e.message}"
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/ocak/commands/issue/list.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../../config'
+require_relative '../../local_issue_fetcher'
+
+module Ocak
+  module Commands
+    module Issue
+      class List < Dry::CLI::Command
+        desc 'List local issues'
+
+        option :label, type: :string, desc: 'Filter by label'
+
+        def call(**options)
+          config = Config.load
+          fetcher = LocalIssueFetcher.new(config: config)
+          issues = fetcher.all_issues
+
+          if options[:label]
+            issues = issues.select do |i|
+              i['labels']&.any? { |l| l['name'] == options[:label] }
+            end
+          end
+
+          if issues.empty?
+            puts 'No issues found.'
+            return
+          end
+
+          issues.sort_by { |i| i['number'] }.each do |issue|
+            labels = (issue['labels'] || []).map { |l| l['name'] }.join(', ')
+            label_str = labels.empty? ? '' : "  [#{labels}]"
+            puts format('#%-4<num>d %<title>s%<labels>s',
+                        num: issue['number'], title: issue['title'], labels: label_str)
+          end
+        rescue Config::ConfigNotFound => e
+          warn "Error: #{e.message}"
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/ocak/commands/issue/view.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative '../../config'
+require_relative '../../local_issue_fetcher'
+
+module Ocak
+  module Commands
+    module Issue
+      class View < Dry::CLI::Command
+        desc 'View a local issue'
+
+        argument :issue, type: :integer, required: true, desc: 'Issue number'
+
+        def call(issue:, **)
+          config = Config.load
+          fetcher = LocalIssueFetcher.new(config: config)
+          data = fetcher.view(issue.to_i)
+
+          unless data
+            warn "Issue ##{issue} not found."
+            exit 1
+          end
+
+          labels = (data['labels'] || []).map { |l| l['name'] }.join(', ')
+          puts "##{data['number']}  #{data['title']}"
+          puts "Labels: #{labels}" unless labels.empty?
+          puts "Complexity: #{data['complexity']}" if data['complexity'] && data['complexity'] != 'full'
+          puts ''
+          puts data['body'] unless data['body'].to_s.empty?
+
+          # Show pipeline comments from the raw file
+          path = File.join('.ocak', 'issues', format('%04d.md', issue.to_i))
+          show_pipeline_comments(path)
+        rescue Config::ConfigNotFound => e
+          warn "Error: #{e.message}"
+          exit 1
+        end
+
+        private
+
+        def show_pipeline_comments(path)
+          return unless File.exist?(path)
+
+          content = File.read(path)
+          sentinel = LocalIssueFetcher::COMMENTS_SENTINEL
+          return unless content.include?(sentinel)
+
+          comments = content.split(sentinel, 2).last.to_s.strip
+          return if comments.empty?
+
+          puts ''
+          puts '--- Pipeline Activity ---'
+          puts comments
+        end
+      end
+    end
+  end
+end

data/lib/ocak/commands/resume.rb

@@ -6,7 +6,7 @@ require_relative '../git_utils'
 require_relative '../pipeline_runner'
 require_relative '../pipeline_state'
 require_relative '../claude_runner'
-require_relative '../issue_fetcher'
+require_relative '../issue_backend'
 require_relative '../worktree_manager'
 require_relative '../merge_manager'
 require_relative '../logger'
@@ -78,7 +78,7 @@ module Ocak
         logger = PipelineLogger.new(log_dir: log_dir, issue_number: 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)
+        issues = IssueBackend.build(config: config, logger: logger)
 
         issues.transition(issue_number, from: config.label_failed, to: config.label_in_progress)
 
@@ -96,7 +96,8 @@ module Ocak
         if result[:success]
           attempt_merge(ctx)
         else
-          report_pipeline_failure(ctx[:issue_number], result, issues: ctx[:issues], config: ctx[:config])
+          report_pipeline_failure(ctx[:issue_number], result, issues: ctx[:issues], config: ctx[:config],
+                                                              logger: ctx[:logger])
           warn "Issue ##{ctx[:issue_number]} failed again at phase: #{result[:phase]}"
         end
       end

data/lib/ocak/commands/status.rb

@@ -3,6 +3,7 @@
 require 'open3'
 require 'json'
 require_relative '../config'
+require_relative '../issue_backend'
 require_relative '../run_report'
 require_relative '../worktree_manager'
 
@@ -42,7 +43,26 @@ module Ocak
 
       def show_issues(config)
         puts 'Issues:'
+        fetcher = IssueBackend.build(config: config)
 
+        if fetcher.is_a?(LocalIssueFetcher)
+          show_local_issues(fetcher, config)
+        else
+          show_github_issues(config)
+        end
+      end
+
+      def show_local_issues(fetcher, config)
+        all = fetcher.all_issues
+        %w[ready in_progress completed failed].each do |state|
+          label = config.send(:"label_#{state}")
+          count = all.count { |i| i['labels']&.any? { |l| l['name'] == label } }
+          icon = { 'ready' => '  ', 'in_progress' => '  ', 'completed' => '  ', 'failed' => '  ' }[state]
+          puts "  #{icon} #{state.tr('_', ' ')}: #{count} (label: #{label})"
+        end
+      end
+
+      def show_github_issues(config)
         %w[ready in_progress completed failed].each do |state|
           label = config.send(:"label_#{state}")
           count = fetch_issue_count(label, config)

data/lib/ocak/config.rb

@@ -72,6 +72,10 @@ module Ocak
     def require_comment    = dig(:safety, :require_comment)
     def max_issues_per_run = dig(:safety, :max_issues_per_run) || 5
 
+    # Issues
+    def issue_backend = dig(:issues, :backend)
+    def local_issues? = issue_backend == 'local'
+
     # Labels
     def label_ready = dig(:labels, :ready) || 'auto-ready'
     def label_in_progress = dig(:labels, :in_progress) || 'auto-doing'

data/lib/ocak/failure_reporting.rb

@@ -4,12 +4,13 @@ module Ocak
   # Shared pipeline failure reporting — label transition + comment posting.
   # Included by PipelineRunner and Commands::Resume.
   module FailureReporting
-    def report_pipeline_failure(issue_number, result, issues:, config:)
+    def report_pipeline_failure(issue_number, result, issues:, config:, logger: nil)
       issues.transition(issue_number, from: config.label_in_progress, to: config.label_failed)
       sanitized = result[:output][0..1000].to_s.gsub('```', "'''")
       issues.comment(issue_number,
                      "Pipeline failed at phase: #{result[:phase]}\n\n```\n#{sanitized}\n```")
-    rescue StandardError
+    rescue StandardError => e
+      logger&.debug("Failure report failed: #{e.message}")
       nil
     end
   end