oh-my-customcode 0.1.4 → 0.2.0

package/templates/{commands/pipeline/list.md → .claude/skills/pipeline-list/SKILL.md}

@@ -1,13 +1,12 @@
-# Command: pipeline:list
-
-> List all available pipelines
+---
+name: pipeline-list
+description: List all available pipelines
+argument-hint: "[--verbose] [--templates]"
+---
 
-## Usage
+# Pipeline List Skill
 
-```
-pipeline:list
-pipeline:list --verbose
-```
+List all available pipelines with optional detailed information.
 
 ## Options
 
@@ -16,10 +15,9 @@ pipeline:list --verbose
 --templates      Include templates in list
 ```
 
-## Output
+## Output Format
 
 ### Standard
-
 ```
 [pipeline:list]
 
@@ -40,7 +38,6 @@ Use "pipeline:list --verbose" for detailed info.
 ```
 
 ### Verbose
-
 ```
 [pipeline:list --verbose]
 
@@ -59,7 +56,7 @@ Steps:
   1. detect_language → secretary
   2. analyze → ${language}-expert
   3. security_check → qa-lead
-  4. report → documenter
+  4. report → arch-documenter
 
 ---
 
@@ -72,10 +69,6 @@ Location: pipelines/templates/pipeline-template.yaml
 Use as starting point for new pipelines.
 ```
 
-## Agent
-
-Executed by: **secretary** (orchestrator)
-
-## Related Commands
+## Related
 
-- `pipeline:run` - Execute a pipeline
+- pipeline-run - Execute a pipeline

package/templates/{commands/pipeline/run.md → .claude/skills/pipeline-run/SKILL.md}

@@ -1,14 +1,13 @@
-# Command: pipeline:run
+---
+name: pipeline-run
+description: Execute a defined pipeline with sequential steps
+argument-hint: "<pipeline-name> [--input key=value]"
+disable-model-invocation: true
+---
 
-> Execute a defined pipeline
+# Pipeline Execution Skill
 
-## Usage
-
-```
-pipeline:run <pipeline-name>
-pipeline:run <pipeline-name> --input key=value
-pipeline:run code-review --input file_path=src/main.go
-```
+Execute a defined pipeline with sequential steps, passing outputs between steps.
 
 ## Parameters
 
@@ -36,10 +35,34 @@ pipeline:run code-review --input file_path=src/main.go
 6. Report final results
 ```
 
-## Output
+## Pipeline Definition Format
+
+```yaml
+name: pipeline-name
+description: What this pipeline does
+
+inputs:
+  - name: input_name
+    required: true
+    description: Input description
+
+steps:
+  - id: step_1
+    agent: agent-name
+    action: action_name
+    input: { key: "${input_name}" }
+    output: result_variable
+
+  - id: step_2
+    agent: another-agent
+    action: action_name
+    input: { data: "${result_variable}" }
+    output: final_result
+```
 
-### Normal Execution
+## Output Format
 
+### Normal Execution
 ```
 [pipeline:run code-review --input file_path=src/main.go]
 
@@ -63,7 +86,7 @@ pipeline:run code-review --input file_path=src/main.go
       Status: ✓ No vulnerabilities
 
 [4/4] report
-      Agent: documenter
+      Agent: arch-documenter
       Status: ✓ Report generated
 
 [Complete] Pipeline finished successfully
@@ -76,7 +99,6 @@ Results:
 ```
 
 ### Dry Run
-
 ```
 [pipeline:run code-review --dry-run --input file_path=src/main.go]
 
@@ -95,7 +117,7 @@ Steps to execute:
 │       Input: { file: "src/main.go", findings: ${analysis} }
 │       Output: → security
 
-└── [4] report → documenter.generate_report
+└── [4] report → arch-documenter.generate_report
         Input: { file, language, analysis, security }
         Output: → report
 
@@ -103,7 +125,6 @@ No changes made (dry run).
 ```
 
 ### Error
-
 ```
 [pipeline:run code-review --input file_path=missing.go]
 
@@ -117,11 +138,6 @@ Error at step 1: detect_language
 Pipeline aborted. No partial results.
 ```
 
