ocak 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3ade72c57a02f3647218543b060295454aec639d90ba261b4fe9b88fa05f1bf
-  data.tar.gz: 86decb5ce7099d43214859b82f3b12fc7d55b5cdf3d1d57a30ed38dc7c74a957
+  metadata.gz: bb7c3ddd6ff9b6dacc60c4ee6f3fabae90089eace4e457a28e824be15a901cda
+  data.tar.gz: c9b5a76e36361dddb4731fff6298388f0246421272923951f83fdcebde9e5d4b
 SHA512:
-  metadata.gz: 6ba522815876568e13b9453cdbd943a873c2ad28cee59a6c92d99b6dc62ccfeeadac57a2a2815b95f834b7c7173ffb2baf40107dcdfabc2cc74cf3d04446ad2d
-  data.tar.gz: 9b4d7d602aa8c2c213d64bbf75a5d9c5dfecb01952d327140c268f32474aaa02e3664f6b29cd60c9eee45fa1ac97e6f5012b9bbac51d54b1de68d40c34291a64
+  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
@@ -109,7 +110,7 @@ module Ocak
         agent_path = File.join(output_dir, "#{output_name}.md")
         current_content = File.read(agent_path)
 
-        prompt = build_enhancement_prompt(agent, current_content, context)
+        prompt = build_enhancement_prompt(current_content, context)
         result = run_claude_prompt(prompt)
 
         if result && !result.strip.empty? && result.include?('---')
@@ -131,7 +132,7 @@ module Ocak
       parts.join("\n\n")
     end
 
-    def build_enhancement_prompt(_agent, template_content, context)
+    def build_enhancement_prompt(template_content, context)
       <<~PROMPT
         You are customizing a Claude Code agent for a specific project.
 
@@ -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,17 +5,14 @@ require 'securerandom'
 require_relative '../config'
 require_relative '../claude_runner'
 require_relative '../git_utils'
-require_relative '../issue_fetcher'
-require_relative '../verification'
-require_relative '../planner'
+require_relative '../issue_backend'
+require_relative '../pipeline_executor'
 require_relative '../step_comments'
 require_relative '../logger'
 
 module Ocak
   module Commands
     class Hiz < Dry::CLI::Command
-      include Verification
-      include Planner
       include StepComments
 
       desc 'Fast-mode: implement an issue with Sonnet, create a PR (no merge)'
@@ -26,17 +23,10 @@ module Ocak
       option :verbose, type: :boolean, default: false, desc: 'Increase log detail'
       option :quiet, type: :boolean, default: false, desc: 'Suppress non-error output'
 
-      STEP_MODELS = {
-        'implementer' => 'sonnet',
-        'reviewer' => 'haiku',
-        'security-reviewer' => 'sonnet'
-      }.freeze
-
-      IMPLEMENT_STEP = { agent: 'implementer', role: 'implement' }.freeze
-
-      REVIEW_STEPS = [
-        { agent: 'reviewer',          role: 'review' },
-        { agent: 'security-reviewer', role: 'security' }
+      HIZ_STEPS = [
+        { 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)
@@ -50,10 +40,10 @@ module Ocak
           return
         end
 
-        logger = build_logger(issue_number)
+        @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} ===")
 
@@ -78,130 +68,70 @@ module Ocak
         start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         chdir = @config.project_dir
 
+        issues.transition(issue_number, from: @config.label_ready, to: @config.label_in_progress)
         post_hiz_start_comment(issue_number, state: state)
-        branch = create_branch(issue_number, chdir)
-
-        failure = run_agents(issue_number, claude: claude, logger: logger, chdir: chdir, state: state)
-        if failure
-          duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time).round
-          post_hiz_summary_comment(issue_number, duration, success: false, failed_phase: failure[:phase],
-                                                           state: state)
-          handle_failure(issue_number, failure[:phase], failure[:output], issues: state.issues, logger: logger)
+        begin
+          branch = create_branch(issue_number, chdir)
+        rescue RuntimeError => e
+          fail_pipeline(issue_number, 'create-branch', e.message,
+                        start_time: start_time, state: state, logger: logger)
           return
         end
 
