oh-my-customcode 0.15.0 → 0.16.1

package/README.md

@@ -21,7 +21,7 @@ Like oh-my-zsh transformed shell customization, oh-my-customcode makes personali
 
 | Feature | Description |
 |---------|-------------|
-| **Batteries Included** | 42 agents, 53 skills, 22 guides, 18 rules, 1 hook, 4 contexts, ontology graph - ready to use out of the box |
+| **Batteries Included** | 42 agents, 55 skills, 22 guides, 18 rules, 1 hook, 4 contexts, ontology graph - ready to use out of the box |
 | **Sub-Agent Model** | Supports hierarchical agent orchestration with specialized roles |
 | **Dead Simple Customization** | Create a folder + markdown file = new agent or skill |
 | **Mix and Match** | Use built-in components, create your own, or combine both |
@@ -125,7 +125,7 @@ Claude Code selects the appropriate model and parallelizes independent tasks (up
 | **QA** | 3 | qa-planner, qa-writer, qa-engineer |
 | **Total** | **42** | |
 
-### Skills (53)
+### Skills (55)
 
 | Category | Count | Skills |
 |----------|-------|--------|
@@ -138,6 +138,7 @@ Claude Code selects the appropriate model and parallelizes independent tasks (up
 | **Package Management** | 3 | npm-publish, npm-version, npm-audit |
 | **Operations** | 7 | update-docs, update-external, audit-agents, fix-refs, sauron-watch, monitoring-setup, claude-code-bible |
 | **Utilities** | 5 | lists, help, status, result-aggregation, writing-clearly-and-concisely |
+| **Quality & Workflow** | 2 | multi-model-verification, structured-dev-cycle |
 | **Deploy** | 2 | vercel-deploy, codex-exec |
 | **External** | 1 | skills-sh-search |
 
@@ -225,7 +226,7 @@ your-project/
     │   ├── be-fastapi-expert.md
     │   ├── mgr-creator.md
     │   └── ...
-    ├── skills/            # Skill modules (53 directories, each with SKILL.md)
+    ├── skills/            # Skill modules (55 directories, each with SKILL.md)
     │   ├── go-best-practices/
     │   ├── react-best-practices/
     │   ├── secretary-routing/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-customcode",
-  "version": "0.15.0",
+  "version": "0.16.1",
   "description": "Batteries-included agent harness for Claude Code",
   "type": "module",
   "bin": {

package/templates/.claude/contexts/ecomode.md

@@ -61,3 +61,50 @@ Ecomode deactivates when:
 - User requests "verbose" or "full details"
 - Single task execution
 - Explicit "ecomode off"
+
+## Effort Level Integration
+
+Agent frontmatter `effort` field maps to runtime behavior:
+
+| Effort | Model Preference | Output Length | Detail Level | Token Budget |
+|--------|-----------------|---------------|--------------|--------------|
+| `low` | haiku | ≤100 tokens | Minimal — result only | Conservative |
+| `medium` | sonnet | ≤200 tokens | Summary + key details | Balanced |
+| `high` | opus | ≤500 tokens | Full reasoning + examples | Generous |
+
+### Effort ↔ Ecomode Interaction
+
+| Condition | Behavior |
+|-----------|----------|
+| Ecomode ON + effort: high | Ecomode wins — compress output regardless |
+| Ecomode OFF + effort: low | Low effort wins — concise output |
+| Ecomode OFF + effort: high | Full detailed output |
+| Ecomode ON + effort: low | Maximum compression |
+
+### Effort-Based Configuration
+
+```yaml
+effort_levels:
+  low:
+    result_format: minimal
+    max_result_length: 100
+    skip_intermediate_steps: true
+    output_style: concise
+  medium:
+    result_format: summary
+    max_result_length: 200
+    skip_intermediate_steps: false
+    output_style: balanced
+  high:
+    result_format: detailed
+    max_result_length: 500
+    skip_intermediate_steps: false
+    output_style: explanatory
+```
+
+### Application
+
+When spawning agents, the orchestrator should consider the agent's effort level:
+- `effort: low` agents → Assign to simple tasks (validation, search, formatting)
+- `effort: medium` agents → Assign to standard tasks (implementation, review)
+- `effort: high` agents → Assign to complex tasks (architecture, security, design)

package/templates/.claude/hooks/hooks.json

@@ -2,6 +2,16 @@
   "$schema": "https://json.schemastore.org/claude-code-settings.json",
   "hooks": {
     "PreToolUse": [
+      {
+        "matcher": "tool == \"Write\" || tool == \"Edit\"",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash .claude/hooks/scripts/stage-blocker.sh"
+          }
+        ],
+        "description": "Block Write/Edit tools during plan/verify/compound stages — only allow in implement stage"
+      },
       {
         "matcher": "tool == \"Bash\" && tool_input.command matches \"(npm run dev|pnpm( run)? dev|yarn dev|bun run dev)\"",
         "hooks": [
@@ -27,7 +37,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "#!/bin/bash\necho '[Hook] Review changes before push...' >&2\necho '[Hook] Press Enter to continue with push or Ctrl+C to abort...' >&2\nread -r"
+            "command": "#!/bin/bash\necho '[Hook] Review changes before push...' >&2\nif [ -t 0 ]; then echo '[Hook] Press Enter to continue or Ctrl+C to abort...' >&2; read -r; else echo '[Hook] Non-interactive mode, proceeding...' >&2; fi"
           }
         ],
         "description": "Pause before git push to review changes"

package/templates/.claude/hooks/scripts/stage-blocker.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+# Stage-blocking hook: blocks Write/Edit in non-implement stages
+if [ -f /tmp/.claude-dev-stage ]; then
+  stage=$(cat /tmp/.claude-dev-stage | tr -d '[:space:]')
+  if [ -z "$stage" ]; then exit 0; fi
+  case "$stage" in
+    plan|verify-plan|verify-impl|compound|done)
+      echo "⛔ BLOCKED: Write/Edit disabled in '$stage' stage. Only allowed during 'implement' stage. Use 'echo implement > /tmp/.claude-dev-stage' to transition."
+      exit 2
+      ;;
+  esac
+fi

package/templates/.claude/rules/SHOULD-interaction.md

@@ -32,3 +32,44 @@
 - Dependent: Sequential
 - Independent: Parallel allowed
 - Report: `[Task 1/3] Done` / `[Task 2/3] In progress...` / `[Task 3/3] Pending`
+
+## Output Styles
+
+| Style | Trigger | Behavior |
+|-------|---------|----------|
+| `concise` | effort: low, batch operations | Key result only, no preamble, no elaboration |
+| `balanced` | effort: medium, general tasks | Summary + key details, minimal explanation |
+| `explanatory` | effort: high, complex/learning tasks | Full reasoning, examples, trade-off analysis |
+
+### Style Selection Priority
+
+1. User explicit request ("be concise", "explain in detail") → Override
+2. Ecomode active → Force `concise`
+3. Agent effort level → Map to corresponding style
+4. Default → `balanced`
+
+### Style Examples
+
+**Concise** (effort: low):
+```
+✓ 3 files updated, 0 errors
+```
+
+**Balanced** (effort: medium):
+```
+[Done] Updated authentication module
+- Modified: auth.ts, middleware.ts, config.ts
+- Added JWT validation with 24h expiry
+```
+
+**Explanatory** (effort: high):
+```
+[Done] Updated authentication module — Result: JWT-based auth with refresh tokens
+
+Changes:
+1. auth.ts:45 — Added JWT signing with RS256 algorithm (chosen over HS256 for key rotation support)
+2. middleware.ts:12 — New auth middleware validates token and attaches user context
+3. config.ts:8 — Added TOKEN_EXPIRY (24h) and REFRESH_EXPIRY (7d) constants
+
+Trade-offs: RS256 is ~10x slower than HS256 but enables asymmetric key management.
+```

package/templates/.claude/skills/multi-model-verification/SKILL.md

@@ -0,0 +1,129 @@
+---
+name: multi-model-verification
+description: Parallel code verification using multiple models with severity classification
+version: 1.0.0
+user_invocable: false
+---
+
+# Multi-Model Verification
+
+Parallel code verification using multiple AI models for comprehensive quality assurance. Each model focuses on a different aspect, and results are aggregated with severity classification.
+
+## Background
+
+Inspired by Pi Coding Agent Workflow Extension's multi-model verification pattern. Instead of a single reviewer, multiple models verify code simultaneously, each with specialized focus areas.
+
+## Verification Roles
+
+| Model | Role | Focus Areas |
+|-------|------|-------------|
+| `opus` | Architecture Reviewer | Design patterns, separation of concerns, extensibility, security architecture |
+| `sonnet` | Code Quality Reviewer | Logic correctness, error handling, edge cases, performance patterns |
+| `haiku` | Style & Convention Reviewer | Naming conventions, formatting, documentation, code organization |
+
+## Severity Classification
+
+| Severity | Description | Action Required |
+|----------|-------------|-----------------|
+| CRITICAL | Bugs, security vulnerabilities, data loss risks | Must fix before merge |
+| WARNING | Code smells, suboptimal patterns, missing error handling | Should fix, justify if skipped |
+| INFO | Style suggestions, minor improvements, alternative approaches | Optional improvement |
+
+## Workflow
+
+### Prerequisites
+- Agent Teams enabled (`CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`) for full parallel execution
+- Falls back to sequential Task tool execution if Agent Teams unavailable
+
+### Execution Flow
+
+1. **Input**: File path(s) or diff to verify
+2. **Spawn Parallel Reviewers**:
+   - `Task(opus)` → Architecture & design review
+   - `Task(sonnet)` → Code quality & correctness review
+   - `Task(haiku)` → Style & convention review
+3. **Collect Results**: Each reviewer returns findings with severity
+4. **Aggregate**: Merge and deduplicate findings
+5. **Report**: Unified report sorted by severity
+
+### Agent Teams Mode
+
+When Agent Teams is available, create a verification team:
+
+```
+TeamCreate("verification-team")
+├── architect-reviewer (opus) → Architecture review
+├── quality-reviewer (sonnet) → Code quality review
+└── style-reviewer (haiku) → Style review
+```
+
+Members communicate findings via SendMessage for cross-cutting concerns.
+
+### Task Tool Fallback
+
+When Agent Teams is unavailable, spawn parallel Task agents:
+
+```
+[1] Task(general-purpose):opus → Architecture review
+[2] Task(general-purpose):sonnet → Code quality review
+[3] Task(general-purpose):haiku → Style & convention review
+```
+
+## Output Format
+
+```
+## Multi-Model Verification Report
+
+### Summary
+- Files reviewed: {count}
+- Findings: {critical} CRITICAL, {warning} WARNING, {info} INFO
+- Reviewers: opus (architecture), sonnet (quality), haiku (style)
+
+### CRITICAL
+[opus] {file}:{line} — {description}
+[sonnet] {file}:{line} — {description}
+
+### WARNING
+[sonnet] {file}:{line} — {description}
+[haiku] {file}:{line} — {description}
+
+### INFO
+[haiku] {file}:{line} — {description}
+
+### Consensus
+Issues flagged by 2+ reviewers:
+- {file}:{line} — {description} (flagged by: opus, sonnet)
+```
+
+## Integration
+
+- Works with `dev-review` skill as an enhanced verification mode
+- Integrates with `structured-dev-cycle` skill at the "Verify Implementation" stage
+- Compatible with R009 (parallel execution) and R018 (Agent Teams) rules
+
+## Configuration
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `models` | `[opus, sonnet, haiku]` | Models to use for verification |
+| `severity_filter` | `all` | Minimum severity to report (`critical`, `warning`, `all`) |
+| `consensus_threshold` | `2` | Number of reviewers needed for consensus flag |
+| `include_suggestions` | `true` | Include INFO-level suggestions |
+
+## When to Use
+
+| Scenario | Recommended |
+|----------|-------------|
+| Pre-merge review of critical code | Yes |
+| Architecture changes | Yes |
+| Security-sensitive code | Yes |
+| Simple formatting changes | No (use single reviewer) |
+| Rapid prototyping | No (overhead too high) |
+
+## Cost Awareness
+
+Multi-model verification uses 3x the tokens of a single review. Reserve for:
+- Critical path code changes
+- Security-sensitive modifications
+- Architecture decisions
+- Pre-release verification

package/templates/.claude/skills/structured-dev-cycle/SKILL.md

@@ -0,0 +1,171 @@
+---
+name: structured-dev-cycle
+description: 6-stage structured development cycle with stage-based tool restrictions
+version: 1.0.0
+user_invocable: false
+---
+
+# Structured Development Cycle
+
+A disciplined 6-stage development cycle that enforces quality through stage-based tool restrictions. Prevents premature implementation by requiring planning and verification phases.
+
+## Background
+
+Inspired by Pi Coding Agent Workflow Extension's structured development approach. The core insight: restricting file modification tools during planning phases forces thorough analysis before code changes.
+
+## Stages
+
+| # | Stage | Allowed Tools | Blocked Tools | Purpose |
+|---|-------|---------------|---------------|---------|
+| 1 | **Plan** | Read, Glob, Grep, WebSearch, WebFetch | Write, Edit, Bash (modifying) | Define approach, analyze requirements |
+| 2 | **Verify Plan** | Read, Glob, Grep | Write, Edit, Bash | Review plan from different perspective |
+| 3 | **Implement** | All tools | None | Write code, create files |
+| 4 | **Verify Implementation** | Read, Glob, Grep, Bash (tests only) | Write, Edit | Review code, run tests |
+| 5 | **Compound** | Read, Bash (tests only) | Write, Edit | Integration testing, cross-module validation |
+| 6 | **Done** | Read | Write, Edit, Bash | Summary and documentation |
+
+## Stage Tracking
+
+Stage state is tracked via a marker file for hook enforcement:
+
+```bash
+# Set stage (used by orchestrator or skill)
+echo "plan" > /tmp/.claude-dev-stage
+
+# Valid stage values (all block Write/Edit except 'implement'):
+# plan, verify-plan, implement, verify-impl, compound, done
+
+# Clear stage (disable blocking)
+rm -f /tmp/.claude-dev-stage
+```
+
+A PreToolUse hook in `.claude/hooks/hooks.json` checks this marker and blocks Write/Edit tools during non-implementation stages.
+
+## Workflow
+
+### Stage 1: Plan
+```
+[Stage 1/6: Plan]
+├── Analyze requirements and constraints
+├── Read existing code for context
+├── Search for related patterns
+├── Define approach with rationale
+└── Output: Implementation plan document
+```
+
+**Exit criteria**: Clear plan with file list, approach description, and risk assessment.
+
+### Stage 2: Verify Plan
+```
+[Stage 2/6: Verify Plan]
+├── Review plan for completeness
+├── Check for missing edge cases
+├── Validate against existing patterns
+├── Consider alternative approaches
+└── Output: Plan approval or revision requests
+```
+
+**Exit criteria**: Plan verified by different perspective (ideally different model via multi-model-verification).
+
+### Stage 3: Implement
+```
+[Stage 3/6: Implement]
+├── Follow verified plan
+├── Create/modify files as specified
+├── Write tests alongside code
+├── Track deviations from plan
+└── Output: Implementation complete
+```
+
+**Exit criteria**: All planned files created/modified, tests written.
+
+### Stage 4: Verify Implementation
+```
+[Stage 4/6: Verify Implementation]
+├── Run test suite
+├── Review code quality
+├── Check for plan deviations
+├── Validate error handling
+└── Output: Verification report
+```
+
+**Exit criteria**: All tests pass, no critical issues found. If issues found, return to Stage 3.
+
+### Stage 5: Compound
+```
+[Stage 5/6: Compound]
+├── Run integration tests
+├── Cross-module validation
+├── Check for side effects
+├── Verify documentation accuracy
+└── Output: Integration report
+```
+
+**Exit criteria**: No integration issues. If issues found, return to Stage 3.
+
+### Stage 6: Done
+```
+[Stage 6/6: Done]
+├── Summarize changes made
+├── List files modified
+├── Note any deviations from plan
+├── Suggest follow-up tasks
+└── Output: Completion summary
+```
+
+## Integration
+
+### With EnterPlanMode
+Stage 1 (Plan) maps to Claude Code's `EnterPlanMode`. When the structured cycle is active:
+- EnterPlanMode triggers Stage 1
+- ExitPlanMode transitions to Stage 2 (Verify Plan), not directly to implementation
+
+### With Multi-Model Verification
+Stage 2 (Verify Plan) and Stage 4 (Verify Implementation) can invoke the `multi-model-verification` skill for comprehensive review.
+
+### With PreToolUse Hooks
+The stage marker file (`/tmp/.claude-dev-stage`) is read by a PreToolUse hook that enforces tool restrictions. This provides a safety net beyond instruction-based compliance.
+
+### With Agent Teams
+For complex tasks, each stage can be handled by specialized team members:
+- Plan: architect agent
+- Verify: reviewer agent(s)
+- Implement: domain expert agent
+- Compound: QA agent
+
+## When to Use
+
+| Task Complexity | Recommended Cycle |
+|----------------|-------------------|
+| Simple fix (< 3 files) | Skip — direct implementation |
+| Medium feature (3-10 files) | Stages 1, 3, 4, 6 (skip verify plan, compound) |
+| Complex feature (10+ files) | Full 6-stage cycle |
+| Architecture change | Full 6-stage cycle with multi-model verification |
+| Security-critical code | Full 6-stage cycle (mandatory) |
+
+## Stage Transition Commands
+
+```bash
+# Orchestrator manages transitions:
+echo "plan" > /tmp/.claude-dev-stage           # Enter planning
+echo "verify-plan" > /tmp/.claude-dev-stage     # Enter plan verification
+echo "implement" > /tmp/.claude-dev-stage       # Enter implementation
+echo "verify-impl" > /tmp/.claude-dev-stage     # Enter impl verification
+echo "compound" > /tmp/.claude-dev-stage        # Enter compound testing
+echo "done" > /tmp/.claude-dev-stage            # Mark done
+rm -f /tmp/.claude-dev-stage                    # Clear (disable blocking)
+```
+
+## Limitations
+
+- **Single session**: The fixed path `/tmp/.claude-dev-stage` does not support concurrent Claude Code sessions. Running multiple sessions simultaneously may cause stage state conflicts.
+- **World-writable path**: The `/tmp/` directory is accessible to all users. For multi-user environments, consider using a user-scoped path like `/tmp/.claude-dev-stage-$(id -u)`.
+
+## Display Format
+
+```
+═══ Structured Dev Cycle ═══════════════════════════
+ [■■□□□□] Stage 2/6: Verify Plan
+ Files planned: 5 | Risks identified: 2
+═════════════════════════════════════════════════════
+```

package/templates/CLAUDE.md.en

@@ -174,7 +174,7 @@ project/
 +-- CLAUDE.md                    # Entry point
 +-- .claude/
 |   +-- agents/                  # Subagent definitions (42 files)
-|   +-- skills/                  # Skills (52 directories)
+|   +-- skills/                  # Skills (55 directories)
 |   +-- rules/                   # Global rules (R000-R018)
 |   +-- hooks/                   # Hook scripts (memory, HUD)
 |   +-- contexts/                # Context files (ecomode)

package/templates/CLAUDE.md.ko

@@ -174,7 +174,7 @@ project/
 +-- CLAUDE.md                    # 진입점
 +-- .claude/
 |   +-- agents/                  # 서브에이전트 정의 (42 파일)
-|   +-- skills/                  # 스킬 (52 디렉토리)
+|   +-- skills/                  # 스킬 (55 디렉토리)
 |   +-- rules/                   # 전역 규칙 (R000-R018)
 |   +-- hooks/                   # 훅 스크립트 (메모리, HUD)
 |   +-- contexts/                # 컨텍스트 파일 (ecomode)

package/templates/manifest.json

@@ -18,7 +18,7 @@
       "name": "skills",
       "path": ".claude/skills",
       "description": "Reusable skill modules (includes slash commands)",
-      "files": 53
+      "files": 55
     },
     {
       "name": "guides",