ocak 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f09506ff0c348c7f0822da37268c614ea209b9ca8edb643b7a4619df96113a3
-  data.tar.gz: 90a52276424ab7f2dbaa19643ca22ffde525460089d7f2b3f97670c638b43f2b
+  metadata.gz: 21e35193d8d3fc3b9c24f7e75502749ce4f9a57352da20d9bb0c980c2191ad9a
+  data.tar.gz: 2204cd3797a57348f3a3742fa17385375050d8b66fe37d4bdb466a4f603f31dd
 SHA512:
-  metadata.gz: 04fd822b0fc96ae9f845d97c431a40552c081d56475925069c2158685d126fb816ef87ddd9946b041c2bf624e9e6676a92c2ab30da2b8d10128eebb7a133a57b
-  data.tar.gz: 111a2c5c925cbad3919f65a92ed3d0d16c88acfd934d0e8d1baf97b21d966a53822129255f28f1941b692bd03eb455eff8ca186555d9e78b2cce189085f53853
+  metadata.gz: 7fddde997f1ba1c8f5e5e9db9e3f6dc9281ac1db82743b651f72f658967fcefeca67b05c5e338dbbaad9be798adae10f24807d1fec3ddd9975e72daba853f709
+  data.tar.gz: 0d5f6f2f9e7300eb8b242e654296dd156192e4993976a40d0ebb050a1bf417e9b36e85f1b6b4f4e8e99cc1e375275be5175f6ef9489056c2dcc1d3025cffaa9e

data/README.md

@@ -1,6 +1,6 @@
 # Ocak
 
-*Ocak (pronounced "oh-JAHK") is Turkish for "forge" or "hearth" — the place where raw material meets fire and becomes something useful. Also: let 'em cook.*
+*Ocak (pronounced "oh-JAHK") is Turkish for "forge" or "hearth" - the place where raw material meets fire and becomes something useful. Also: let 'em cook.*
 
 Multi-agent pipeline that processes GitHub issues autonomously with Claude Code. You write an issue, label it, and ocak runs it through implement → review → fix → security review → document → audit → merge. Each issue gets its own worktree so they can run in parrallel.
 
@@ -83,8 +83,8 @@ stateDiagram-v2
 ### Complexity Classification
 
 The planner classifes each issue as `simple` or `full`:
-- **Simple** — skips security review, second fix pass, documenter, and auditor
-- **Full** — runs the whole thing
+- **Simple** - skips security review, second fix pass, documenter, and auditor
+- **Full** - runs the whole thing
 
 `--fast` forces all issues to `simple`, giving you: implement → review → fix (if needed) → verify (if fixed) → merge.
 
@@ -102,7 +102,7 @@ flowchart LR
     E --> F["Merger agent<br>create PR + merge"]
 ```
 
-Merging is sequential — one at a time — so you dont get conflicts between parallel worktrees.
+Merging is sequential - one at a time - so you dont get conflicts between parallel worktrees.
 
 ## Agents
 
@@ -119,7 +119,7 @@ Merging is sequential — one at a time — so you dont get conflicts between pa
 | **planner** | Batch issues, classify complexity | Read, Glob, Grep, Bash (read-only) | haiku |
 | **pipeline** | Self-contained single-agent mode | All tools | opus |
 
-Review agents (reviewer, security-reviewer, auditor) have no Write/Edit access — they can only read and report stuff back.
+Review agents (reviewer, security-reviewer, auditor) have no Write/Edit access - they can only read and report stuff back.
 
 ## Skills
 
@@ -128,13 +128,13 @@ Interactive skills for use inside Claude Code:
 | Skill | Description |
 |-------|-------------|
 | `/design [description]` | Researches your codebase, asks clarifying questions, produces a detailed implementation-ready issue |
-| `/audit [scope]` | Codebase sweep — scopes: `security`, `errors`, `patterns`, `tests`, `data`, `dependencies`, or `all` |
+| `/audit [scope]` | Codebase sweep - scopes: `security`, `errors`, `patterns`, `tests`, `data`, `dependencies`, or `all` |
 | `/scan-file <path>` | Deep single-file analysis with test coverage check, scored 1-10 per method |
 | `/debt` | Tech debt tracker with risk scoring (churn, coverage, suppressions, age, blast radius) |
 
 ## Modes
 
-### Full Pipeline — `ocak run`
+### Full Pipeline - `ocak run`
 
 The default. Polls for `auto-ready` issues, plans batches, runs the full step sequence in parallel worktrees, merges sequentally.
 
@@ -146,7 +146,7 @@ ocak run --audit --watch         # Auditor as merge gate
 ocak run --fast --watch          # Skip security/docs/audit steps
 ```
 