-        verification_failure = run_final_verification_step(issue_number, claude: claude, logger: logger,
-                                                                         chdir: chdir, state: state)
-        if verification_failure
-          duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time).round
-          post_hiz_summary_comment(issue_number, duration, success: false, failed_phase: 'final-verify',
-                                                           state: state)
-          handle_failure(issue_number, 'final-verify', verification_failure[:output],
-                         issues: state.issues, logger: logger)
+        executor = PipelineExecutor.new(config: @config, issues: issues)
+        result = executor.run_pipeline(
+          issue_number, logger: logger, claude: claude, chdir: chdir,
+                        steps: HIZ_STEPS, verification_model: ClaudeRunner::MODEL_SONNET,
+                        post_start_comment: false, post_summary_comment: false
+        )
+
+        state.total_cost = result[:total_cost] || 0.0
+        state.steps_run = result[:steps_run] || 0
+        state.steps_run += 1 if verification_ran?(result)
+
+        unless result[:success]
+          fail_pipeline(issue_number, result[:phase], result[:output],
+                        start_time: start_time, state: state, logger: logger, branch: branch)
           return
         end
 
+        state.review_results = extract_review_results(result[:step_results])
+
         duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time).round
         post_hiz_summary_comment(issue_number, duration, success: true, state: state)
         push_and_create_pr(issue_number, branch, logger: logger, chdir: chdir, state: state)
       end
 
-      def run_agents(issue_number, claude:, logger:, chdir:, state:)
-        result = run_step(IMPLEMENT_STEP, issue_number, claude: claude, logger: logger, chdir: chdir, state: state)
-        state.steps_run += 1
-        state.total_cost += result.cost_usd.to_f
-        unless result.success?
-          logger.error("Implementation failed for issue ##{issue_number}")
-          return { phase: 'implement', output: result.output }
-        end
+      def verification_ran?(result)
+        (@config.test_command || @config.lint_check_command) &&
+          (result[:success] || result[:phase] == 'final-verify')
+      end
 
-        state.review_results = run_reviews_in_parallel(issue_number, claude: claude, logger: logger,
-                                                                     chdir: chdir, state: state)
-        nil
+      def extract_review_results(step_results)
+        return {} unless step_results
+
+        step_results.select do |_role, r|
+          r&.blocking_findings? || r&.warnings?
+        end
       end
 
       def create_branch(issue_number, chdir)
         branch = "hiz/issue-#{issue_number}-#{SecureRandom.hex(4)}"
+        raise "Unsafe branch name: #{branch}" unless GitUtils.safe_branch_name?(branch)
+
         _, stderr, status = Open3.capture3('git', 'checkout', '-b', branch, chdir: chdir)
         raise "Failed to create branch #{branch}: #{stderr}" unless status.success?
 
         branch
       end
 
