ocak 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4aa86d60189e50486edaba37ce3a2763d52a28b817818ac5b6466c952087cff
-  data.tar.gz: 4a1d662842ef9f7e88fe5b6deeb30c51f061a6a598f948e1e622bf60e05abc70
+  metadata.gz: f3ade72c57a02f3647218543b060295454aec639d90ba261b4fe9b88fa05f1bf
+  data.tar.gz: 86decb5ce7099d43214859b82f3b12fc7d55b5cdf3d1d57a30ed38dc7c74a957
 SHA512:
-  metadata.gz: 14787c35edcd0b30fd87b1aaf3e9537e091778a457ab43c33304b037dcbd79efa03d3f1dbdfa5d7d4256431cea8e7067d2c66ea9e5fcbaa43f86cfdef1802105
-  data.tar.gz: 8d0c0b8a7ad9a8ed47d9b2864d9238b6a6705df00d6580db7296d67fab284198001c41ed9cc024edb6288344183ef07059788f536392ba7b7b386baa52106e7e
+  metadata.gz: 6ba522815876568e13b9453cdbd943a873c2ad28cee59a6c92d99b6dc62ccfeeadac57a2a2815b95f834b7c7173ffb2baf40107dcdfabc2cc74cf3d04446ad2d
+  data.tar.gz: 9b4d7d602aa8c2c213d64bbf75a5d9c5dfecb01952d327140c268f32474aaa02e3664f6b29cd60c9eee45fa1ac97e6f5012b9bbac51d54b1de68d40c34291a64

data/README.md

@@ -2,7 +2,7 @@
 
 *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 parallel.
+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.
 
 ## Quick Start
 
@@ -19,61 +19,168 @@ ocak init
 ocak run --once --watch
 
 # Or run a single issue:
