ocak 0.3.0 → 0.4.0

data/lib/ocak/logger.rb

@@ -166,8 +166,11 @@ module Ocak
     def format_tool_result(prefix, event)
       return nil unless event[:is_test_result]
 
-      color = event[:passed] ? :green : :red
-      status = event[:passed] ? 'PASS' : 'FAIL'
+      color, status = case event[:passed]
+                      when true  then [:green, 'PASS']
+                      when false then [:red, 'FAIL']
+                      else [:yellow, 'UNKNOWN']
+                      end
       "#{prefix} #{c(color)}#{c(:bold)}[TEST #{status}]#{c(:reset)} #{c(:dim)}#{event[:command]}#{c(:reset)}"
     end
 

data/lib/ocak/merge_manager.rb

@@ -123,7 +123,8 @@ module Ocak
       return true if status.success?
 
       @logger.warn("Rebase conflict, aborting rebase: #{stderr}")
-      git('rebase', '--abort', chdir: worktree.path)
+      _, abort_stderr, abort_status = git('rebase', '--abort', chdir: worktree.path)
+      @logger.warn("git rebase --abort failed: #{abort_stderr}") unless abort_status.success?
 
       # Fall back to merge strategy
       @logger.info('Attempting merge strategy instead...')
@@ -149,7 +150,7 @@ module Ocak
 
       result = @claude.run_agent(
         'implementer',
-        "Resolve these merge conflicts. Conflicting files:\n#{conflicting.join("\n")}\n\n" \
+        "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
@@ -159,7 +160,11 @@ module Ocak
         # Check if all conflicts resolved
         remaining, = git('diff', '--name-only', '--diff-filter=U', chdir: worktree.path)
         if remaining.strip.empty?
-          git('commit', '--no-edit', chdir: worktree.path)
+          _, commit_stderr, commit_status = git('commit', '--no-edit', chdir: worktree.path)
+          unless commit_status.success?
+            @logger.error("Commit after conflict resolution failed: #{commit_stderr}")
+            return false
+          end
           @logger.info('Merge conflicts resolved by agent')
           return true
         end
@@ -175,13 +180,14 @@ module Ocak
       return true unless test_cmd
 
       @logger.info('Running tests after rebase...')
-      _, _, status = shell(test_cmd, chdir: worktree.path)
+      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

data/lib/ocak/pipeline_executor.rb

@@ -24,14 +24,20 @@ module Ocak
       @shutdown_check = shutdown_check
     end
 
-    def run_pipeline(issue_number, logger:, claude:, chdir: nil, skip_steps: [], complexity: 'full')
+    def run_pipeline(issue_number, logger:, claude:, chdir: nil, skip_steps: [], complexity: 'full', # rubocop:disable Metrics/ParameterLists
+                     steps: nil, verification_model: nil,
+                     post_start_comment: true, post_summary_comment: true)
+      @logger = logger
+      @custom_steps = steps
+      @verification_model = verification_model
+      @post_summary_comment = post_summary_comment
       chdir ||= @config.project_dir
       logger.info("=== Starting pipeline for issue ##{issue_number} (#{complexity}) ===")
 
       report = RunReport.new(complexity: complexity)
       state = build_initial_state(complexity, report)
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      post_pipeline_start_comment(issue_number, state)
+      post_pipeline_start_comment(issue_number, state) if post_start_comment
 
       failure = run_pipeline_steps(issue_number, state, logger: logger, claude: claude, chdir: chdir,
                                                         skip_steps: skip_steps)
@@ -52,7 +58,7 @@ module Ocak
     def build_initial_state(complexity, report)
       { last_review_output: nil, had_fixes: false, completed_steps: [], total_cost: 0.0,
         complexity: complexity, steps_run: 0, steps_skipped: 0,
-        audit_output: nil, audit_blocked: false, report: report }
+        audit_output: nil, audit_blocked: false, report: report, step_results: {} }
     end
 
     def handle_interrupted(issue_number, state, report, logger)
@@ -69,50 +75,98 @@ module Ocak
     def finish_success(issue_number, state, report, start_time, logger)
       duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time).round
       save_report(report, issue_number, success: true)