-      def run_reviews_in_parallel(issue_number, claude:, logger:, chdir:, state:)
-        threads = REVIEW_STEPS.map do |step|
-          Thread.new do
-            run_step(step, issue_number, claude: claude, logger: logger, chdir: chdir, state: state)
-          rescue StandardError => e
-            logger.error("#{step[:role]} thread failed: #{e.message}")
-            nil
-          end
-        end
-
-        results = {}
-        threads.each_with_index do |thread, i|
-          result = thread.value
-          step = REVIEW_STEPS[i]
-          if result
-            state.steps_run += 1
-            state.total_cost += result.cost_usd.to_f
-            results[step[:role]] = result if result.blocking_findings? || result.warnings?
-          end
-          next if result.nil? || result.success?
-
-          logger.warn("#{step[:role]} reported issues but continuing")
-        end
-        results
-      end
-
-      def run_step(step, issue_number, claude:, logger:, chdir:, state:)
-        agent = step[:agent]
-        role = step[:role]
-        model = STEP_MODELS[agent]
-        logger.info("--- Phase: #{role} (#{agent}) [#{model}] ---")
-        post_step_comment(issue_number, "\u{1F504} **Phase: #{role}** (#{agent})", state: state)
-        prompt = build_step_prompt(role, issue_number, nil)
-        result = claude.run_agent(agent, prompt, chdir: chdir, model: model)
-        post_step_completion_comment(issue_number, role, result, state: state)
-        result
-      end
-
-      def run_final_verification_step(issue_number, claude:, logger:, chdir:, state:)
-        return nil unless @config.test_command || @config.lint_check_command
-
-        logger.info('--- Final verification ---')
-        post_step_comment(issue_number, "\u{1F504} **Phase: final-verify** (verification)", state: state)
-        result = run_final_checks(logger, chdir: chdir)
-
-        unless result[:success]
-          logger.warn('Final checks failed, attempting fix...')
-          post_step_comment(issue_number,
-                            "\u{26A0}\u{FE0F} **Final verification failed** \u2014 attempting auto-fix...",
-                            state: state)
-          fix_prompt = "Fix these test/lint failures:\n\n" \
-                       "<verification_output>\n#{result[:output]}\n</verification_output>"
-          claude.run_agent('implementer', fix_prompt,
-                           chdir: chdir, model: STEP_MODELS['implementer'])
-          result = run_final_checks(logger, chdir: chdir)
-        end
-
-        state.steps_run += 1
-        if result[:success]
-          post_step_comment(issue_number, "\u{2705} **Phase: final-verify** completed", state: state)
-          nil
-        else
-          post_step_comment(issue_number, "\u{274C} **Phase: final-verify** failed", state: state)
-          { success: false, phase: 'final-verify', output: result[:output] }
-        end
-      end
-
       def push_and_create_pr(issue_number, branch, logger:, chdir:, state:)
         commit_changes(issue_number, chdir, logger: logger)
 
         _, stderr, status = Open3.capture3('git', 'push', '-u', 'origin', branch, chdir: chdir)
         unless status.success?
           logger.error("Push failed: #{stderr}")
-          handle_failure(issue_number, 'push', stderr, issues: state.issues, logger: logger)
+          handle_failure(issue_number, 'push', stderr, issues: state.issues, logger: logger, branch: branch)
           return
         end
 
@@ -224,7 +154,7 @@ module Ocak
           puts "PR created: #{pr_url}"
         else
           logger.error("PR creation failed: #{stderr}")
-          handle_failure(issue_number, 'pr-create', stderr, issues: state.issues, logger: logger)
+          handle_failure(issue_number, 'pr-create', stderr, issues: state.issues, logger: logger, branch: branch)
         end
       end
 
@@ -247,41 +177,44 @@ module Ocak
         body
       end
 
-      def handle_failure(issue_number, phase, output, issues:, logger:)
-        logger.error("Issue ##{issue_number} failed at phase: #{phase}")
-        issues.comment(issue_number,
-                       "Hiz (fast mode) failed at phase: #{phase}\n\n```\n#{output.to_s[0..1000]}\n```")
-        warn "Issue ##{issue_number} failed at phase: #{phase}"
-        _, stderr, status = Open3.capture3('git', 'checkout', 'main', chdir: @config.project_dir)
-        logger.warn("Cleanup checkout to main failed: #{stderr}") unless status.success?
+      def fail_pipeline(issue_number, phase, output, start_time:, state:, logger:, branch: nil) # rubocop:disable Metrics/ParameterLists
+        duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time).round
+        post_hiz_summary_comment(issue_number, duration, success: false, failed_phase: phase, state: state)
+        handle_failure(issue_number, phase, output, issues: state.issues, logger: logger, branch: branch)
       end
 