-ocak run --single 42 --watch
+ocak run 42 --watch
 ```
 
 ## How It Works
 
-### The Pipeline
+### Pipeline Flow
 
+```mermaid
+flowchart LR
+    A["/design<br>Create issue"] --> B["Label<br>auto-ready"]
+    B --> C["Planner<br>Batch & classify"]
+    C --> D["Worktree<br>per issue"]
+    D --> E["Pipeline<br>Steps"]
+    E --> F["Rebase<br>& merge"]
 ```
-  /design        Label           Pipeline
-  ┌──────┐    ┌──────────┐    ┌───────────────────────────────────────────┐
-  │ User │───>│auto-ready│───>│ implement → review → fix → security →    │
-  │ idea │    │  label   │    │ document → audit → merge PR              │
-  └──────┘    └──────────┘    └───────────────────────────────────────────┘
-                                 │           │          │
-                                 ▼           ▼          ▼
-                              worktree   read-only   sequential
-                              per issue  reviews     rebase+merge
+
+### Pipeline Steps
+
+```mermaid
+flowchart TD
+    IMP["1. Implementer<br>(opus)"] --> REV["2. Reviewer<br>(sonnet)"]
+    REV -->|"🔴 findings"| FIX1["3. Fix<br>(opus)"]
+    REV -->|"no findings"| SEC
+    FIX1 --> VER["4. Verify<br>(sonnet)"]
+    VER --> SEC["5. Security Review<br>(sonnet)"]
+    SEC -->|"🔴 findings"| FIX2["6. Security Fix<br>(opus)"]
+    SEC -->|"no findings"| DOC
+    FIX2 --> DOC["7. Documenter<br>(sonnet)"]
+    DOC --> AUD["8. Auditor<br>(sonnet)"]
+    AUD --> MRG["9. Merger<br>(sonnet)"]
+```
+
+Steps 5-8 are tagged `complexity: full` and get skipped for simple issues. `--fast` forces everything to simple complexity so a typo fix doesnt burn through the whole pipeline.
+
+Conditional steps only run when needed:
+- **Fix** only runs if the reviewer flagged 🔴 blocking issues
+- **Verify** only runs if fixes were actually applied
+- **Merge** gets skipped in `--manual-review` mode or when the auditor BLOCKs
+
+### Label State Machine
+
+```mermaid
+stateDiagram-v2
+    [*] --> auto_ready
+    auto_ready --> auto_doing: Pipeline picks up
+    auto_doing --> completed: Success
+    auto_doing --> pipeline_failed: Failure
+    auto_doing --> auto_pending_human: --manual-review / audit BLOCK
+    auto_doing --> auto_ready: Ctrl+C interrupt
+    pipeline_failed --> auto_doing: ocak resume
+    auto_pending_human --> auto_reready: Human labels for re-review
+    auto_reready --> auto_pending_human: Feedback addressed
+
+    state "auto-ready" as auto_ready
+    state "auto-doing" as auto_doing
+    state "completed" as completed
+    state "pipeline-failed" as pipeline_failed
+    state "auto-pending-human" as auto_pending_human
+    state "auto-reready" as auto_reready
+```
+
+### 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
+
+`--fast` forces all issues to `simple`, giving you: implement → review → fix (if needed) → verify (if fixed) → merge.
+
+### Merge Flow
+
+After all pipeline steps complete:
+
+```mermaid
+flowchart LR
+    A["Commit<br>changes"] --> B["Rebase<br>onto main"]
+    B -->|conflict| C["Implementer<br>resolves"]
+    C --> D
+    B -->|clean| D["Run tests"]
+    D --> E["Push branch"]
+    E --> F["Merger agent<br>create PR + merge"]
 ```
 
-1. **Design** — `/design` in Claude Code walks you through creating an issue thats detailed enough for agents to work from
-2. **Label** — slap the `auto-ready` label on it
-3. **Plan** — planner agent figures out which issues can safely run in parallel
-4. **Execute** — each issue gets a worktree, runs through the pipeline steps
-5. **Merge** — completed work gets rebased, tested, and merged sequentially
+Merging is sequential — one at a time — so you dont get conflicts between parallel worktrees.
 
-### Agents
+## Agents
 
 8 agents, each with scoped tool permisions:
 
 | Agent | Role | Tools | Model |
 |-------|------|-------|-------|
-| **implementer** | Write code and tests | Read, Write, Edit, Bash | opus |
-| **reviewer** | Check patterns, tests, quality | Read, Grep, Glob (read-only) | sonnet |
-| **security-reviewer** | OWASP Top 10, auth, injection | Read, Grep, Glob, Bash | sonnet |
-| **auditor** | Pre-merge gate on changed files | Read, Grep, Glob (read-only) | sonnet |
-| **documenter** | Add missing docs | Read, Write, Edit | sonnet |
-| **merger** | Create PR, merge, close issue | Read, Grep, Bash | sonnet |
-| **planner** | Determine safe parallelization | Read, Grep, Glob (read-only) | sonnet |
-| **pipeline** | Self-contained orchestrator | All tools | opus |
+| **implementer** | Write code and tests | Read, Write, Edit, Bash, Task | opus |
+| **reviewer** | Check patterns, tests, quality | Read, Grep, Glob, Bash (read-only) | sonnet |
+| **security-reviewer** | OWASP Top 10, auth, injection | Read, Grep, Glob, Bash (read-only) | sonnet |
+| **auditor** | Pre-merge security gate | Read, Grep, Glob, Bash (read-only) | sonnet |
+| **documenter** | Add missing docs (skips if not needed) | Read, Write, Edit, Bash | sonnet |
+| **merger** | Create PR, merge, close issue | Read, Glob, Grep, Bash | sonnet |
+| **planner** | Batch issues, classify complexity | Read, Glob, Grep, Bash (read-only) | haiku |
+| **pipeline** | Self-contained single-agent mode | All tools | opus |
 
-### Skills
+Review agents (reviewer, security-reviewer, auditor) have no Write/Edit access — they can only read and report stuff back.
 
-Interactive skills for when you want to be in the loop:
+## Skills
 
-- `/design` — walks through your codebase, asks questions, produces a detailed issue
-- `/audit [scope]` — codebase sweep for security, patterns, tests, data, dependencies
-- `/scan-file <path>` — deep single-file analysis with test coverage check
-- `/debt` — tech debt tracker with risk scoring
+Interactive skills for use inside Claude Code:
 
-### Label State Machine
+| 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` |
+| `/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`
+
+The default. Polls for `auto-ready` issues, plans batches, runs the full step sequence in parallel worktrees, merges sequentally.
+
+```bash
+ocak run --once --watch          # Process current batch and exit
+ocak run 42 --watch              # Single issue, full pipeline
+ocak run --manual-review --watch # Create PRs without auto-merge
+ocak run --audit --watch         # Auditor as merge gate
+ocak run --fast --watch          # Skip security/docs/audit steps
+```
+
+### Fast Mode — `ocak hiz`
+
+Lightweight alternative for quick PRs you'll review youself:
+
+```mermaid
+flowchart LR
+    A["Implementer<br>(sonnet)"] --> B["Reviewer (haiku)<br>+<br>Security (sonnet)<br>in parallel"]
+    B --> C["Verify<br>tests + lint"]
+    C --> D["Create PR<br>(no merge)"]
 ```
