ocak 0.5.0 → 0.6.1

data/lib/ocak/conflict_resolution.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Ocak
+  # Rebase and conflict resolution logic — rebase_onto_main, resolve_conflicts_via_agent.
+  # Extracted from MergeManager to reduce file size.
+  module ConflictResolution
+    private
+
+    def rebase_onto_main(worktree)
+      fetch_result = run_git('fetch', 'origin', 'main', chdir: worktree.path)
+      unless fetch_result.success?
+        @logger.error("git fetch origin main failed: #{fetch_result.error}")
+        return false
+      end
+
+      rebase_result = run_git('rebase', 'origin/main', chdir: worktree.path)
+
+      return true if rebase_result.success?
+
+      @logger.warn("Rebase conflict, aborting rebase: #{rebase_result.error}")
+      abort_result = run_git('rebase', '--abort', chdir: worktree.path)
+      @logger.warn("git rebase --abort failed: #{abort_result.error}") unless abort_result.success?
+
+      # Fall back to merge strategy
+      @logger.info('Attempting merge strategy instead...')
+      merge_result = run_git('merge', 'origin/main', '--no-edit', chdir: worktree.path)
+
+      return true if merge_result.success?
+
+      # Merge also has conflicts — try to resolve via agent
+      @logger.warn("Merge conflict, attempting agent resolution: #{merge_result.error}")
+      resolve_conflicts_via_agent(worktree)
+    end
+
+    def resolve_conflicts_via_agent(worktree)
+      # Get list of conflicting files
+      diff_result = run_git('diff', '--name-only', '--diff-filter=U', chdir: worktree.path)
+      conflicting = diff_result.stdout.lines.map(&:strip).reject(&:empty?)
+
+      if conflicting.empty?
+        @logger.warn('No conflicting files found, aborting merge')
+        run_git('merge', '--abort', chdir: worktree.path)
+        return false
+      end
+
+      result = @claude.run_agent(
+        'implementer',
+        "Resolve these merge conflicts.\n\n<conflicting_files>\n#{conflicting.join("\n")}\n</conflicting_files>\n\n" \
+        'Open each file, find conflict markers (<<<<<<< ======= >>>>>>>), and resolve them. ' \
+        'Then run `git add` on each resolved file.',
+        chdir: worktree.path
+      )
+
+      if result.success?
+        # Check if all conflicts resolved
+        remaining_result = run_git('diff', '--name-only', '--diff-filter=U', chdir: worktree.path)
+        if remaining_result.output.empty?
+          commit_result = run_git('commit', '--no-edit', chdir: worktree.path)
+          unless commit_result.success?
+            @logger.error("Commit after conflict resolution failed: #{commit_result.error}")
+            return false
+          end
+          @logger.info('Merge conflicts resolved by agent')
+          return true
+        end
+      end
+
+      @logger.error('Agent could not resolve merge conflicts')
+      run_git('merge', '--abort', chdir: worktree.path)
+      false
+    end
+  end
+end

data/lib/ocak/failure_reporting.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
+require_relative 'issue_state_machine'
+
 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:, logger: nil)
-      issues.transition(issue_number, from: config.label_in_progress, to: config.label_failed)
+      IssueStateMachine.new(config: config, issues: issues).mark_failed(issue_number)
       sanitized = result[:output][0..1000].to_s.gsub('```', "'''")
       issues.comment(issue_number,
                      "Pipeline failed at phase: #{result[:phase]}\n\n```\n#{sanitized}\n```")

data/lib/ocak/instance_builders.rb

@@ -17,8 +17,12 @@ module Ocak
       ClaudeRunner.new(config: @config, logger: logger, watch: @watch_formatter, registry: @registry)
     end
 
+    def build_state_machine(issues)
+      IssueStateMachine.new(config: @config, issues: issues)
+    end
+
     def build_merge_manager(logger:, issues:)