-      def build_logger(issue_number)
-        PipelineLogger.new(log_dir: File.join(@config.project_dir, @config.log_dir), issue_number: issue_number)
+      def handle_failure(issue_number, phase, output, issues:, logger:, branch: nil)
+        logger.error("Issue ##{issue_number} failed at phase: #{phase}")
+        issues.transition(issue_number, from: @config.label_in_progress, to: @config.label_failed)
+        begin
+          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 => e
+          logger&.debug("Failure comment failed: #{e.message}")
+          nil
+        end
+        warn "Issue ##{issue_number} failed at phase: #{phase}"
+        GitUtils.checkout_main(chdir: @config.project_dir, logger: logger)
+        delete_branch(branch, logger: logger) if branch
       end
 
-      def post_step_comment(issue_number, body, state:)
-        state.issues&.comment(issue_number, body)
-      rescue StandardError
-        nil
+      def delete_branch(branch, logger:)
+        _, stderr, status = Open3.capture3('git', 'branch', '-D', branch, chdir: @config.project_dir)
+        logger.warn("Failed to delete branch #{branch}: #{stderr}") unless status.success?
+      rescue StandardError => e
+        logger.warn("Error deleting branch #{branch}: #{e.message}")
       end
 
-      def post_step_completion_comment(issue_number, role, result, state:)
-        duration = (result.duration_ms.to_f / 1000).round
-        cost = format('%.3f', result.cost_usd.to_f)
-        if result.success?
-          post_step_comment(issue_number, "\u{2705} **Phase: #{role}** completed \u2014 #{duration}s | $#{cost}",
-                            state: state)
-        else
-          post_step_comment(issue_number, "\u{274C} **Phase: #{role}** failed \u2014 #{duration}s | $#{cost}",
-                            state: state)
-        end
+      def build_logger(issue_number)
+        PipelineLogger.new(log_dir: File.join(@config.project_dir, @config.log_dir), issue_number: issue_number)
       end
 
       def post_hiz_start_comment(issue_number, state:)
         steps = "implement \u2192 review \u2225 security"
         steps += " \u2192 verify" if @config.test_command || @config.lint_check_command
-        post_step_comment(issue_number, "\u{1F680} **Hiz (fast mode) started** \u2014 #{steps}", state: state)
+        post_step_comment(issue_number, "\u{1F680} **Hiz (fast mode) started** \u2014 #{steps}",
+                          issues: state.issues)
       end
 
       def post_hiz_summary_comment(issue_number, duration, success:, state:, failed_phase: nil)
@@ -292,12 +225,12 @@ module Ocak
           post_step_comment(issue_number,
                             "\u{2705} **Pipeline complete** \u2014 #{state.steps_run}/#{total} steps run " \
                             "| 0 skipped | $#{cost} total | #{duration}s",
-                            state: state)
+                            issues: state.issues)
         else
           post_step_comment(issue_number,
                             "\u{274C} **Pipeline failed** at phase: #{failed_phase} \u2014 " \
                             "#{state.steps_run}/#{total} steps completed | $#{cost} total",
-                            state: state)
+                            issues: state.issues)
         end
       end
     end

data/lib/ocak/commands/init.rb

@@ -85,7 +85,12 @@ module Ocak
 
       def update_settings(project_dir, stack)
         settings_path = File.join(project_dir, '.claude', 'settings.json')
-        existing = File.exist?(settings_path) ? JSON.parse(File.read(settings_path)) : {}
+        existing = begin
+          File.exist?(settings_path) ? JSON.parse(File.read(settings_path)) : {}
+        rescue JSON::ParserError
+          puts '  Warning: .claude/settings.json is not valid JSON, creating fresh'
+          {}
+        end
 
         merge_permissions(existing, stack)
         merge_hooks(existing)
@@ -178,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'
@@ -211,11 +221,7 @@ module Ocak
       end
 
       def init_logger
-        @init_logger ||= Object.new.tap do |l|
-          def l.info(msg)
-            puts "  #{msg}"
-          end
-        end
+        @init_logger ||= Struct.new(:_) { def info(msg) = puts("  #{msg}") }.new
       end
     end
   end