-### Fast Mode — `ocak hiz`
+### Fast Mode - `ocak hiz`
 
 Lightweight alternative for quick PRs you'll review youself:
 
@@ -173,11 +173,54 @@ 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`.
+
+### Multi-Repo Mode
+
+Run issues across multiple repos from a single issue tracker. One "god repo" holds all the issues, agents run in worktrees of whatever repo the issue targets.
+
+Each issue specifies its target with YAML front-matter at the top of the body:
+
+```
+---
+target_repo: my-service
+---
+
+Actual issue description here...
+```
+
+Enable it in `ocak.yml`:
+
+```yaml
+multi_repo: true
+```
+
+Map repo names to local paths in `~/.config/ocak/config.yml`:
+
+```yaml
+repos:
+  my-service: ~/dev/my-service
+  other-thing: ~/dev/other-thing
+```
+
+Labels and comments stay on the god repo's issues. PRs get created in the target repo. Worktree isolation, parallel batches, sequential merging all work the same.
+
 ### 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.
+`Ctrl+C` once - current agent step finishes, then the pipeline stops. WIP gets committed, labels reset to `auto-ready`, and resume commands are printed.
 
-`Ctrl+C` twice — kills active subprocesses immediatley (SIGTERM → wait → SIGKILL), then same cleanup runs.
+`Ctrl+C` twice - kills active subprocesses immediatley (SIGTERM → wait → SIGKILL), then same cleanup runs.
 
 ```bash
 ocak resume 42 --watch  # Pick up from where it stopped
@@ -199,6 +242,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
@@ -224,7 +271,7 @@ labels:
   reready: "auto-reready"
   awaiting_review: "auto-pending-human"
 
-# Pipeline steps — add, remove, reorder as you like
+# Pipeline steps - add, remove, reorder as you like
 steps:
   - agent: implementer
     role: implement