-## Agent
-
-Executed by: **secretary** (orchestrator) using **pipeline-execution** skill
-
-## Related Commands
+## Related
 
-- `pipeline:list` - List available pipelines
-- `pipeline:status` - Show running pipeline status
+- pipeline-list - List available pipelines

package/templates/{agents/sw-engineer/language/python-expert/refs → .claude/skills}/python-best-practices/SKILL.md

@@ -1,7 +1,7 @@
-# Python Best Practices Skill
-
-> **Category**: Development
-> **Source**: Internal (based on PEP 8 and PEP 20)
+---
+name: python-best-practices
+description: Pythonic patterns from PEP 8 and PEP 20
+---
 
 ## Purpose
 

package/templates/.claude/skills/qa-lead-routing/SKILL.md

@@ -0,0 +1,277 @@
+---
+name: qa-lead-routing
+description: Coordinates QA workflow across planning, writing, and execution agents. Use when user requests testing, quality assurance, or test documentation.
+user-invocable: false
+---
+
+# QA Lead Routing Skill
+
+## Purpose
+
+Coordinates QA team activities by routing tasks to qa-planner, qa-writer, and qa-engineer agents. This skill contains the coordination logic for orchestrating the complete quality assurance workflow.
+
+## QA Team Agents
+
+| Agent | Role | Output |
+|-------|------|--------|
+| qa-planner | Test planning | QA plans, test scenarios, acceptance criteria |
+| qa-writer | Documentation | Test cases, test reports, templates |
+| qa-engineer | Execution | Test results, defect reports, coverage reports |
+
+## Command Routing
+
+```
+QA Request → Routing → QA Agent(s)
+
+test_planning      → qa-planner
+test_documentation → qa-writer
+test_execution     → qa-engineer
+quality_analysis   → qa-planner + qa-engineer (parallel)
+full_qa_cycle      → all agents (sequential)
+```
+
+## Routing Rules
+
+### 1. Test Planning
+
+```
+User: "Create test plan for feature X"
+
+Route:
+  Task(qa-planner role → create test plan, model: "sonnet")
+
+Output:
+  - Test scenarios
+  - Coverage targets
+  - Acceptance criteria
+  - Risk assessment
+```
+
+### 2. Test Documentation
+
+```
+User: "Document test cases for API"
+
+Route:
+  Task(qa-writer role → document test cases, model: "sonnet")
+
+Output:
+  - Test case specifications
+  - Test data requirements
+  - Expected results
+  - Test templates
+```
+
+### 3. Test Execution
+
+```
+User: "Execute tests for module Y"
+
+Route:
+  Task(qa-engineer role → execute tests, model: "sonnet")
+
+Output:
+  - Test execution results
+  - Pass/fail metrics
+  - Defect reports
+  - Coverage reports
+```
+
+### 4. Quality Analysis
+
+When analysis is needed (parallel execution):
+
+```
+User: "Analyze quality metrics"
+
+Route (parallel):
+  Task(qa-planner role → analyze strategy, model: "sonnet")
+  Task(qa-engineer role → analyze results, model: "sonnet")
+
+Aggregate:
+  Strategy insights + execution data
+```
+
+### 5. Full QA Cycle (Sequential)
+
+For complete quality assurance workflow:
+
+```
+User: "Run full QA cycle for feature Z"
+
+Route (sequential):
+  1. Task(qa-planner role → create test plan, model: "sonnet")
+  2. Task(qa-writer role → document test cases, model: "sonnet")
+  3. Task(qa-engineer role → execute tests, model: "sonnet")
+  4. Task(qa-writer role → generate report, model: "sonnet")
+
+Aggregate and present final report
+```
+
+## Full QA Cycle Workflow
+
+```
+1. Planning Phase (qa-planner)
+   - Analyze requirements
+   - Define test scenarios
+   - Set acceptance criteria
+   - Identify risks
+
+2. Documentation Phase (qa-writer)
+   - Write test cases
+   - Define test data
+   - Document expected results
+   - Create templates
+
+3. Execution Phase (qa-engineer)
+   - Execute test cases
+   - Record results
+   - Report defects
+   - Calculate coverage
+
+4. Reporting Phase (qa-writer)
+   - Aggregate results
+   - Generate reports
+   - Document findings
+   - Provide recommendations
+
+5. Aggregation (qa-lead routing)
+   - Combine all phases
+   - Present unified status
+   - Highlight critical issues
+```
+
+## Sequential vs Parallel Execution
+
+### Sequential (typical for QA workflow)
+
+QA workflow is typically sequential because each phase depends on the previous:
+- Planning must complete before documentation
+- Documentation must complete before execution
+- Execution must complete before reporting
+
+```
+qa-planner → qa-writer → qa-engineer → qa-writer
+   (plan)    (document)    (execute)     (report)
+```
+
+### Parallel (rare, for independent analyses)
+
+Only when tasks are truly independent:
+- Quality analysis (strategy + results)
+- Multi-module testing (independent modules)
+
+```
+Example:
+  Task(qa-engineer role → test module A, model: "sonnet")
+  Task(qa-engineer role → test module B, model: "sonnet")
+  Task(qa-engineer role → test module C, model: "sonnet")
+```
+
+## Sub-agent Model Selection
+
+### Model Mapping
+
+| Agent | Recommended Model | Reason |
+|-------|-------------------|--------|
+| qa-planner | `sonnet` | Strategy requires balanced reasoning |
+| qa-writer | `sonnet` | Documentation quality matters |
+| qa-engineer | `sonnet` | Test execution needs accuracy |
+
+All QA agents typically use `sonnet` for balanced quality output.
+
+### Task Call Examples
+
+```
+# Test planning
+Task(
+  subagent_type: "general-purpose",
+  prompt: "Create comprehensive test plan for authentication feature following qa-planner guidelines",
+  model: "sonnet"
+)
+
+# Test documentation
+Task(
+  subagent_type: "general-purpose",
+  prompt: "Document test cases for API endpoints following qa-writer guidelines",
+  model: "sonnet"
+)
+
+# Test execution
+Task(
+  subagent_type: "general-purpose",
+  prompt: "Execute integration tests and report results following qa-engineer guidelines",
+  model: "sonnet"
+)
+```
+
+## Display Format
+
+### Full QA Cycle
+
+```
+[Planning] Delegating to qa-planner...
+  → Test plan created (15 scenarios)
+
+[Documentation] Delegating to qa-writer...
+  → 15 test cases documented
+
+[Execution] Delegating to qa-engineer...
+  → 13 passed, 2 failed
+
+[Report] Generating summary...
+  Coverage: 85%
+  Pass Rate: 87%
+  Defects: 2 (1 High, 1 Medium)
+
+[Done] QA cycle completed
+```
+
+### Parallel Quality Analysis
+
+```
+[Analyzing] Spawning parallel analysis...
+
+[Instance 1] strategy-analysis:sonnet → qa-planner
+[Instance 2] results-analysis:sonnet → qa-engineer
+
+[Progress] ████████████ 2/2
+
+[Summary]
+  Strategy: Coverage targets met, add edge cases
+  Results: 85% pass rate, 2 critical defects
+
+Analysis completed.
+```
+
+## Integration with Other Agents
+
+- **Receives requirements from**: arch-speckit-agent (sw-architect)
+- **Reports quality status to**: dev-lead
+- **Coordinates with**: Language experts for automated tests
+- **Provides feedback to**: Development team via dev-lead
+
+## Metrics Tracking
+
+QA lead routing should aggregate these metrics:
+
+```yaml
+metrics:
+  test_coverage: percentage
+  pass_rate: percentage
+  defect_count: number
+  defect_severity: [critical, high, medium, low]
+  execution_time: duration
+  test_case_count: number
+```
+
+## Usage
+
+This skill is NOT user-invocable. It should be automatically triggered when the main conversation detects QA intent.
+
+Detection criteria:
+- User requests testing
+- User mentions quality assurance
+- User asks for test plan/cases/execution
+- User requests QA metrics/reports
+- System detects need for quality verification