-      post_pipeline_summary_comment(issue_number, state, duration, success: true)
+      post_pipeline_summary_comment(issue_number, state, duration, success: true) if @post_summary_comment
       logger.info("=== Pipeline complete for issue ##{issue_number} ===")
       { success: true, output: 'Pipeline completed successfully',
-        audit_blocked: state[:audit_blocked], audit_output: state[:audit_output] }
+        audit_blocked: state[:audit_blocked], audit_output: state[:audit_output],
+        step_results: state[:step_results], total_cost: state[:total_cost], steps_run: state[:steps_run] }
     end
 
     def build_interrupted_result(state)
-      last_step = state[:completed_steps].any? ? @config.steps[state[:completed_steps].last] : nil
+      last_step = state[:completed_steps].any? ? active_steps[state[:completed_steps].last] : nil
       last_role = last_step ? symbolize(last_step)[:role].to_s : 'startup'
-      { success: false, phase: last_role, output: 'Pipeline interrupted', interrupted: true }
+      { success: false, phase: last_role, output: 'Pipeline interrupted', interrupted: true,
+        step_results: state[:step_results], total_cost: state[:total_cost], steps_run: state[:steps_run] }
     end
 
     def post_failure_and_return(issue_number, state, failure, start_time)
       duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time).round
-      post_pipeline_summary_comment(issue_number, state, duration, success: false,
-                                                                   failed_phase: failure[:phase])
-      failure
+      if @post_summary_comment
+        post_pipeline_summary_comment(issue_number, state, duration, success: false,
+                                                                     failed_phase: failure[:phase])
+      end
+      failure.merge(step_results: state[:step_results], total_cost: state[:total_cost],
+                    steps_run: state[:steps_run])
     end
 
     def run_pipeline_steps(issue_number, state, logger:, claude:, chdir:, skip_steps: [])
-      @config.steps.each_with_index do |step, idx|
+      @skip_steps = skip_steps
+      steps = active_steps
+      idx = 0
+      while idx < steps.size
         break if check_shutdown(state, logger)
 
-        step = symbolize(step)
-        role = step[:role].to_s
-        agent = step[:agent].to_s
+        step = symbolize(steps[idx])
+        if step[:parallel]
+          group = collect_parallel_group(steps, idx)
+          failure = run_parallel_group(group, issue_number, state, logger: logger, claude: claude, chdir: chdir)
+          idx += group.size
+        else
+          failure = run_single_step(step, idx, issue_number, state, logger: logger, claude: claude, chdir: chdir)
+          idx += 1
+        end
+        return failure if failure
+      end
+      nil
+    end
+
+    def collect_parallel_group(steps, start_idx)
+      group = []
+      idx = start_idx
+      while idx < steps.size
+        step = symbolize(steps[idx])
+        break unless step[:parallel]
 
-        next if handle_already_completed(idx, role, skip_steps, logger)
+        group << [step, idx]
+        idx += 1
+      end
+      group
+    end
 
-        reason = skip_reason(step, state)
-        if reason
-          logger.info("Skipping #{role} \u2014 #{reason}")
-          record_skipped_step(issue_number, state, idx, agent, role, reason)
-          next
+    def run_parallel_group(group, issue_number, state, logger:, claude:, chdir:)
+      mutex = Mutex.new
+      threads = group.map do |step, idx|
+        Thread.new do
+          run_single_step(step, idx, issue_number, state, logger: logger, claude: claude,
+                                                          chdir: chdir, mutex: mutex)
+        rescue StandardError => e
+          logger.error("#{step[:role]} thread failed: #{e.message}")
+          nil
         end
+      end
 
-        result = execute_step(step, issue_number, state[:last_review_output], logger: logger, claude: claude,
-                                                                              chdir: chdir)
-        state[:report].record_step(index: idx, agent: agent, role: role, status: 'completed', result: result)
-        ctx = StepContext.new(issue_number, idx, role, result, state, logger, chdir)
-        failure = record_step_result(ctx)
-        return failure if failure
+      results = threads.map(&:value)
+      results.compact.find { |r| r.is_a?(Hash) && !r[:success] }
+    end
+
+    def run_single_step(step, idx, issue_number, state, logger:, claude:, chdir:, mutex: nil) # rubocop:disable Metrics/ParameterLists
+      role = step[:role].to_s
+      agent = step[:agent].to_s
+
+      return nil if handle_already_completed(idx, role, @skip_steps, logger)
+
+      reason = skip_reason(step, state)
+      if reason
+        logger.info("Skipping #{role} \u2014 #{reason}")
+        record_skipped_step(issue_number, state, idx, agent, role, reason)
+        return nil
       end