-      if issues.is_a?(LocalIssueFetcher) && !gh_available?
+      if issues.is_a?(LocalIssueFetcher) && !@config.multi_repo? && !gh_available?
         LocalMergeManager.new(config: @config, logger: logger, issues: issues)
       else
         MergeManager.new(config: @config, claude: build_claude(logger), logger: logger,

data/lib/ocak/issue_fetcher.rb

@@ -134,6 +134,15 @@ module Ocak
       nil
     end
 
+    def repo_nwo
+      return @repo_nwo if defined?(@repo_nwo_resolved)
+
+      stdout, _, status = run_gh('repo', 'view', '--json', 'nameWithOwner', '-q', '.nameWithOwner')
+      @repo_nwo = status.success? ? stdout.strip : nil
+      @repo_nwo_resolved = true
+      @repo_nwo
+    end
+
     private
 
     def in_progress?(issue)

data/lib/ocak/issue_state_machine.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Ocak
+  # Encapsulates all valid label transitions for pipeline issue processing.
+  # Replaces scattered issues.transition calls with named, intention-revealing methods.
+  class IssueStateMachine
+    def initialize(config:, issues:)
+      @config = config
+      @issues = issues
+    end
+
+    def mark_in_progress(issue_number)
+      @issues&.transition(issue_number, from: @config.label_ready, to: @config.label_in_progress)
+    end
+
+    def mark_completed(issue_number)
+      @issues&.transition(issue_number, from: @config.label_in_progress, to: @config.label_completed)
+    end
+
+    def mark_failed(issue_number)
+      @issues&.transition(issue_number, from: @config.label_in_progress, to: @config.label_failed)
+    end
+
+    def mark_interrupted(issue_number)
+      @issues&.transition(issue_number, from: @config.label_in_progress, to: @config.label_ready)
+    end
+
+    def mark_for_review(issue_number)
+      @issues&.transition(issue_number, from: @config.label_in_progress, to: @config.label_awaiting_review)
+    end
+
+    def mark_resuming(issue_number)
+      @issues&.transition(issue_number, from: @config.label_failed, to: @config.label_in_progress)
+    end
+  end
+end

data/lib/ocak/merge_manager.rb

@@ -4,10 +4,14 @@ require 'open3'
 require 'shellwords'
 require_relative 'git_utils'
 require_relative 'command_runner'
+require_relative 'conflict_resolution'
+require_relative 'merge_verification'
 
 module Ocak
   class MergeManager
     include CommandRunner
+    include ConflictResolution
+    include MergeVerification
 
     def initialize(config:, claude:, logger:, issues:, watch: nil)
       @config = config
@@ -40,7 +44,7 @@ module Ocak
 
       result = @claude.run_agent(
         'merger',
-        "Create a PR, merge it, and close issue ##{issue_number}. Branch: #{worktree.branch}",
+        merger_prompt(issue_number, worktree),
         chdir: worktree.path
       )
 
@@ -68,6 +72,18 @@ module Ocak
 
     private
 
+    def merger_prompt(issue_number, worktree)
+      base = if worktree.target_repo
+               "Create a PR and merge it for issue ##{issue_number}. Branch: #{worktree.branch}. " \
+                 'Do NOT close any issues (the issue lives in a different repository).'
+             else
+               "Create a PR, merge it, and close issue ##{issue_number}. Branch: #{worktree.branch}"
+             end
+      issue_data = @issues.view(issue_number)
+      base += "\n\n<issue_data>\nTitle: #{issue_data['title']}\n\n#{issue_data['body']}\n</issue_data>" if issue_data
+      base
+    end
+
     def log_and_nil(message)
       @logger.error(message)
       nil
@@ -76,7 +92,14 @@ module Ocak
     def open_pull_request(issue_number, worktree)
       issue_title = fetch_issue_title(issue_number)
       pr_title = "Fix ##{issue_number}: #{issue_title}"
-      pr_body = "Closes ##{issue_number}\n\n" \
+      issue_ref = if worktree.target_repo
+                    god_nwo = @issues.repo_nwo
+                    ref = god_nwo ? "#{god_nwo}##{issue_number}" : "##{issue_number}"
+                    "Related to #{ref}"
+                  else
+                    "Closes ##{issue_number}"
+                  end
+      pr_body = "#{issue_ref}\n\n" \
                 '_This PR was created in manual review mode. ' \
                 'Review and label `auto-reready` to trigger automated fixes based on your feedback._'
 
@@ -114,98 +137,6 @@ module Ocak
       )
     end
 