-auto-ready ──→ in-progress ──→ completed
-                    │
-                    └──→ pipeline-failed
+
+Runs in your current checkout (no worktree), uses cheaper models, creates a PR without merging. Rougly 5-10x cheaper than the full pipeline.
+
+```bash
+ocak hiz 42 --watch
+```
+
+### Re-review Flow
+
+When `--manual-review` is enabled, PRs sit open for human review. After leaving feedback, slap the `auto-reready` label on the PR and ocak will:
+
+1. Check out the PR branch
+2. Run the implementer against the review comments
+3. Push with `--force-with-lease`
+4. Remove the `auto-reready` label
+5. Comment "Feedback addressed. Please re-review."
+
+### 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` twice — kills active subprocesses immediatley (SIGTERM → wait → SIGKILL), then same cleanup runs.
+
+```bash
+ocak resume 42 --watch  # Pick up from where it stopped
 ```
 
 ## Configuration
@@ -87,23 +194,35 @@ stack:
   framework: rails
   test_command: "bundle exec rspec"
   lint_command: "bundle exec rubocop -A"
+  setup_command: "bundle install"
   security_commands:
     - "bundle exec brakeman -q"
     - "bundle exec bundler-audit check"
 
 # Pipeline settings
 pipeline:
-  max_parallel: 3        # Concurrent worktrees
-  poll_interval: 60      # Seconds between polls
+  max_parallel: 5
+  poll_interval: 60
   worktree_dir: ".claude/worktrees"
   log_dir: "logs/pipeline"
+  cost_budget: 5.0          # Max USD per issue (kills pipeline if exceeded)
+  manual_review: false       # Create PRs without auto-merge
+  audit_mode: false          # Run auditor as merge gate
+
+# Safety controls
+safety:
+  allowed_authors: []        # Restrict to GitHub usernames (empty = current gh user)
+  require_comment: false     # Require confirmation comment before processing
+  max_issues_per_run: 5      # Cap issues per polling cycle
 
 # GitHub labels
 labels:
   ready: "auto-ready"
-  in_progress: "in-progress"
+  in_progress: "auto-doing"
   completed: "completed"
   failed: "pipeline-failed"
+  reready: "auto-reready"
+  awaiting_review: "auto-pending-human"
 
 # Pipeline steps — add, remove, reorder as you like
 steps:
@@ -113,19 +232,23 @@ steps:
     role: review
   - agent: implementer
     role: fix
-    condition: has_findings     # Only runs if reviewer found issues
+    condition: has_findings
   - agent: reviewer
     role: verify
-    condition: had_fixes        # Only runs if fixes were made
-  - agent: security_reviewer
+    condition: had_fixes
+  - agent: security-reviewer
     role: security
+    complexity: full
   - agent: implementer
     role: fix
     condition: has_findings
+    complexity: full
   - agent: documenter
     role: document