-      nil
+
+      result = execute_step(step, issue_number, state[:last_review_output], logger: logger, claude: claude,
+                                                                            chdir: chdir)
+      state[:report].record_step(index: idx, agent: agent, role: role, status: 'completed', result: result)
+      ctx = StepContext.new(issue_number, idx, role, result, state, logger, chdir)
+      record_step_result(ctx, mutex: mutex)
     end
 
     def check_shutdown(state, logger)
@@ -141,14 +195,13 @@ module Ocak
       logger.info("--- Phase: #{role} (#{agent}) ---")
       post_step_comment(issue_number, "\u{1F504} **Phase: #{role}** (#{agent})")
       prompt = build_step_prompt(role, issue_number, review_output)
-      claude.run_agent(agent.tr('_', '-'), prompt, chdir: chdir)
+      opts = { chdir: chdir }
+      opts[:model] = step[:model].to_s if step[:model]
+      claude.run_agent(agent.tr('_', '-'), prompt, **opts)
     end
 
-    def record_step_result(ctx)
-      update_pipeline_state(ctx.role, ctx.result, ctx.state)
-      ctx.state[:completed_steps] << ctx.idx
-      ctx.state[:steps_run] += 1
-      ctx.state[:total_cost] += ctx.result.cost_usd.to_f
+    def record_step_result(ctx, mutex: nil)
+      sync(mutex) { accumulate_state(ctx) }
       save_step_progress(ctx)
       write_step_output(ctx.issue_number, ctx.idx, ctx.role, ctx.result.output)
       post_step_completion_comment(ctx.issue_number, ctx.role, ctx.result)
@@ -156,6 +209,22 @@ module Ocak
       check_step_failure(ctx) || check_cost_budget(ctx.state, ctx.logger)
     end
 
+    def accumulate_state(ctx)
+      update_pipeline_state(ctx.role, ctx.result, ctx.state)
+      ctx.state[:completed_steps] << ctx.idx
+      ctx.state[:steps_run] += 1
+      ctx.state[:total_cost] += ctx.result.cost_usd.to_f
+      ctx.state[:step_results][ctx.role] = ctx.result
+    end
+
+    def sync(mutex, &)
+      if mutex
+        mutex.synchronize(&)
+      else
+        yield
+      end
+    end
+
     def save_step_progress(ctx)
       pipeline_state.save(ctx.issue_number,
                           completed_steps: ctx.state[:completed_steps],
@@ -165,13 +234,15 @@ module Ocak
 
     def write_step_output(issue_number, idx, agent, output)
       return if output.to_s.empty?
+      return unless issue_number.to_s.match?(/\A\d+\z/)
 
       safe_agent = agent.to_s.gsub(/[^a-zA-Z0-9_-]/, '')
       dir = File.join(@config.project_dir, '.ocak', 'logs', "issue-#{issue_number}")
       FileUtils.mkdir_p(dir)
       File.write(File.join(dir, "step-#{idx}-#{safe_agent}.md"), output)
-    rescue StandardError
-      nil # sidecar write failures must never crash the pipeline
+    rescue StandardError => e
+      @logger&.debug("Step output write failed: #{e.message}")
+      nil
     end
 
     def check_step_failure(ctx)
@@ -221,29 +292,9 @@ module Ocak
     end
 
     def run_final_verification(issue_number, logger:, claude:, chdir:)
-      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)")
-      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      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...")
-        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)
-        result = run_final_checks(logger, chdir: chdir)
-      end
-
-      duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time).round
-      if result[:success]
-        post_step_comment(issue_number, "\u{2705} **Phase: final-verify** completed \u{2014} #{duration}s")
-        nil
-      else
-        post_step_comment(issue_number, "\u{274C} **Phase: final-verify** failed \u{2014} #{duration}s")
-        { success: false, phase: 'final-verify', output: result[:output] }
+      run_verification_with_retry(logger: logger, claude: claude, chdir: chdir,
+                                  model: @verification_model) do |body|
+        post_step_comment(issue_number, body)
       end
     end
 