-    def rebase_onto_main(worktree)
-      fetch_result = run_git('fetch', 'origin', 'main', chdir: worktree.path)
-      unless fetch_result.success?
-        @logger.error("git fetch origin main failed: #{fetch_result.error}")
-        return false
-      end
-
-      rebase_result = run_git('rebase', 'origin/main', chdir: worktree.path)
-
-      return true if rebase_result.success?
-
-      @logger.warn("Rebase conflict, aborting rebase: #{rebase_result.error}")
-      abort_result = run_git('rebase', '--abort', chdir: worktree.path)
-      @logger.warn("git rebase --abort failed: #{abort_result.error}") unless abort_result.success?
-
-      # Fall back to merge strategy
-      @logger.info('Attempting merge strategy instead...')
-      merge_result = run_git('merge', 'origin/main', '--no-edit', chdir: worktree.path)
-
-      return true if merge_result.success?
-
-      # Merge also has conflicts — try to resolve via agent
-      @logger.warn("Merge conflict, attempting agent resolution: #{merge_result.error}")
-      resolve_conflicts_via_agent(worktree)
-    end
-
-    def resolve_conflicts_via_agent(worktree)
-      # Get list of conflicting files
-      diff_result = run_git('diff', '--name-only', '--diff-filter=U', chdir: worktree.path)
-      conflicting = diff_result.stdout.lines.map(&:strip).reject(&:empty?)
-
-      if conflicting.empty?
-        @logger.warn('No conflicting files found, aborting merge')
-        run_git('merge', '--abort', chdir: worktree.path)
-        return false
-      end
-
-      result = @claude.run_agent(
-        'implementer',
-        "Resolve these merge conflicts.\n\n<conflicting_files>\n#{conflicting.join("\n")}\n</conflicting_files>\n\n" \
-        'Open each file, find conflict markers (<<<<<<< ======= >>>>>>>), and resolve them. ' \
-        'Then run `git add` on each resolved file.',
-        chdir: worktree.path
-      )
-
-      if result.success?
-        # Check if all conflicts resolved
-        remaining_result = run_git('diff', '--name-only', '--diff-filter=U', chdir: worktree.path)
-        if remaining_result.output.empty?
-          commit_result = run_git('commit', '--no-edit', chdir: worktree.path)
-          unless commit_result.success?
-            @logger.error("Commit after conflict resolution failed: #{commit_result.error}")
-            return false
-          end
-          @logger.info('Merge conflicts resolved by agent')
-          return true
-        end
-      end
-
-      @logger.error('Agent could not resolve merge conflicts')
-      run_git('merge', '--abort', chdir: worktree.path)
-      false
-    end
-
-    def verify_tests(worktree)
-      test_cmd = @config.test_command
-      return true unless test_cmd
-
-      @logger.info('Running tests after rebase...')
-      stdout, stderr, status = shell(test_cmd, chdir: worktree.path)
-
-      if status.success?
-        @logger.info('Tests passed after rebase')
-        true
-      else
-        @logger.warn('Tests failed after rebase')
-        @logger.debug("Test output:\n#{stdout[0..2000]}\n#{stderr[0..500]}")
-        false
-      end
-    end
-
-    def push_branch(worktree)
-      result = run_git('push', '-u', 'origin', worktree.branch, chdir: worktree.path)
-
-      unless result.success?
-        @logger.error("Push failed: #{result.error}")
-        return false
-      end
-
-      true
-    end
-
     def shell(cmd, chdir:)
       Open3.capture3(*Shellwords.shellsplit(cmd), chdir: chdir)
     end

