oh-my-customcode 0.9.2 → 0.9.4

package/templates/.claude/rules/MUST-continuous-improvement.md

@@ -1,132 +1,25 @@
 # [MUST] Continuous Improvement Rules
 
-> **Priority**: MUST - Top-level enforcement
-> **ID**: R016
-> **Trigger**: User points out rule violation
+> **Priority**: MUST | **ID**: R016 | **Trigger**: User points out rule violation
 
-## CRITICAL
+## Core Rule
 
-**When user points out a rule violation, you MUST update the rules to prevent future violations BEFORE continuing with the task.**
+When user points out a violation: STOP → UPDATE the relevant rule → COMMIT → THEN continue original task.
 
-```
-╔══════════════════════════════════════════════════════════════════╗
-║  WHEN USER POINTS OUT A VIOLATION:                               ║
-║                                                                   ║
-║  1. STOP current task immediately                                ║
-║  2. UPDATE the relevant rule to be clearer/stronger              ║
-║  3. COMMIT the rule update                                       ║
-║  4. THEN continue with the original task                         ║
-║                                                                   ║
-║  DO NOT just apologize and continue.                             ║
-║  DO NOT promise to do better next time.                          ║
-║  ACTUALLY UPDATE THE RULES.                                      ║
-╚══════════════════════════════════════════════════════════════════╝
-```
+Do NOT just apologize. ACTUALLY UPDATE THE RULES.
 
 ## Workflow
 
-```
-User points out violation
-         │
-         ▼
-┌─────────────────────────┐
-│ 1. Acknowledge violation │
-└───────────┬─────────────┘
-            │
-            ▼
-┌─────────────────────────┐
-│ 2. Identify root cause   │
-│    - Which rule was weak?│
-│    - What was unclear?   │
-└───────────┬─────────────┘
-            │
-            ▼
-┌─────────────────────────┐
-│ 3. Update the rule       │
-│    - Add clarity         │
-│    - Add examples        │
-│    - Add self-checks     │
-└───────────┬─────────────┘
-            │
-            ▼
-┌─────────────────────────┐
-│ 4. Commit the change     │
-└───────────┬─────────────┘
-            │
-            ▼
-┌─────────────────────────┐
-│ 5. Continue original task│
-│    (now following rules) │
-└─────────────────────────┘
-```
+1. Acknowledge violation
+2. Identify root cause (which rule was weak/unclear?)
+3. Update the rule (add clarity, examples, self-checks)
+4. Commit the change
+5. Continue original task following updated rules
 
-## Examples
-
-### Example 1: Parallel Execution Violation
-
-```
-User: "병렬 실행을 안 지킨거 아닌가?"
-
-WRONG Response:
-  "맞습니다, 죄송합니다. 다음부터 잘 지키겠습니다."
-  [continues task without updating rules]
-
-CORRECT Response:
-  1. "맞습니다. R009 위반입니다."
-  2. [Updates MUST-parallel-execution.md with clearer guidance]
-  3. [Commits the update]
-  4. [Continues task with proper parallel execution]
-```
-
-### Example 2: Wrong Agent Used
-
-```
-User: "mgr-creator 에이전트를 써야 하는거 아닌가?"
-
-WRONG Response:
-  "맞습니다. mgr-creator를 사용하겠습니다."
-  [continues without updating rules]
-
-CORRECT Response:
-  1. "맞습니다. R010 위반입니다."
-  2. [Updates relevant rules to clarify agent delegation]
-  3. [Commits the update]
-  4. [Continues with proper agent delegation]
-```
-
-## Why This Matters
-
-```
-Without rule updates:
-  Violation → Apology → Same mistake later → Apology → ...
-
-With rule updates:
-  Violation → Rule improvement → Better behavior → Learning preserved
-```
-
-1. **Institutional Memory**: Rules capture learnings permanently
-2. **Prevents Recurrence**: Clearer rules = fewer future violations
-3. **Continuous Improvement**: System gets better over time
-4. **Accountability**: Actions, not just words
-
-## Integration with Other Rules
-
-This rule takes precedence when violations are pointed out:
+## Integration
 
 | Situation | Action |
 |-----------|--------|
 | User points out violation | STOP → Update rule → Continue |
 | Self-detected violation | Fix immediately, consider rule update |
 | Ambiguous situation | Ask user, then update if needed |