@@ -258,8 +309,9 @@ module Ocak
     def save_report(report, issue_number, success:, failed_phase: nil)
       report.finish(success: success, failed_phase: failed_phase)
       report.save(issue_number, project_dir: @config.project_dir)
-    rescue StandardError
-      nil # report save failures must never crash the pipeline
+    rescue StandardError => e
+      @logger&.debug("Report save failed: #{e.message}")
+      nil
     end
 
     def pipeline_state
@@ -274,8 +326,12 @@ module Ocak
       nil
     end
 
+    def active_steps
+      @custom_steps || @config.steps
+    end
+
     def post_pipeline_start_comment(issue_number, state)
-      total = @config.steps.size
+      total = active_steps.size
       conditional = conditional_step_count(state)
       post_step_comment(issue_number,
                         "\u{1F680} **Pipeline started** \u2014 complexity: `#{state[:complexity]}` " \
@@ -283,7 +339,7 @@ module Ocak
     end
 
     def post_pipeline_summary_comment(issue_number, state, duration, success:, failed_phase: nil)
-      total = @config.steps.size
+      total = active_steps.size
       cost = format('%.2f', state[:total_cost])
 
       if success
@@ -298,7 +354,7 @@ module Ocak
     end
 
     def conditional_step_count(state)
-      @config.steps.count do |step|
+      active_steps.count do |step|
         step = symbolize(step)
         step[:condition] ||
           (step[:complexity] == 'full' && state[:complexity] == 'simple') ||

data/lib/ocak/pipeline_runner.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative 'failure_reporting'
 require_relative 'merge_orchestration'
 require_relative 'pipeline_executor'
 require_relative 'process_registry'
@@ -8,6 +9,7 @@ require_relative 'reready_processor'
 
 module Ocak
   class PipelineRunner
+    include FailureReporting
     include MergeOrchestration
 
     attr_reader :registry
@@ -82,9 +84,7 @@ module Ocak
       elsif result[:success]
         handle_single_success(issue_number, result, logger: logger, claude: claude, issues: issues)
       else
-        issues.transition(issue_number, from: @config.label_in_progress, to: @config.label_failed)
-        issues.comment(issue_number,
-                       "Pipeline failed at phase: #{result[:phase]}\n\n```\n#{result[:output][0..1000]}\n```")
+        report_pipeline_failure(issue_number, result, issues: issues, config: @config)
         logger.error("Issue ##{issue_number} failed at phase: #{result[:phase]}")
       end
     end
@@ -114,7 +114,11 @@ module Ocak
         break if @options[:once]
 
         logger.info("Sleeping #{@config.poll_interval}s...")
-        sleep @config.poll_interval
+        @config.poll_interval.times do
+          break if @shutting_down
+
+          sleep 1
+        end
       end
     end
 
@@ -141,7 +145,7 @@ module Ocak
     end
 
     def run_batch(batch_issues, logger:, issues:)
-      worktrees = WorktreeManager.new(config: @config)
+      worktrees = WorktreeManager.new(config: @config, logger: logger)
 
       threads = batch_issues.map do |issue|
         Thread.new { process_one_issue(issue, worktrees: worktrees, issues: issues) }
@@ -165,6 +169,9 @@ module Ocak
       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:)
@@ -187,9 +194,11 @@ module Ocak
       build_issue_result(result, issue_number: issue_number, worktree: worktree, issues: issues,
                                  logger: logger)
     rescue StandardError => e
-      logger.error("Unexpected error: #{e.message}\n#{e.backtrace.first(5).join("\n")}")
-      issues.transition(issue_number, from: @config.label_in_progress, to: @config.label_failed)
-      { issue_number: issue_number, success: false, worktree: worktree, error: e.message }
+      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
@@ -203,9 +212,7 @@ module Ocak
         { issue_number: issue_number, success: true, worktree: worktree,
           audit_blocked: result[:audit_blocked], audit_output: result[:audit_output] }
       else