data/lib/ocak/merge_orchestration.rb

@@ -14,52 +14,60 @@ module Ocak
       elsif @config.manual_review
         handle_batch_manual_review(result, merger: merger, issues: issues, logger: logger)
       elsif merger.merge(result[:issue_number], result[:worktree])
-        issues.transition(result[:issue_number], from: @config.label_in_progress, to: @config.label_completed)
+        @state_machine.mark_completed(result[:issue_number])
         logger.info("Issue ##{result[:issue_number]} merged successfully")
       else
-        issues.transition(result[:issue_number], from: @config.label_in_progress, to: @config.label_failed)
+        @state_machine.mark_failed(result[:issue_number])
         logger.error("Issue ##{result[:issue_number]} merge failed")
       end
     end
 
     def handle_single_success(issue_number, result, logger:, claude:, issues:)
+      target_dir = result[:target_repo]&.dig(:path) || @config.project_dir
+
       if result[:audit_blocked]
-        handle_single_audit_blocked(issue_number, result, logger: logger, claude: claude, issues: issues)
+        handle_single_audit_blocked(issue_number, result, logger: logger, claude: claude, issues: issues,
+                                                          chdir: target_dir)
       elsif @config.manual_review
-        handle_single_manual_review(issue_number, logger: logger, claude: claude, issues: issues)
+        handle_single_manual_review(issue_number, logger: logger, claude: claude, issues: issues, chdir: target_dir)
       else
         unless pipeline_has_merge_step?
-          claude.run_agent('merger', "Create a PR, merge it, and close issue ##{issue_number}",
-                           chdir: @config.project_dir)
+          prompt = if result[:target_repo]
+                     "Create a PR and merge it for issue ##{issue_number}. " \
+                       'Do NOT close any issues (the issue lives in a different repository).'
+                   else
+                     "Create a PR, merge it, and close issue ##{issue_number}"
+                   end
+          prompt += merger_issue_context(issue_number, issues)
+          claude.run_agent('merger', prompt, chdir: target_dir)
         end
-        issues.transition(issue_number, from: @config.label_in_progress, to: @config.label_completed)
+        @state_machine.mark_completed(issue_number)
         logger.info("Issue ##{issue_number} completed successfully")
       end
     end
 
-    def handle_single_manual_review(issue_number, logger:, claude:, issues:)
-      claude.run_agent('merger',
-                       "Create a PR for issue ##{issue_number} but do NOT merge it and do NOT close the issue",
-                       chdir: @config.project_dir)
-      issues.transition(issue_number, from: @config.label_in_progress, to: @config.label_awaiting_review)
+    def handle_single_manual_review(issue_number, logger:, claude:, issues: nil, chdir: @config.project_dir)
+      prompt = "Create a PR for issue ##{issue_number} but do NOT merge it and do NOT close the issue"
+      prompt += merger_issue_context(issue_number, issues)
+      claude.run_agent('merger', prompt, chdir: chdir)
+      @state_machine.mark_for_review(issue_number)
       logger.info("Issue ##{issue_number} PR created (manual review mode)")
     end
 
-    def handle_batch_manual_review(result, merger:, issues:, logger:)
+    def handle_batch_manual_review(result, merger:, logger:, issues: nil) # rubocop:disable Lint/UnusedMethodArgument
       pr_number = merger.create_pr_only(result[:issue_number], result[:worktree])
       if pr_number
-        issues.transition(result[:issue_number], from: @config.label_in_progress,
-                                                 to: @config.label_awaiting_review)
+        @state_machine.mark_for_review(result[:issue_number])
         logger.info("Issue ##{result[:issue_number]} PR ##{pr_number} created (manual review mode)")
       else
