oh-my-customcode 0.20.0 → 0.21.0

package/README.md

@@ -21,7 +21,7 @@ Like oh-my-zsh transformed shell customization, oh-my-customcode makes personali
 
 | Feature | Description |
 |---------|-------------|
-| **Batteries Included** | 41 agents, 55 skills, 22 guides, 18 rules, 2 hooks, 4 contexts, ontology graph - ready to use out of the box |
+| **Batteries Included** | 41 agents, 60 skills, 22 guides, 18 rules, 2 hooks, 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 |
@@ -124,20 +124,20 @@ Claude Code selects the appropriate model and parallelizes independent tasks (up
 | **QA** | 3 | qa-planner, qa-writer, qa-engineer |
 | **Total** | **41** | |
 
-### Skills (58)
+### Skills (60)
 
 | Category | Count | Skills |
 |----------|-------|--------|
 | **Routing** | 4 | secretary-routing, dev-lead-routing, de-lead-routing, qa-lead-routing |
 | **Best Practices** | 18 | go-best-practices, python-best-practices, typescript-best-practices, kotlin-best-practices, rust-best-practices, react-best-practices, fastapi-best-practices, springboot-best-practices, go-backend-best-practices, docker-best-practices, aws-best-practices, postgres-best-practices, supabase-postgres-best-practices, redis-best-practices, airflow-best-practices, dbt-best-practices, kafka-best-practices, snowflake-best-practices |
-| **Development** | 5 | dev-review, dev-refactor, create-agent, intent-detection, web-design-guidelines |
+| **Development** | 6 | dev-review, dev-refactor, create-agent, intent-detection, web-design-guidelines, analysis |
 | **Data Engineering** | 2 | spark-best-practices, pipeline-architecture-patterns |
 | **Optimization** | 3 | optimize-analyze, optimize-bundle, optimize-report |
 | **Memory** | 3 | memory-save, memory-recall, memory-management |
 | **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** | 4 | multi-model-verification, structured-dev-cycle, model-escalation, stuck-recovery |
+| **Quality & Workflow** | 6 | multi-model-verification, structured-dev-cycle, model-escalation, stuck-recovery, dag-orchestration, task-decomposition |
 | **Deploy** | 2 | vercel-deploy, codex-exec |
 | **External** | 1 | skills-sh-search |
 
@@ -225,7 +225,7 @@ your-project/
     │   ├── be-fastapi-expert.md
     │   ├── mgr-creator.md
     │   └── ...
-    ├── skills/            # Skill modules (55 directories, each with SKILL.md)
+    ├── skills/            # Skill modules (60 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.20.0",
+  "version": "0.21.0",
   "description": "Batteries-included agent harness for Claude Code",
   "type": "module",
   "bin": {

package/templates/.claude/skills/dag-orchestration/SKILL.md

@@ -0,0 +1,198 @@
+---
+name: dag-orchestration
+description: YAML-based DAG workflow engine with topological execution and failure strategies
+---
+
+# DAG Orchestration Skill
+
+Defines and executes directed acyclic graph (DAG) workflows. The orchestrator uses this skill to plan multi-step tasks with dependencies, execute them in topologically-sorted order, and handle failures.
+
+**Orchestrator-only** — only the main conversation uses this skill (R010). Subagents execute individual nodes.
+
+## Workflow Spec Format
+
+```yaml
+# .claude/workflows/<name>.yaml or inline in conversation
+workflow:
+  name: feature-implementation
+  description: Implement a new feature with tests and docs
+
+nodes:
+  - id: analyze
+    agent: Explore
+    model: haiku
+    prompt: "Analyze codebase for integration points"
+
+  - id: implement
+    agent: lang-typescript-expert
+    model: sonnet
+    prompt: "Implement the feature"
+    depends_on: [analyze]
+
+  - id: test
+    agent: qa-engineer
+    model: sonnet
+    prompt: "Write and run tests"
+    depends_on: [implement]
+
+  - id: review
+    agent: lang-typescript-expert
+    model: opus
+    prompt: "Code review"
+    depends_on: [implement]
+
+  - id: docs
+    agent: arch-documenter
+    model: sonnet
+    prompt: "Update documentation"
+    depends_on: [implement]
+
+  - id: commit
+    agent: mgr-gitnerd
+    model: sonnet
+    prompt: "Commit changes"
+    depends_on: [test, review, docs]
+
+config:
+  max_parallel: 4          # R009 limit
+  failure_strategy: stop   # stop | skip | retry
+  retry_count: 2           # Max retries per node (if strategy=retry)
+  timeout_per_node: 300    # Seconds per node (0 = no limit)
+```
+
+## Execution Algorithm — Kahn's Topological Sort
+
+```
+1. Parse workflow YAML
+2. Build adjacency list and in-degree map
+3. Validate: detect cycles (error if found)
+4. Initialize queue with nodes where in-degree = 0
+5. While queue is not empty:
+   a. Dequeue up to max_parallel nodes
+   b. Execute nodes in parallel via Task tool (R009)
+   c. On completion:
+      - Success → decrement in-degree of dependents
+      - Failure → apply failure_strategy
+   d. Enqueue newly-ready nodes (in-degree = 0)
+6. Verify all nodes executed (detect unreachable nodes)
+```
+
+## Execution Rules
+
+| Rule | Detail |
+|------|--------|
+| Max parallel | 4 concurrent nodes (R009) |
+| Agent Teams gate | 3+ parallel nodes → check R018 eligibility |
+| Orchestrator only | DAG scheduling runs in main conversation (R010) |
+| Node execution | Each node = one Task tool call to specified agent |
+| State tracking | `/tmp/.claude-dag-$PPID.json` |
+
+## Failure Strategies
+
+| Strategy | Behavior |
+|----------|----------|
+| `stop` | Halt entire DAG on first failure (default) |
+| `skip` | Mark failed node as skipped, continue dependents with warning |
+| `retry` | Retry failed node up to `retry_count` times, then stop |
+
+## State File Format
+
+```json
+{
+  "workflow": "feature-implementation",
+  "started_at": "2026-03-07T10:00:00Z",
+  "status": "running",
+  "nodes": {
+    "analyze": {"status": "completed", "started": "...", "completed": "..."},
+    "implement": {"status": "running", "started": "..."},
+    "test": {"status": "pending"},
+    "review": {"status": "pending"},
+    "docs": {"status": "pending"},
+    "commit": {"status": "blocked", "blocked_by": ["test", "review", "docs"]}
+  },
+  "execution_order": [["analyze"], ["implement"], ["test", "review", "docs"], ["commit"]]
+}
+```
+
+## Display Format
+
+```
+[DAG] feature-implementation — 6 nodes
+[Layer 0] analyze ← running
+[Layer 1] implement ← pending (depends: analyze)
+[Layer 2] test, review, docs ← pending (parallel, depends: implement)
+[Layer 3] commit ← blocked (depends: test, review, docs)
+```
+
+Progress:
+```
+[DAG Progress] 3/6 nodes completed
+  ✓ analyze (12s)
+  ✓ implement (45s)
+  → test (running)
+  → review (running)
+  → docs (running)
+  ○ commit (blocked)
+```
+
+## Common Workflow Templates
+
+### Feature Implementation
+```yaml
+nodes: [analyze → implement → [test, review, docs] → commit]
+```
+
+### Code Review + Fix
+```yaml
+nodes: [review → fix → re-review → commit]
+failure_strategy: retry
+```
+
+### Multi-Language Project
+```yaml
+nodes: [
+  analyze → [impl-frontend, impl-backend, impl-db] → integration-test → commit
+]
+```
+
+### Refactoring
+```yaml
+nodes: [
+  analyze → plan → [refactor-1, refactor-2, refactor-3] → test → review → commit
+]
+```
+
+## Integration
+
+| Rule | Integration |
+|------|-------------|
+| R009 | Max 4 parallel nodes; independent nodes MUST parallelize |
+| R010 | DAG scheduler runs only in orchestrator |
+| R015 | Display DAG plan before execution |
+| R018 | 3+ parallel nodes → check Agent Teams eligibility |
+| model-escalation | Node failures feed into task-outcome-recorder |
+| stuck-recovery | Repeated node failures trigger stuck detection |
+
+## Inline DAG
+
+For ad-hoc workflows without a YAML file:
+
+```
+[DAG Plan]
+1. analyze (Explore:haiku)
+2. implement (lang-typescript-expert:sonnet) ← depends: 1
+3. test (qa-engineer:sonnet) ← depends: 2
+4. review (lang-typescript-expert:opus) ← depends: 2
+5. commit (mgr-gitnerd:sonnet) ← depends: 3, 4
+
+Execute? [Y/n]
+```
+
+The orchestrator builds the DAG from this inline format and executes using the same algorithm.
+
+## Limitations
+
+- No cycles allowed (DAG = acyclic)
+- Max 20 nodes per workflow (complexity guard)
+- Nested DAGs not supported (flatten instead)
+- Cross-workflow dependencies not supported

package/templates/.claude/skills/task-decomposition/SKILL.md

@@ -0,0 +1,181 @@
+---
+name: task-decomposition
+description: Auto-decompose large tasks into DAG-compatible parallel subtasks
+---
+
+# Task Decomposition Skill
+
+Analyzes task complexity and decomposes large tasks into smaller, parallelizable subtasks compatible with the DAG orchestration skill. The orchestrator uses this as a planning frontend before execution.
+
+## Trigger Conditions
+
+Decomposition is **recommended** when any of these thresholds are met:
+
+| Trigger | Threshold | Rationale |
+|---------|-----------|-----------|
+| Estimated duration | > 30 minutes | Too long for single agent |
+| Files affected | > 3 files | Parallelizable across files |
+| Domains involved | > 2 domains | Requires multiple specialists |
+| Agent types needed | > 2 types | Cross-specialty coordination |
+
+## Decomposition Process
+
+```
+1. Analyze task scope
+   ├── Estimate duration, file count, domains
+   ├── Identify required agent types
+   └── Check trigger thresholds
+
+2. If thresholds met → decompose:
+   ├── Break into atomic subtasks (single agent, single concern)
+   ├── Identify dependencies between subtasks
+   ├── Map subtasks to agents (use routing skills)
+   └── Generate DAG workflow spec
+
+3. Present plan to user (R015 transparency)
+   ├── Show decomposed subtasks with agents
+   ├── Show dependency graph
+   ├── Show estimated parallel execution time
+   └── Request confirmation before execution
+
+4. Execute via dag-orchestration skill
+```
+
+## Decomposition Heuristics
+
+### By File Independence
+```
+Task: "Update auth module across 5 files"
+  ├── auth.ts → lang-typescript-expert
+  ├── middleware.ts → lang-typescript-expert
+  ├── config.ts → lang-typescript-expert (independent)
+  ├── auth.test.ts → qa-engineer (depends: auth.ts)
+  └── README.md → arch-documenter (depends: all above)
+
+DAG: [auth.ts, middleware.ts, config.ts] → auth.test.ts → README.md
+```
+
+### By Domain Separation
+```
+Task: "Add user profile feature with API and UI"
+  ├── API endpoint → be-express-expert
+  ├── Database schema → db-postgres-expert
+  ├── Frontend component → fe-vercel-agent
+  └── Integration test → qa-engineer
+
+DAG: [API, DB] → Frontend → Integration test
+     (API and DB are independent, Frontend needs both)
+```
+
+### By Layer
+```
+Task: "Implement order processing in Spring Boot"
+  ├── Domain model → lang-kotlin-expert
+  ├── Repository → be-springboot-expert (depends: domain)
+  ├── Service → be-springboot-expert (depends: domain, repository)
+  ├── Controller → be-springboot-expert (depends: service)
+  └── Tests → qa-engineer (depends: all)
+
+DAG: domain → [repository] → service → controller → tests
+```
+
+## Output Format
+
+### Decomposition Plan
+```
+[Task Decomposition]
+├── Original: "Add user authentication with JWT"
+├── Complexity: High (4 files, 3 domains, ~45 min)
+├── Decomposed into 5 subtasks:
+│
+│   [1] analyze (Explore:haiku)
+│       Scan codebase for existing auth patterns
+│
+│   [2] implement-auth (lang-typescript-expert:sonnet)
+│       Implement JWT signing and validation
+│       Depends: [1]
+│
+│   [3] implement-middleware (lang-typescript-expert:sonnet)
+│       Create auth middleware
+│       Depends: [1]
+│
+│   [4] write-tests (qa-engineer:sonnet)
+│       Write auth tests
+│       Depends: [2, 3]
+│
+│   [5] commit (mgr-gitnerd:sonnet)
+│       Commit all changes
+│       Depends: [4]
+│
+├── Parallel layers: 3 (max 2 concurrent in layer 2)
+├── Estimated time: ~20 min (vs ~45 min sequential)
+└── Proceed? [Y/n]
+```
+
+### Generated DAG Spec
+```yaml
+workflow:
+  name: auto-decomposed-auth
+  description: "Auto-decomposed: Add user authentication with JWT"
+
+nodes:
+  - id: analyze
+    agent: Explore
+    model: haiku
+    prompt: "Scan codebase for existing auth patterns"
+  - id: implement-auth
+    agent: lang-typescript-expert
+    model: sonnet
+    prompt: "Implement JWT signing and validation"
+    depends_on: [analyze]
+  - id: implement-middleware
+    agent: lang-typescript-expert
+    model: sonnet
+    prompt: "Create auth middleware"
+    depends_on: [analyze]
+  - id: write-tests
+    agent: qa-engineer
+    model: sonnet
+    prompt: "Write auth tests"
+    depends_on: [implement-auth, implement-middleware]
+  - id: commit
+    agent: mgr-gitnerd
+    model: sonnet
+    prompt: "Commit all changes"
+    depends_on: [write-tests]
+
+config:
+  max_parallel: 4
+  failure_strategy: stop
+```
+
+## Atomic Task Criteria
+
+A subtask is **atomic** when it meets ALL of:
+- Single agent can handle it
+- Single concern (one logical change)
+- Independently testable outcome
+- < 15 minutes estimated duration
+- < 3 files affected
+
+If a subtask is not atomic → decompose further (max 2 levels deep).
+
+## Skip Decomposition When
+
+| Condition | Reason |
+|-----------|--------|
+| Single file edit | Already atomic |
+| < 10 minutes estimated | Overhead not worth it |
+| User explicitly requests "just do it" | User override |
+| Single domain, single agent | No parallelization benefit |
+
+## Integration
+
+| Component | Integration |
+|-----------|-------------|
+| dag-orchestration | Generates DAG specs consumed by dag-orchestration |
+| Routing skills | Uses dev-lead/de-lead/qa-lead routing for agent mapping |
+| R009 | Maximizes parallelization within max-4 limit |
+| R010 | Decomposition happens in orchestrator only |
+| R015 | Plan displayed before execution for user approval |
+| R018 | 3+ agents in plan → check Agent Teams eligibility |

package/templates/manifest.json

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