-        issues.transition(issue_number, from: @config.label_in_progress, to: @config.label_failed)
-        issues.comment(issue_number,
-                       "Pipeline failed at phase: #{result[:phase]}\n\n```\n#{result[:output][0..1000]}\n```")
+        report_pipeline_failure(issue_number, result, issues: issues, config: @config)
         { issue_number: issue_number, success: false, worktree: worktree }
       end
     end
@@ -226,7 +233,7 @@ module Ocak
     end
 
     def cleanup_stale_worktrees(logger)
-      worktrees = WorktreeManager.new(config: @config)
+      worktrees = WorktreeManager.new(config: @config, logger: logger)
       removed = worktrees.clean_stale
       removed.each { |path| logger.info("Cleaned stale worktree: #{path}") }
     rescue StandardError => e
@@ -259,6 +266,17 @@ module Ocak
       @registry.kill_all
     end
 
+    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)
+      begin
+        issues.comment(issue_number, "Unexpected #{error.class}: #{error.message}")
+      rescue StandardError
+        nil
+      end
+    end
+
     def handle_interrupted_issue(issue_number, worktree_path, step_name, logger:, issues:)
       if worktree_path
         GitUtils.commit_changes(chdir: worktree_path,

data/lib/ocak/pipeline_state.rb

@@ -5,8 +5,9 @@ require 'fileutils'
 
 module Ocak
   class PipelineState
-    def initialize(log_dir:)
+    def initialize(log_dir:, logger: nil)
       @log_dir = log_dir
+      @logger = logger
     end
 
     def save(issue_number, completed_steps:, worktree_path: nil, branch: nil)
@@ -18,6 +19,10 @@ module Ocak
                                                                   branch: branch,
                                                                   updated_at: Time.now.iso8601
                                                                 }))
+    rescue StandardError => e
+      @logger&.warn("Pipeline state save failed for issue ##{issue_number}: #{e.message}") ||
+        warn("Pipeline state save failed for issue ##{issue_number}: #{e.message}")
+      nil
     end
 
     def load(issue_number)
@@ -25,7 +30,7 @@ module Ocak
       return nil unless File.exist?(path)
 
       JSON.parse(File.read(path), symbolize_names: true)
-    rescue JSON::ParserError => e
+    rescue ArgumentError, JSON::ParserError => e
       warn("Failed to parse pipeline state for issue ##{issue_number}: #{e.message}")
       nil
     end
@@ -33,6 +38,8 @@ module Ocak
     def delete(issue_number)
       path = state_path(issue_number)
       FileUtils.rm_f(path)
+    rescue ArgumentError
+      nil
     end
 
     def list
@@ -47,6 +54,8 @@ module Ocak
     private
 
     def state_path(issue_number)
+      raise ArgumentError, "Invalid issue number: #{issue_number}" unless issue_number.to_s.match?(/\A\d+\z/)
+
       File.join(@log_dir, "issue-#{issue_number}-state.json")
     end
   end

data/lib/ocak/planner.rb

@@ -11,8 +11,7 @@ module Ocak
       'verify' => 'Review the changes for GitHub issue #%<issue>s. Run: git diff main',
       'security' => 'Security review changes for GitHub issue #%<issue>s. Run: git diff main',
       'document' => 'Add documentation for changes in GitHub issue #%<issue>s',
-      'merge' => 'Create a PR, merge it, and close issue #%<issue>s',
-      'create_pr' => 'Create a PR, merge it, and close issue #%<issue>s'
+      'merge' => 'Create a PR, merge it, and close issue #%<issue>s'
     }.freeze
 
     def build_step_prompt(role, issue_number, review_output)

data/lib/ocak/process_runner.rb

@@ -5,6 +5,8 @@ require 'open3'
 module Ocak
   # Runs a subprocess with streaming line output and timeout support.
   module ProcessRunner
+    KILL_GRACE_PERIOD = 2
+
     FailedStatus = Struct.new(:success?) do
       def self.instance = new(false)
     end
@@ -54,9 +56,9 @@ module Ocak
 
     def kill_process(pid)
       Process.kill('TERM', pid)
-      sleep 2
+      sleep KILL_GRACE_PERIOD
       Process.kill('KILL', pid)