-        issues.transition(result[:issue_number], from: @config.label_in_progress, to: @config.label_failed)
+        @state_machine.mark_failed(result[:issue_number])
         logger.error("Issue ##{result[:issue_number]} PR creation failed")
       end
     end
 
-    def handle_single_audit_blocked(issue_number, result, logger:, claude:, issues:)
-      handle_single_manual_review(issue_number, logger: logger, claude: claude, issues: issues)
-      post_audit_comment_single(result[:audit_output], logger: logger, issues: issues)
+    def handle_single_audit_blocked(issue_number, result, logger:, claude:, issues:, chdir: @config.project_dir)
+      handle_single_manual_review(issue_number, logger: logger, claude: claude, issues: issues, chdir: chdir)
+      post_audit_comment_single(result[:audit_output], logger: logger, issues: issues, chdir: chdir)
     end
 
     def handle_batch_audit(result, merger:, issues:, logger:)
@@ -70,17 +78,16 @@ module Ocak
       pr_number = merger.create_pr_only(result[:issue_number], result[:worktree])
       if pr_number
         issues.pr_comment(pr_number, "## Audit Report\n\n#{audit_output}")
-        issues.transition(result[:issue_number], from: @config.label_in_progress,
-                                                 to: @config.label_awaiting_review)
+        @state_machine.mark_for_review(result[:issue_number])
         logger.info("Issue ##{result[:issue_number]} PR ##{pr_number} created (audit findings)")
       else
-        issues.transition(result[:issue_number], from: @config.label_in_progress, to: @config.label_failed)
+        @state_machine.mark_failed(result[:issue_number])
         logger.error("Issue ##{result[:issue_number]} PR creation failed")
       end
     end
 
-    def post_audit_comment_single(audit_output, logger:, issues:)
-      pr_number = find_pr_for_branch(logger: logger)
+    def post_audit_comment_single(audit_output, logger:, issues:, chdir: @config.project_dir)
+      pr_number = find_pr_for_branch(logger: logger, chdir: chdir)
       unless pr_number
         logger.warn("Could not find PR to post audit comment — findings were: #{audit_output.to_s[0..200]}")
         return
@@ -90,12 +97,19 @@ module Ocak
       logger.info("Posted audit comment on PR ##{pr_number}")
     end
 
+    def merger_issue_context(issue_number, issues)
+      issue_data = issues&.view(issue_number)
+      return '' unless issue_data
+
+      "\n\n<issue_data>\nTitle: #{issue_data['title']}\n\n#{issue_data['body']}\n</issue_data>"
+    end
+
     def pipeline_has_merge_step?
       @config.steps.any? { |s| s[:role].to_s == 'merge' || s['role'].to_s == 'merge' }
     end
 
-    def find_pr_for_branch(logger:)
-      stdout, _, status = Open3.capture3('gh', 'pr', 'view', '--json', 'number', chdir: @config.project_dir)
+    def find_pr_for_branch(logger:, chdir: @config.project_dir)
+      stdout, _, status = Open3.capture3('gh', 'pr', 'view', '--json', 'number', chdir: chdir)
       return nil unless status.success?
 
       data = JSON.parse(stdout)

data/lib/ocak/merge_verification.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'shellwords'
+
+module Ocak
+  # Test verification and git push logic — verify_tests, push_branch.
+  # Extracted from MergeManager to reduce file size.
+  module MergeVerification
+    private
+
+    def verify_tests(worktree)
+      test_cmd = @config.test_command
+      return true unless test_cmd
+
+      @logger.info('Running tests after rebase...')
+      stdout, stderr, status = shell(test_cmd, chdir: worktree.path)
+
+      if status.success?
+        @logger.info('Tests passed after rebase')
+        true
+      else
+        @logger.warn('Tests failed after rebase')
+        @logger.debug("Test output:\n#{stdout[0..2000]}\n#{stderr[0..500]}")
+        false
+      end
+    end
+
+    def push_branch(worktree)
+      result = run_git('push', '-u', 'origin', worktree.branch, chdir: worktree.path)
+
+      unless result.success?
+        @logger.error("Push failed: #{result.error}")
+        return false
+      end
+
+      true
+    end
+  end
+end