+    complexity: full
   - agent: auditor
     role: audit
+    complexity: full
   - agent: merger
     role: merge
 
@@ -189,6 +312,43 @@ steps:
     role: custom_step
 ```
 
+### Per-Step Model Override
+
+Override the default model for any step:
+
+```yaml
+steps:
+  - agent: implementer
+    role: implement
+    model: sonnet    # Use sonnet instead of opus for cheaper runs
+```
+
+## Stack Detection
+
+`ocak init` auto-detects your project stack and generates tailored agent templates. For anything else you get generic agents that you can cusomize.
+
+| Language | Frameworks | Test | Lint | Security |
+|----------|-----------|------|------|----------|
+| Ruby | Rails, Sinatra, Hanami | rspec | rubocop | brakeman, bundler-audit |
+| TypeScript/JS | Next, Remix, Nuxt, Svelte, React, Vue, Express | vitest, jest | biome, eslint | npm audit |
+| 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 | — |
+
+Monorepo detection: npm/pnpm workspaces, Cargo workspaces, Go workspaces, Lerna, and convention-based (`packages/`, `apps/`, `services/`).
+
+## Run Reports
+
+Pipeline runs generate JSON reports in `.ocak/reports/`:
+
+```bash
+ocak status --report
+```
+
+Shows per-run stats (cost, duration, steps completed, failures) and aggregates across recent runs (avg cost, avg duration, success rate, slowest step, most-skipped step). Handy for figuring out where all your money went.
+
 ## 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:
@@ -204,50 +364,66 @@ The `/design` skill produces issues formatted for zero-context agents. Think of
 ## CLI Reference
 
 ```
