ocak 0.5.0 → 0.6.0

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,6 +17,10 @@ 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?
         LocalMergeManager.new(config: @config, logger: logger, issues: issues)

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,15 @@ module Ocak
 
     private
 
+    def merger_prompt(issue_number, worktree)
+      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
+    end
+
     def log_and_nil(message)
       @logger.error(message)
       nil
@@ -76,7 +89,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 +134,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,59 @@ 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
+          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:)
+    def handle_single_manual_review(issue_number, logger:, claude:, issues: nil, chdir: @config.project_dir) # rubocop:disable Lint/UnusedMethodArgument
       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)
+                       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 +77,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
@@ -94,8 +100,8 @@ module Ocak
       @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
@@ -145,8 +147,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

@@ -26,6 +26,7 @@ module Ocak
 
     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 +42,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}`.")

data/lib/ocak/stream_parser.rb

@@ -191,7 +191,7 @@ module Ocak
     end
 
     def detect_test_pass(output)
-      return true  if output.match?(/0 failures,\s*0 errors/)
+      return true  if output.match?(/\b0 failures\b/)
       return true  if output.match?(/no offenses detected/i)
       return true  if output.match?(/test result: ok/i) # cargo test
       return false if output.match?(/[1-9]\d* failures?/) || output.match?(/[1-9]\d* errors?/)

data/lib/ocak/target_resolver.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Ocak
+  module TargetResolver
+    # Resolves the target repo for an issue.
+    # Returns { name:, path: } hash or nil (single-repo mode).
+    # Raises TargetResolutionError on missing/invalid target in multi-repo mode.
+    def self.resolve(issue, config:)
+      return nil unless config.multi_repo?
+
+      body = issue['body'].to_s
+      repo_name = extract_target_name(body, field: config.target_field)
+
+      unless repo_name
+        raise TargetResolutionError,
+              "Issue ##{issue['number']} is missing required '#{config.target_field}' field in body. " \
+              "Known repos: #{config.repos.keys.join(', ')}"
+      end
+
+      config.resolve_repo(repo_name)
+    end
+
+    # Extract target name from YAML front-matter.
+    # Returns the target name string, or nil if not found.
+    def self.extract_target_name(body, field:)
+      match = body.match(/\A---\s*\n(.*?)\n---/m)
+      return nil unless match
+
+      frontmatter = YAML.safe_load(match[1])
+      return nil unless frontmatter.is_a?(Hash)
+
+      frontmatter[field]&.to_s&.strip
+    rescue Psych::SyntaxError
+      nil
+    end
+
+    class TargetResolutionError < StandardError; end
+  end
+end

data/lib/ocak/templates/agents/implementer.md.erb

@@ -98,6 +98,9 @@ You implement GitHub issues. The issue is your single source of truth — everyt
 <%- end -%>
 <%- end -%>
 
+### Working Directory Context
+If a CLAUDE.md file exists in the current working directory, read it for project-specific conventions, patterns, and architecture. This is especially important when working in a repository you haven't seen before.
+
 ### General Rules
 
 - Do NOT add features, refactoring, or improvements beyond what the issue specifies