data/lib/ocak/pipeline_executor.rb

@@ -2,6 +2,7 @@
 
 require 'open3'
 require 'fileutils'
+require_relative 'command_runner'
 require_relative 'pipeline_state'
 require_relative 'run_report'
 require_relative 'verification'
@@ -13,6 +14,7 @@ require_relative 'parallel_execution'
 
 module Ocak
   class PipelineExecutor
+    include CommandRunner
     include Verification
     include Planner
     include StepComments
@@ -42,6 +44,7 @@ module Ocak
 
       report = RunReport.new(complexity: complexity)
       state = build_initial_state(complexity, report)
+      state[:issue_data] = @issues&.view(issue_number)
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       post_pipeline_start_comment(issue_number, state) if post_start_comment
 
@@ -145,8 +148,12 @@ module Ocak
     end
 
     def current_branch(chdir, logger: nil)
-      stdout, = Open3.capture3('git', 'rev-parse', '--abbrev-ref', 'HEAD', chdir: chdir)
-      stdout.strip
+      result = run_git('rev-parse', '--abbrev-ref', 'HEAD', chdir: chdir)
+      if result.status.nil?
+        logger&.debug("Could not determine current branch: #{result.error}")
+        return nil
+      end
+      result.output
     rescue StandardError => e
       logger&.debug("Could not determine current branch: #{e.message}")
       nil

data/lib/ocak/pipeline_runner.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require 'fileutils'
 require_relative 'batch_processing'
 require_relative 'failure_reporting'
 require_relative 'instance_builders'
+require_relative 'issue_state_machine'
 require_relative 'merge_orchestration'
 require_relative 'pipeline_executor'
 require_relative 'process_registry'
@@ -36,6 +38,7 @@ module Ocak
     end
 
     def run
+      warn_if_untrusted
       @options[:single] ? run_single(@options[:single]) : run_loop
     end
 
@@ -52,12 +55,25 @@ module Ocak
 
     private
 
+    def warn_if_untrusted
+      return unless @config.custom_commands?
+
+      trusted_path = File.join(@config.project_dir, '.ocak', 'trusted')
+      return if File.exist?(trusted_path)
+
+      warn 'Warning: ocak.yml contains commands that will be executed with your user privileges. ' \
+           'Review the config before proceeding.'
+      FileUtils.mkdir_p(File.dirname(trusted_path))
+      FileUtils.touch(trusted_path)
+    end
+
     def run_single(issue_number)
       logger = build_logger(issue_number: issue_number)
       claude = build_claude(logger)
       issues = IssueBackend.build(config: @config)
       ensure_labels(issues, logger)
       @executor.issues = issues
+      @state_machine = build_state_machine(issues)
       logger.info("Running single issue mode for ##{issue_number}")
 
       if @options[:dry_run]
@@ -65,7 +81,7 @@ module Ocak
         return
       end
 
-      issues.transition(issue_number, from: @config.label_ready, to: @config.label_in_progress)
+      @state_machine.mark_in_progress(issue_number)
       complexity = @options[:fast] ? 'simple' : 'full'
       result = run_pipeline(issue_number, logger: logger, claude: claude, complexity: complexity)
 
@@ -84,6 +100,7 @@ module Ocak
       issues = IssueBackend.build(config: @config, logger: logger)
       ensure_labels(issues, logger)
       @executor.issues = issues
+      @state_machine = build_state_machine(issues)
       cleanup_stale_worktrees(logger)
 
       loop do

data/lib/ocak/planner.rb

@@ -14,18 +14,32 @@ module Ocak
       'merge' => 'Create a PR, merge it, and close issue #%<issue>s'
     }.freeze
 