package/templates/{skills/development → .claude/skills}/react-best-practices/SKILL.md

@@ -1,7 +1,7 @@
-# React Best Practices
-
-> **Source**: vercel-labs/agent-skills
-> **Rules**: 40+ rules in 8 categories
+---
+name: react-best-practices
+description: React/Next.js performance optimization with 40+ rules in 8 categories
+---
 
 ## When to Use
 

package/templates/{skills/system → .claude/skills}/result-aggregation/SKILL.md

@@ -1,7 +1,7 @@
-# Result Aggregation Skill
-
-> **Category**: System
-> **Source**: Internal
+---
+name: result-aggregation
+description: Aggregate parallel agent results into concise output
+---
 
 ## Purpose
 
@@ -130,10 +130,10 @@ When ecomode active:
 ```
 [Batch Complete] 4/4
 
-├── golang-expert: ✓ src/main.go - 2 issues (1 naming, 1 error handling)
-├── python-expert: ✓ scripts/*.py - Clean
-├── rust-expert: ⚠ lib/core.rs - 1 unsafe block flagged
-└── typescript-expert: ✓ web/app.tsx - 3 suggestions
+├── lang-golang-expert: ✓ src/main.go - 2 issues (1 naming, 1 error handling)
+├── lang-python-expert: ✓ scripts/*.py - Clean
+├── lang-rust-expert: ⚠ lib/core.rs - 1 unsafe block flagged
+└── lang-typescript-expert: ✓ web/app.tsx - 3 suggestions
 ```
 
 ### Agent Creation Batch