-    rescue Errno::ESRCH => e
+    rescue Errno::ESRCH, Errno::EPERM => e
       warn("Process already exited during kill: #{e.message}")
       nil
     end

data/lib/ocak/reready_processor.rb

@@ -101,6 +101,9 @@ module Ocak
 
       _, _, status = Open3.capture3(*Shellwords.shellsplit(cmd), chdir: @config.project_dir)
       status.success?
+    rescue ArgumentError => e
+      @logger&.warn("Invalid shell command in config: #{cmd.inspect} (#{e.message})")
+      false
     end
 
     def handle_result(pr_number, success)
@@ -133,8 +136,7 @@ module Ocak
     end
 
     def cleanup
-      _, stderr, status = Open3.capture3('git', 'checkout', 'main', chdir: @config.project_dir)
-      @logger.warn("Cleanup checkout to main failed: #{stderr}") unless status.success?
+      GitUtils.checkout_main(chdir: @config.project_dir, logger: @logger)
     end
 
     def build_feedback_prompt(feedback)

data/lib/ocak/run_report.rb

@@ -41,6 +41,8 @@ module Ocak
     end
 
     def save(issue_number, project_dir:)
+      return nil unless issue_number.to_s.match?(/\A\d+\z/)
+
       dir = File.join(project_dir, REPORTS_DIR)
       FileUtils.mkdir_p(dir)
 

data/lib/ocak/step_comments.rb

@@ -2,21 +2,26 @@
 
 module Ocak
   # Shared comment-posting helpers for pipeline steps.
-  # Includers must provide an @issues instance variable (IssueFetcher or nil).
+  # Includers typically provide an @issues instance variable (IssueFetcher or nil).
+  # All methods accept an optional `issues:` keyword to override @issues, allowing
+  # callers like Hiz to pass issues from a different source (e.g., state.issues).
   module StepComments
-    def post_step_comment(issue_number, body)
-      @issues&.comment(issue_number, body)
-    rescue StandardError
+    def post_step_comment(issue_number, body, issues: @issues)
+      issues&.comment(issue_number, body)
+    rescue StandardError => e
+      @logger&.debug("Step comment failed: #{e.message}")
       nil
     end
 
-    def post_step_completion_comment(issue_number, role, result)
+    def post_step_completion_comment(issue_number, role, result, issues: @issues)
       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}")
+        post_step_comment(issue_number, "\u{2705} **Phase: #{role}** completed \u2014 #{duration}s | $#{cost}",
+                          issues: issues)
       else
-        post_step_comment(issue_number, "\u{274C} **Phase: #{role}** failed \u2014 #{duration}s | $#{cost}")
+        post_step_comment(issue_number, "\u{274C} **Phase: #{role}** failed \u2014 #{duration}s | $#{cost}",
+                          issues: issues)
       end
     end
   end

data/lib/ocak/stream_parser.rb

@@ -157,7 +157,12 @@ module Ocak
       result_text = extract_tool_text(block['content'])
       passed = detect_test_pass(result_text)
       cmd_label = command[TEST_CMD_PATTERN] || 'test'
-      @logger.info("[TEST] #{passed ? 'PASS' : 'FAIL'} (#{cmd_label})", agent: @agent_name)
+      status_label = case passed
+                     when true  then 'PASS'
+                     when false then 'FAIL'
+                     else 'UNKNOWN'
+                     end
+      @logger.info("[TEST] #{status_label} (#{cmd_label})", agent: @agent_name)
 
       { category: :tool_result, is_test_result: true, passed: passed, command: cmd_label }
     end
@@ -193,7 +198,7 @@ module Ocak
       return false if output.match?(/FAIL/i) && !output.match?(/0 failed/i)
       return true  if output.match?(/passed/i) && !output.match?(/failed/i)
 
-      true # no obvious failure signal
+      nil # no recognized pattern — unknown result
     end
   end
 end

data/lib/ocak/templates/ocak.yml.erb

@@ -12,6 +12,7 @@ stack:
 <%- end -%>
 <%- if lint_command -%>
   lint_command: "<%= lint_command %>"
+  # lint_check_command: "<%= lint_command %>"  # Explicit check-only lint command (no auto-fix flags)
 <%- end -%>
 <%- if setup_command -%>
   setup_command: "<%= setup_command %>"