-    def build_step_prompt(role, issue_number, review_output)
-      if role == 'fix'
-        "Fix these review findings for issue ##{issue_number}:\n\n<review_output>\n#{review_output}\n</review_output>"
-      elsif STEP_PROMPTS.key?(role)
-        format(STEP_PROMPTS[role], issue: issue_number)
-      else
-        "Run #{role} for GitHub issue ##{issue_number}"
-      end
+    ISSUE_CONTEXT_ROLES = %w[implement document merge].freeze
+
+    def build_step_prompt(role, issue_number, review_output, issue_data: nil)
+      prompt = if role == 'fix'
+                 "Fix these review findings for issue ##{issue_number}:\n\n" \
+                   "<review_output>\n#{review_output}\n</review_output>"
+               elsif STEP_PROMPTS.key?(role)
+                 format(STEP_PROMPTS[role], issue: issue_number)
+               else
+                 "Run #{role} for GitHub issue ##{issue_number}"
+               end
+
+      prompt += format_issue_context(issue_data) if issue_data && ISSUE_CONTEXT_ROLES.include?(role)
+      prompt
+    end
+
+    def format_issue_context(issue_data)
+      parts = []
+      parts << "Title: #{issue_data['title']}" if issue_data['title']
+      parts << issue_data['body'] if issue_data['body']
+      "\n\n<issue_data>\n#{parts.join("\n\n")}\n</issue_data>"
     end
 
     def plan_batches(issues, logger:, claude:)
       return sequential_batches(issues) if issues.size <= 1
+      return plan_multi_repo_batches(issues) if @config&.multi_repo?
 
       issue_json = JSON.generate(issues.map { |i| { number: i['number'], title: i['title'] } })
       result = claude.run_agent(
@@ -41,6 +55,20 @@ module Ocak
       parse_planner_output(result.output, issues, logger)
     end
 
+    def plan_multi_repo_batches(issues)
+      by_repo = issues.group_by { |i| i['_target']&.dig(:name) || '__self__' }
+
+      # If all issues target different repos, one big parallel batch — no agent call needed
+      return [{ 'batch' => 1, 'issues' => issues }] if by_repo.values.all? { |group| group.size == 1 }
+
+      # Otherwise, issues in the same repo are sequential (by depth), cross-repo are parallel
+      max_depth = by_repo.values.map(&:size).max
+      (0...max_depth).map do |depth|
+        batch_issues = by_repo.values.filter_map { |group| group[depth] }
+        { 'batch' => depth + 1, 'issues' => batch_issues }
+      end
+    end
+
     def parse_planner_output(output, issues, logger)
       json_match = output.match(/\{[\s\S]*"batches"[\s\S]*\}/)
       if json_match

data/lib/ocak/shutdown_handling.rb

@@ -40,7 +40,7 @@ module Ocak
     def handle_process_error(error, issue_number:, logger:, issues:)
       logger.error("Unexpected #{error.class}: #{error.message}\n#{error.backtrace&.first(5)&.join("\n")}")
       logger.debug("Full backtrace:\n#{error.backtrace&.join("\n")}")
-      issues.transition(issue_number, from: @config.label_in_progress, to: @config.label_failed)
+      @state_machine.mark_failed(issue_number)
       begin
         issues.comment(issue_number, "Unexpected #{error.class}: #{error.message}")
       rescue StandardError => e
@@ -55,7 +55,7 @@ module Ocak
                                 message: "wip: pipeline interrupted after step #{step_name} for issue ##{issue_number}",
                                 logger: logger)
       end
-      issues&.transition(issue_number, from: @config.label_in_progress, to: @config.label_ready)
+      @state_machine&.mark_interrupted(issue_number)
       issues&.comment(issue_number,
                       "\u{26A0}\u{FE0F} Pipeline interrupted after #{step_name}. " \
                       "Resume with `ocak resume --issue #{issue_number}`.")