@@ -141,10 +141,10 @@ When ecomode active:
 ```
 [Batch Complete] 3/4 (1 failed)
 
-✗ kotlin-expert: Skill not found: kotlin-best-practices
-✓ golang-expert: Agent created at agents/sw-engineer/golang-expert/
-✓ python-expert: Agent created at agents/sw-engineer/python-expert/
-✓ rust-expert: Agent created at agents/sw-engineer/rust-expert/
+✗ lang-kotlin-expert: Skill not found: kotlin-best-practices
+✓ lang-golang-expert: Agent created at .claude/agents/lang-golang-expert.md
+✓ lang-python-expert: Agent created at .claude/agents/lang-python-expert.md
+✓ lang-rust-expert: Agent created at .claude/agents/lang-rust-expert.md
 ```
 
 ### Audit Batch
@@ -153,11 +153,11 @@ When ecomode active:
 [Batch Complete] 5/5
 
 Agents Audited:
-├── creator: ✓ All refs valid
-├── updater: ✓ All refs valid
-├── supplier: ⚠ 1 deprecated ref
-├── golang-expert: ✓ All refs valid
-└── python-expert: ✓ All refs valid
+├── mgr-creator: ✓ All refs valid
+├── mgr-updater: ✓ All refs valid
+├── mgr-supplier: ⚠ 1 deprecated ref
+├── lang-golang-expert: ✓ All refs valid
+└── lang-python-expert: ✓ All refs valid
 
 Summary: 5 agents checked, 1 warning
 ```

package/templates/{agents/sw-engineer/language/rust-expert/refs → .claude/skills}/rust-best-practices/SKILL.md

@@ -1,7 +1,7 @@
-# Rust Best Practices Skill
-
-> **Category**: Development
-> **Source**: Internal (based on Rust API Guidelines and The Book)
+---
+name: rust-best-practices
+description: Idiomatic Rust patterns from official guidelines
+---
 
 ## Purpose
 

package/templates/.claude/skills/sauron-watch/SKILL.md

@@ -0,0 +1,144 @@
+---
+name: sauron-watch
+description: Full R017 verification (5+3 rounds) before commit
+disable-model-invocation: true
+---
+
+# Sauron Watch Skill
+
+Execute full R017 verification process with 5 rounds of manager agent verification and 3 rounds of deep review.
+
+## Purpose
+
+Ensure complete synchronization of agents, commands, documentation, and project structure before committing changes.
+
+## Workflow
+
+### Phase 1: Manager Agent Verification (5 rounds)
+
+#### Round 1-2: Basic Sync
+```
+□ /audit-agents - Check all agent dependencies
+□ /sync-check - Verify registry synchronization
+□ Fix any issues found
+```
+
+#### Round 3-4: Deep Sync
+```
+□ /audit-agents - Re-verify after fixes
+□ /sync-check - Re-verify registries
+□ /update-docs - Check documentation sync
+□ Fix any remaining issues
+```
+
+#### Round 5: Final Verification
+```
+□ All agent counts match (CLAUDE.md, index.yaml, actual files)
+□ All symlinks valid
+□ All command registries updated
+□ All intent-detection triggers present
+```
+
+### Phase 2: Deep Review (3 rounds)
+
+#### Deep Round 1: Workflow Alignment
+```
+□ Agent creation workflow documented and functional
+□ Development workflow uses proper orchestrators
+□ Deployment workflow defined (if applicable)
+□ All orchestrators have complete `manages:` sections
+```
+
+#### Deep Round 2: Reference Verification
+```
+□ All orchestrators properly reference their managed agents
+□ All rules are properly referenced
+□ No orphaned agents (not managed by any orchestrator)
+□ No circular references
+```
+
+#### Deep Round 3: Philosophy Compliance
+```
+□ R006: Separation of concerns (AGENT.md = role only, no details)
+□ R009: Parallel execution enabled for orchestrators
+□ R010: Multi-agent tasks use orchestrators
+□ R007/R008: Agent/tool identification documented
+□ All MUST rules enforced, SHOULD rules recommended
+```
+
+### Phase 3: Fix Issues
+```
+□ All issues from Phase 1 fixed
+□ All issues from Phase 2 fixed
+□ Re-run verification if major fixes made
+```
+
+### Phase 4: Commit Ready
+```
+□ All verification passed
+□ Ready to delegate to mgr-gitnerd for commit
+```
+
+## Output Format
+
+```
+[mgr-sauron:watch]
+
+Starting full R017 verification...
+
+═══════════════════════════════════════════════════════════
+ PHASE 1: Manager Agent Verification (5 rounds)
+═══════════════════════════════════════════════════════════
+
+[Round 1/5] Basic sync - /audit-agents
+  ✓ All agents have valid dependencies
+
+[Round 2/5] Basic sync - /sync-check
+  ✓ All registries synchronized
+
+[Round 3/5] Deep sync - /audit-agents
+  ✓ Dependencies verified after fixes
+
+[Round 4/5] Deep sync - /sync-check + /update-docs
+  ✓ Registries verified
+  ✓ Documentation synchronized
+
+[Round 5/5] Final verification
+  ✓ Agent counts match across all sources
+  ✓ All symlinks valid
+  ✓ Command registries updated
+  ✓ Intent triggers present
+
+═══════════════════════════════════════════════════════════
+ PHASE 2: Deep Review (3 rounds)
+═══════════════════════════════════════════════════════════
+
+[Round 1/3] Workflow alignment
+  ✓ Agent creation workflow documented
+  ✓ Development workflow uses orchestrators
+  ✓ Orchestrators have complete manages sections
+
+[Round 2/3] Reference verification
+  ✓ All orchestrator references valid
+  ✓ All rules referenced
+  ✓ No orphaned agents
+
+[Round 3/3] Philosophy compliance
+  ✓ R006 separation enforced
+  ✓ R009 parallel execution enabled
+  ✓ R010 orchestrator coordination documented
+  ✓ R007/R008 identification rules present
+
+═══════════════════════════════════════════════════════════
+ VERIFICATION COMPLETE
+═══════════════════════════════════════════════════════════
+
+Status: ✓ ALL CHECKS PASSED
+
+Ready to commit. 커밋할까요?
+```
+
+## Related
+
+- R017: Sync Verification Rules
+- mgr-gitnerd: Git operations agent