-
-## Enforcement
-
-```
-Violation of this rule = Ignoring user feedback = Unacceptable
-
-When caught violating this rule:
-1. Stop immediately
-2. Update THIS rule to be even clearer
-3. Update the ORIGINAL violated rule
-4. Continue with proper behavior
-```

package/templates/.claude/rules/MUST-intent-transparency.md

@@ -1,15 +1,12 @@
 # [MUST] Intent Transparency Rules
 
-> **Priority**: MUST - Required for user control
-> **ID**: R015
+> **Priority**: MUST | **ID**: R015
 
-## Purpose
+## Core Rule
 
-Ensure transparency when automatically detecting user intent and routing to agents. Users should always understand why a specific agent was chosen.
+Display reasoning when routing to agents. Users must always know which agent was selected, why, and how to override.
 
-## Detection Display (REQUIRED)
-
-When intent is detected, display the reasoning:
+## Display Format
 
 ```
 [Intent Detected]
@@ -24,176 +21,22 @@ When intent is detected, display the reasoning:
 | Confidence | Action |
 |------------|--------|
 | >= 90% | Auto-execute with display |
-| 70-89% | Request confirmation |
+| 70-89% | Request confirmation, show alternatives |
 | < 70% | List options for user to choose |
 
 ## Detection Factors
 
-Intent is detected using multiple factors:
-
-```yaml
-factors:
-  keywords:
-    weight: 40
-    description: Language-specific keywords in input
-    example: "Go", "Python", "리뷰", "생성"
-
-  file_patterns:
-    weight: 30
-    description: File extensions mentioned or in context
-    example: "*.go", "main.py"
-
-  action_verbs:
-    weight: 20
-    description: Action words in user input
-    example: "review", "create", "fix", "리뷰", "생성"
-
-  context:
-    weight: 10
-    description: Recent conversation context
-    example: Previous agent used, current working directory
-```
-
-## High Confidence Display (>= 90%)
-
-```
-[Intent Detected]
-├── Input: "Go 코드 리뷰해줘"
-├── Agent: lang-golang-expert
-├── Confidence: 95%
-└── Reason: "Go" keyword (40%) + "리뷰" action verb (55%)
-
-Executing...
-```
-
-## Medium Confidence Display (70-89%)
-
-```
-[Intent Detected]
-├── Input: "백엔드 코드 체크해줘"
-├── Agent: be-go-backend-expert (?)
-├── Confidence: 75%
-└── Reason: "백엔드" keyword (40%) + "체크" action (35%)
-
-Possible alternatives:
-  1. be-go-backend-expert (75%)
-  2. be-fastapi-expert (65%)
-  3. be-springboot-expert (60%)
-
-Proceed with be-go-backend-expert? [Y/n/1-3]
-```
-
-## Low Confidence Display (< 70%)
-
-```
-[Intent Unclear]
-├── Input: "이 코드 좀 봐줘"
-├── Confidence: < 70%
-└── Need more context
-
-Available agents for code review:
-  1. lang-golang-expert (Go files)
-  2. lang-python-expert (Python files)
-  3. lang-typescript-expert (TypeScript files)
-  4. lang-rust-expert (Rust files)
-
-Which agent should review the code? [1-4]
-```
-
-## Override Syntax
+| Factor | Weight | Examples |
+|--------|--------|---------|
+| Keywords | 40% | "Go", "Python", "리뷰" |
+| File patterns | 30% | "*.go", "main.py" |
+| Action verbs | 20% | "review", "create", "fix" |
+| Context | 10% | Previous agent, working directory |
 
-Users can explicitly specify an agent:
+## Override
 
-```
-@{agent-name} {command}
-```
-
-Examples:
-```
-@lang-golang-expert review this code
-@lang-python-expert src/main.py 분석해줘
-@secretary create a new agent
-```
-
-Override bypasses intent detection:
-
-```
-[Override] Agent explicitly specified: lang-python-expert
-Executing...
-```
-
-## Implementation
-
-### Secretary Workflow
-
-```
-1. Receive user input
-2. Check for explicit override (@agent)
-3. If no override:
-   a. Extract keywords, file patterns, action verbs
-   b. Match against agent triggers
-   c. Calculate confidence score
-   d. Display detection reasoning
-   e. Execute or request confirmation based on threshold
-4. Route to selected agent
-```
-
-### Detection Log
-
-For debugging and transparency:
-
-```yaml
-detection_log:
-  input: "Go 코드 리뷰해줘"
-  extracted:
-    keywords: ["Go"]
-    file_patterns: []
-    action_verbs: ["리뷰"]
-  matches:
-    - agent: lang-golang-expert
-      score: 95
-      breakdown:
-        keyword_go: 40
-        action_review: 40
-        context: 15
-  selected: lang-golang-expert
-  confidence: 95%
-```
+Users can specify agent directly with `@{agent-name} {command}`. Override bypasses detection.
 
 ## Agent Triggers
 
-Each agent has defined triggers in:
-`.claude/skills/intent-detection/patterns/agent-triggers.yaml`
-
-```yaml
-agents:
-  lang-golang-expert:
-    keywords: [go, golang, "go 언어"]
-    file_patterns: ["*.go", "go.mod", "go.sum"]
-    actions: [review, analyze, fix, optimize]
-    base_confidence: 40
-
-  lang-python-expert:
-    keywords: [python, py, "파이썬"]
-    file_patterns: ["*.py", "requirements.txt", "pyproject.toml"]
-    actions: [review, analyze, fix, optimize]
-    base_confidence: 40
-```
-
-## Benefits
-
-1. **Transparency**: Users understand agent selection
-2. **Control**: Users can override or choose alternatives
-3. **Trust**: Clear reasoning builds user confidence
-4. **Learning**: Users learn which agents handle what
-5. **Debugging**: Clear logs for troubleshooting
-
-## Violations
-
-Proceeding without displaying intent reasoning = Rule violation
-
-The user must always know:
-- Which agent was selected
-- Why it was selected
-- What confidence level
-- How to override if needed
+Defined in `.claude/skills/intent-detection/patterns/agent-triggers.yaml`. Each agent has keywords, file patterns, actions, and base confidence.

package/templates/.claude/rules/MUST-language-policy.md

@@ -1,55 +1,21 @@
 # [MUST] Language & Delegation Policy
 
-> **Priority**: MUST - Never violate
-> **ID**: R000
+> **Priority**: MUST | **ID**: R000
 
-## Core Principles
+## Output Language
 
-### 1. User Input Language
-```
-User prompts are in Korean.
-Always understand and process Korean input.
-```
-
-### 2. Output Language
-
-| Context | Language | Example |
-|---------|----------|---------|
-| User communication | Korean | 상태 보고, 질문, 설명 |
-| Code | English | variables, functions, comments |
-| File contents | English | .md, .yaml, configs |
-| Commit messages | English | git commits |
-| Error messages to user | Korean | 에러 설명, 해결 방안 |
+| Context | Language |
+|---------|----------|
+| User communication | Korean |
+| Code, file contents, commits | English |
+| Error messages to user | Korean |
 
-### 3. Delegation Model
-```
-User does NOT directly edit files.
-User delegates ALL file operations to AI agent.
-
-User → (Korean prompt) → Agent → (file operations)
-```
+## Delegation Model
 
-### 4. Context Efficiency
-```
-All file contents in English for:
-- Token efficiency
-- Consistent parsing
-- Universal compatibility
-```
-
-## Examples
-
-### Correct
-```
-User: "새로운 에이전트를 만들어줘"
-Agent: "에이전트를 생성하겠습니다." (Korean to user)
-Agent writes AGENT.md in English
-```
+User delegates ALL file operations to AI agent. User does NOT directly edit files.
 
-### Incorrect
 ```
-Agent writes: "# 에이전트 이름" in file  ← Wrong
-Agent writes: "# Agent Name" in file     ← Correct
+User -> (Korean prompt) -> Agent -> (file operations in English)
 ```
 
 ## File Naming
@@ -57,6 +23,5 @@ Agent writes: "# Agent Name" in file     ← Correct
 | Type | Convention | Example |
 |------|------------|---------|
 | Rules | `{PRIORITY}-{name}.md` | `MUST-safety.md` |
-| Agents | `AGENT.md` | - |
+| Agents | `{name}.md` (kebab-case) | `lang-golang-expert.md` |
 | Skills | `SKILL.md` | - |
-| Index | `index.yaml` | - |