@@ -259,6 +306,25 @@ agents:
   # ...
 ```
 
+### User Config
+
+`ocak init` scaffolds `~/.config/ocak/config.yml` (or `$XDG_CONFIG_HOME/ocak/config.yml`) for machine-specific settings. When both files exist, project `ocak.yml` wins on conflicts.
+
+```yaml
+# ~/.config/ocak/config.yml
+
+# Repo path mappings for multi-repo mode
+repos:
+  my-service: ~/dev/my-service
+
+# Machine-level overrides
+pipeline:
+  max_parallel: 3
+  cost_budget: 10.00
+```
+
+The `repos:` key only comes from user config so repo paths dont leak into project config.
+
 ## Customization
 
 ### Swap Agents
@@ -334,8 +400,8 @@ steps:
 | Python | Django, Flask, FastAPI | pytest | ruff, flake8 | bandit, safety |
 | Rust | Actix, Axum, Rocket | cargo test | cargo clippy | cargo audit |
 | Go | Gin, Echo, Fiber, Chi | go test | golangci-lint | gosec |
-| Java | — | gradle test | — | — |
-| Elixir | Phoenix | mix test | mix credo | — |
+| Java | - | gradle test | - | - |
+| Elixir | Phoenix | mix test | mix credo | - |
 
 Monorepo detection: npm/pnpm workspaces, Cargo workspaces, Go workspaces, Lerna, and convention-based (`packages/`, `apps/`, `services/`).
 
@@ -351,15 +417,15 @@ Shows per-run stats (cost, duration, steps completed, failures) and aggregates a
 
 ## Writing Good Issues
 
-The `/design` skill produces issues formatted for zero-context agents. Think of it as writing a ticket for a contractor who's never seen your codebase — everthing they need should be in the issue body. The key sections:
+The `/design` skill produces issues formatted for zero-context agents. Think of it as writing a ticket for a contractor who's never seen your codebase - everthing they need should be in the issue body. The key sections:
 
-- **Context** — what part of the system, with specific file paths
-- **Acceptance Criteria** — "when X, then Y" format, each independantly testable
-- **Implementation Guide** — exact files to create/modify
-- **Patterns to Follow** — references to actual files in the codebase
-- **Security Considerations** — auth, validation, data exposure
-- **Test Requirements** — specific test cases with file paths
-- **Out of Scope** — explicit boundaries so it doesnt scope creep
+- **Context** - what part of the system, with specific file paths
+- **Acceptance Criteria** - "when X, then Y" format, each independantly testable
+- **Implementation Guide** - exact files to create/modify
+- **Patterns to Follow** - references to actual files in the codebase
+- **Security Considerations** - auth, validation, data exposure
+- **Test Requirements** - specific test cases with file paths
+- **Out of Scope** - explicit boundaries so it doesnt scope creep
 
 ## CLI Reference
 
@@ -398,6 +464,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
@@ -413,6 +489,10 @@ Depends on the issue. Simple stuff is $2-5, complex issues can be $10-15. The im
 
 Reasonably. Review agents are read-only (no Write/Edit tools), merging is sequential so you dont get conflicts, and failed piplines get labeled and logged. You can always `--dry-run` first to see what it would do.
 
+**Can I trust `ocak.yml` from someone else's repo?**
+
+Treat it like a Makefile. Commands in `test_command`, `lint_command`, `security_commands`, etc. run with your user privileges. First time you run ocak in a new repo it'll print a warning. Review the commands before running `ocak run` on repos you didnt write.
+
 **What if it breaks?**
 
 Issues get labeled `pipeline-failed` with a comment explaining what went wrong. Worktrees get cleaned up automaticaly. Run `ocak clean` to remove any stragglers, and check `logs/pipeline/` for detailed logs.

data/lib/ocak/agent_generator.rb

@@ -3,9 +3,13 @@
 require 'erb'
 require 'fileutils'
 require 'open3'
+require_relative 'claude_runner'
+require_relative 'command_runner'
 
 module Ocak
   class AgentGenerator
+    include CommandRunner
+
     AGENT_TEMPLATES = %w[
       implementer reviewer security_reviewer documenter
       merger pipeline planner auditor
@@ -136,10 +140,14 @@ module Ocak
         You are customizing a Claude Code agent for a specific project.
 
         Here is the project context:
+        <project_context>
         #{context}
+        </project_context>
 
         Here is the base agent template:
+        <base_template>
         #{template_content}
+        </base_template>
 
         Customize this agent to reference this project's actual conventions, file paths,
         and patterns. Keep the same structure (YAML frontmatter + markdown). Keep the same
@@ -150,6 +158,7 @@ module Ocak
     end
 
     def claude_available?
+      # Uses Open3 directly; 'which' is not a git/gh command
       _, _, status = Open3.capture3('which', 'claude')
       status.success?
     rescue Errno::ENOENT => e
@@ -158,10 +167,11 @@ module Ocak
     end
 
     def run_claude_prompt(prompt)
+      # Uses Open3 directly; 'claude' is not a git/gh command
       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,132 @@
+# frozen_string_literal: true
+
+require_relative 'target_resolver'
+
+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
+
+      ready_issues = resolve_targets(ready_issues, logger: logger) if @config.multi_repo?
+
+      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:)
+      shared_worktrees = @config.multi_repo? ? nil : WorktreeManager.new(config: @config, logger: logger)
+
+      threads = batch_issues.map do |issue|
+        Thread.new { process_one_issue(issue, worktrees: shared_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]
+
+        worktree_manager_for(result[:worktree], shared: shared_worktrees, logger: logger)
+          .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
+      @state_machine.mark_in_progress(issue_number)
+
+      target = issue['_target']
+      worktree_mgr = if target
+                       WorktreeManager.new(config: @config, repo_dir: target[:path], logger: logger)
+                     else
+                       worktrees
+                     end
+      worktree = worktree_mgr.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
+
+    def worktree_manager_for(worktree, shared:, logger:)
+      target = worktree.target_repo
+      return WorktreeManager.new(config: @config, repo_dir: target[:path], logger: logger) if target
+
+      shared || WorktreeManager.new(config: @config, logger: logger)
+    end
+
+    def resolve_targets(ready_issues, logger:)
+      ready_issues.filter_map do |issue|
+        target = TargetResolver.resolve(issue, config: @config)
+        issue['_target'] = target
+        issue
+      rescue TargetResolver::TargetResolutionError => e
+        logger.error("Skipping issue ##{issue['number']}: #{e.message}")
+        nil
+      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

@@ -4,8 +4,10 @@ require 'open3'
 require 'securerandom'
 require_relative '../config'
 require_relative '../claude_runner'
+require_relative '../command_runner'
 require_relative '../git_utils'
-require_relative '../issue_fetcher'
+require_relative '../issue_backend'
+require_relative '../issue_state_machine'
 require_relative '../pipeline_executor'
 require_relative '../step_comments'
 require_relative '../logger'
@@ -14,6 +16,7 @@ module Ocak
   module Commands
     class Hiz < Dry::CLI::Command
       include StepComments
+      include CommandRunner
 
       desc 'Fast-mode: implement an issue with Sonnet, create a PR (no merge)'
 
@@ -24,9 +27,9 @@ module Ocak
       option :quiet, type: :boolean, default: false, desc: 'Suppress non-error output'
 
       HIZ_STEPS = [
-        { agent: 'implementer', role: 'implement', model: 'sonnet' },
-        { agent: 'reviewer', role: 'review', model: 'haiku', parallel: true },
-        { agent: 'security-reviewer', role: 'security', model: 'sonnet', parallel: true }
+        { agent: 'implementer', role: 'implement', model: ClaudeRunner::MODEL_SONNET },
+        { agent: 'reviewer', role: 'review', model: ClaudeRunner::MODEL_HAIKU, parallel: true },
+        { agent: 'security-reviewer', role: 'security', model: ClaudeRunner::MODEL_SONNET, parallel: true }
       ].freeze
 
       HizState = Struct.new(:issues, :total_cost, :steps_run, :review_results)
@@ -43,7 +46,8 @@ module Ocak
         @logger = logger = build_logger(issue_number)
         watch_formatter = options[:watch] ? WatchFormatter.new : nil
         claude = ClaudeRunner.new(config: @config, logger: logger, watch: watch_formatter)
-        issues = IssueFetcher.new(config: @config, logger: logger)
+        issues = IssueBackend.build(config: @config, logger: logger)
+        @state_machine = IssueStateMachine.new(config: @config, issues: issues)
 
         logger.info("=== Hiz (fast mode) for issue ##{issue_number} ===")
 
@@ -68,7 +72,7 @@ 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)
+        @state_machine.mark_in_progress(issue_number)
         post_hiz_start_comment(issue_number, state: state)
         begin
           branch = create_branch(issue_number, chdir)
@@ -81,7 +85,7 @@ module Ocak
         executor = PipelineExecutor.new(config: @config, issues: issues)
         result = executor.run_pipeline(
           issue_number, logger: logger, claude: claude, chdir: chdir,
-                        steps: HIZ_STEPS, verification_model: 'sonnet',
+                        steps: HIZ_STEPS, verification_model: ClaudeRunner::MODEL_SONNET,
                         post_start_comment: false, post_summary_comment: false
         )
 
@@ -119,8 +123,8 @@ module Ocak
         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?
+        result = run_git('checkout', '-b', branch, chdir: chdir)
+        raise "Failed to create branch #{branch}: #{result.error}" unless result.success?
 
         branch
       end
@@ -128,10 +132,10 @@ module Ocak
       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, branch: branch)
+        push_result = run_git('push', '-u', 'origin', branch, chdir: chdir)
+        unless push_result.success?
+          logger.error("Push failed: #{push_result.error}")
+          handle_failure(issue_number, 'push', push_result.error, issues: state.issues, logger: logger, branch: branch)
           return
         end
 
@@ -140,21 +144,16 @@ module Ocak
         pr_title = issue_title ? "Fix ##{issue_number}: #{issue_title}" : "Fix ##{issue_number}"
         pr_body = build_pr_body(issue_number, state: state)
 
-        stdout, stderr, status = Open3.capture3(
-          'gh', 'pr', 'create',
-          '--title', pr_title,
-          '--body', pr_body,
-          '--head', branch,
-          chdir: chdir
-        )
+        pr_result = run_gh('pr', 'create', '--title', pr_title, '--body', pr_body, '--head', branch, chdir: chdir)
 
-        if status.success?
-          pr_url = stdout.strip
+        if pr_result.success?
+          pr_url = pr_result.output
           logger.info("PR created: #{pr_url}")
           puts "PR created: #{pr_url}"
         else
-          logger.error("PR creation failed: #{stderr}")
-          handle_failure(issue_number, 'pr-create', stderr, issues: state.issues, logger: logger, branch: branch)
+          logger.error("PR creation failed: #{pr_result.error}")
+          handle_failure(issue_number, 'pr-create', pr_result.error, issues: state.issues, logger: logger,
+                                                                     branch: branch)
         end
       end
 
@@ -185,12 +184,13 @@ module Ocak
 
       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)
+        @state_machine.mark_failed(issue_number)
         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
+        rescue StandardError => e
+          logger&.debug("Failure comment failed: #{e.message}")
           nil
         end
         warn "Issue ##{issue_number} failed at phase: #{phase}"
@@ -199,8 +199,8 @@ module Ocak
       end
 
       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?
+        result = run_git('branch', '-D', branch, chdir: @config.project_dir)
+        logger.warn("Failed to delete branch #{branch}: #{result.error}") unless result.success?
       rescue StandardError => e
         logger.warn("Error deleting branch #{branch}: #{e.message}")
       end