-ocak init [--force] [--no-ai]    Set up pipeline in current project
-ocak run [options]                Run the pipeline
-  --watch                         Stream agent activity with color
-  --single N                      Run one issue, no worktrees
-  --dry-run                       Show plan without executing
-  --once                          Process current batch and exit
-  --max-parallel N                Limit concurrency (default: 3)
-  --poll-interval N               Seconds between polls (default: 60)
-ocak status                       Show pipeline state
-ocak clean                        Remove stale worktrees
-ocak design [description]         Launch issue design session
-ocak audit [scope]                Run codebase audit
-ocak debt                         Track technical debt
+ocak init [--force] [--no-ai]       Set up pipeline in current project
+     [--config-only]                Only generate config, hooks, settings
+     [--skip-agents]                Skip agent generation
+     [--skip-skills]                Skip skill generation
+
+ocak run [ISSUE] [options]           Run the pipeline
+     --watch                        Stream agent activity with color
+     --dry-run                      Show plan without executing
+     --once                         Process current batch and exit
+     --fast                         Skip security/docs/audit (simple complexity)
+     --max-parallel N               Limit concurrency (default: 5)
+     --poll-interval N              Seconds between polls (default: 60)
+     --manual-review                Create PRs without auto-merge
+     --audit                        Run auditor as post-pipeline gate
+     --verbose / --quiet            Control output verbosity
+
+ocak hiz ISSUE [options]             Fast mode: implement + parallel review
+     --watch                        Stream agent activity
+     --dry-run                      Show plan without executing
+     --verbose / --quiet            Control output verbosity
+
+ocak resume ISSUE [options]          Resume from last successful step
+     --watch                        Stream agent activity
+     --dry-run                      Show which steps would re-run
+     --verbose / --quiet            Control output verbosity
+
+ocak status                          Show pipeline state
+     --report                       Show run reports (cost, duration, stats)
+
+ocak clean                           Remove stale worktrees
+     --logs                         Clean log files, state, and reports
+     --all                          Clean worktrees and logs
+     --keep N                       Only remove artifacts older than N days
+
+ocak design [DESCRIPTION]            Launch interactive issue design session
+ocak audit [SCOPE]                   Print instructions for /audit skill
+ocak debt                            Print instructions for /debt skill
 ```
 
 ## FAQ
 
 **How much does it cost?**
 
-Depends on the issue. Simple stuff is $2-5, complex issues can be $10-15. The implementer runs on opus which is the expensive part, reviews on sonnet are pretty cheap. You can see costs in the `--watch` output.
+Depends on the issue. Simple stuff is $2-5, complex issues can be $10-15. The implementer runs on opus which is the expensive part, reviews on sonnet are pretty cheap. Use `ocak hiz` for ~5-10x cheaper runs. Set `cost_budget` in config to cap spend per issue.
 
 **Is it safe?**
 
-Reasonably. Review agents are read-only (no Write/Edit tools), merging is sequential so you don't get conflicts, and failed piplines get labeled and logged. You can always `--dry-run` first to see what it would do.
+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.
 
 **What if it breaks?**
 
-Issues get labeled `pipeline-failed` with a comment explaining what went wrong. Worktrees get cleaned up automatically. Run `ocak clean` to remove any stragglers, and check `logs/pipeline/` for detailed logs.
-
-**Can I run one issue manually?**
-
-```bash
-ocak run --single 42 --watch
-```
-
-Runs the full pipeline for issue #42 in your current checkout (no worktree).
+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.
 
 **How do I pause it?**
 
-Kill the `ocak run` process. Issues that are `in-progress` will keep their label — remove it manually or let the next run pick them back up.
+`Ctrl+C` once lets the current step finish, commits WIP changes, resets labels, and prints resume commands. `Ctrl+C` twice kills subprocesses immediately. Exit code 130 either way.
 
-**What languages does it support?**
-
-`ocak init` auto-detects Ruby, TypeScript/JavaScript, Python, Rust, Go, Java, and Elixir. Agents get generated with stack-specific instructions. For anything else you get generic agents that you can customize.
+```bash
+ocak resume 42 --watch  # pick up from where it stopped
+```
 
 ## Development
 

data/lib/ocak/agent_generator.rb

@@ -2,6 +2,7 @@
 
 require 'erb'
 require 'fileutils'
+require 'open3'
 
 module Ocak
   class AgentGenerator
@@ -89,6 +90,7 @@ module Ocak
       monorepo = @stack.respond_to?(:monorepo) ? @stack.monorepo : false
       packages = @stack.respond_to?(:packages) ? (@stack.packages || []) : []
       project_dir = @project_dir
+      max_parallel = 5
 
       binding
     end

data/lib/ocak/claude_runner.rb

@@ -14,9 +14,8 @@ module Ocak
       def warnings?          = output.to_s.include?("\u{1F7E1}")
     end
 
-    FailedStatus = Struct.new(:success?) do
-      def self.instance = new(false)
-    end
+    # Backwards-compat alias — FailedStatus now lives in ProcessRunner.
+    FailedStatus = ProcessRunner::FailedStatus
 
     AGENT_TOOLS = {
       'implementer' => 'Read,Write,Edit,Glob,Grep,Bash',
@@ -53,10 +52,11 @@ module Ocak
       /overloaded/i
     ].freeze
 
-    def initialize(config:, logger:, watch: nil)
+    def initialize(config:, logger:, watch: nil, registry: nil)
       @config = config
       @logger = logger
       @watch = watch
+      @registry = registry
     end
 
     def run_agent(agent_name, prompt, chdir: nil, model: nil, retries: MAX_RETRIES)
@@ -119,7 +119,8 @@ module Ocak
     end
 
     def build_agent_result(parser, status, stderr, agent_name)
-      output = parser.result_text || ''
+      full = parser.full_output
+      output = full.empty? ? (parser.result_text || '') : full
       exit_ok = status.respond_to?(:success?) && status.success?
       success = parser.success? && exit_ok
 
@@ -153,7 +154,7 @@ module Ocak
       cmd.push('--model', model) if model
       cmd.push('--', prompt)
 
-      ProcessRunner.run(cmd, chdir: chdir, timeout: TIMEOUT, on_line: on_line)
+      ProcessRunner.run(cmd, chdir: chdir, timeout: TIMEOUT, on_line: on_line, registry: @registry)
     end
 
     def extract_result_from_stream(raw)

data/lib/ocak/commands/clean.rb

@@ -1,17 +1,34 @@
 # frozen_string_literal: true
 
+require 'fileutils'
 require_relative '../config'
 require_relative '../worktree_manager'
 
 module Ocak
   module Commands
     class Clean < Dry::CLI::Command
-      desc 'Remove stale worktrees and prune git worktree list'
+      desc 'Remove stale worktrees, logs, and reports'
 
-      def call(**)
+      option :logs, type: :boolean, default: false, desc: 'Clean log files, state files, and reports'
+      option :all, type: :boolean, default: false, desc: 'Clean worktrees and logs'
+      option :keep, type: :integer, desc: 'Only remove artifacts older than N days'
+
+      def call(**options)
         config = Config.load
-        manager = WorktreeManager.new(config: config)
+        do_worktrees = !options[:logs] || options[:all]
+        do_logs = options[:logs] || options[:all]
+
+        clean_worktrees(config) if do_worktrees
+        clean_logs(config, keep_days: options[:keep]) if do_logs
+      rescue Config::ConfigNotFound => e
+        warn "Error: #{e.message}"
+        exit 1
+      end
+
+      private
 
+      def clean_worktrees(config)
+        manager = WorktreeManager.new(config: config)
         puts 'Cleaning stale worktrees...'
         removed = manager.clean_stale
 
@@ -21,9 +38,53 @@ module Ocak
           removed.each { |path| puts "  Removed: #{path}" }
           puts "Cleaned #{removed.size} worktree(s)."
         end
-      rescue Config::ConfigNotFound => e
-        warn "Error: #{e.message}"
-        exit 1
+      end
+
+      def clean_logs(config, keep_days:)
+        cutoff = keep_days ? Time.now - (keep_days * 86_400) : nil
+        puts keep_days ? "Cleaning logs older than #{keep_days} days..." : 'Cleaning logs...'
+
+        log_dir = File.join(config.project_dir, config.log_dir)
+        reports_dir = File.join(config.project_dir, '.ocak', 'reports')
+
+        artifacts = collect_artifacts(log_dir, reports_dir)
+        removed = remove_artifacts(artifacts, cutoff)
+
+        if removed.empty?
+          puts 'No artifacts to clean.'
+        else
+          puts "Cleaned #{removed.size} artifact(s)."
+        end
+      end
+
+      def collect_artifacts(log_dir, reports_dir)
+        artifacts = []
+
+        if Dir.exist?(log_dir)
+          artifacts += Dir.glob(File.join(log_dir, '*.log'))
+          artifacts += Dir.glob(File.join(log_dir, 'issue-*-state.json'))
+          artifacts += Dir.glob(File.join(log_dir, 'issue-*/')).select { |f| File.directory?(f) }
+        end
+
+        artifacts += Dir.glob(File.join(reports_dir, '*.json')) if Dir.exist?(reports_dir)
+
+        artifacts
+      end
+
+      def remove_artifacts(artifacts, cutoff)
+        removed = []
+        artifacts.each do |path|
+          next if cutoff && File.mtime(path) >= cutoff
+
+          if File.directory?(path)
+            FileUtils.rm_rf(path)
+          else
+            FileUtils.rm_f(path)
+          end
+          puts "  Removed: #{path}"
+          removed << path
+        end
+        removed
       end
     end
   end

data/lib/ocak/commands/design.rb

@@ -15,18 +15,10 @@ module Ocak
           exit 1
         end
 
-        puts 'Starting interactive design session...'
-        puts 'This will open Claude Code with the /design skill.'
-        puts ''
-
         if description
           exec('claude', '--skill', skill_path, '--', description)
         else
-          puts 'Run this inside Claude Code:'
-          puts '  /design <description of what you want to build>'
-          puts ''
-          puts 'Or provide a description directly:'
-          puts '  ocak design "add user authentication with OAuth"'
+          exec('claude', '--skill', skill_path)
         end
       end
     end