oh-my-customcode 0.9.2 → 0.9.4

package/templates/.claude/rules/MUST-sync-verification.md

@@ -1,215 +1,38 @@
 # [MUST] Sync Verification Rules
 
-> **Priority**: MUST - ENFORCED after any structural changes
-> **ID**: R017
-> **Violation**: Committing or pushing without verification = Rule violation
+> **Priority**: MUST - ENFORCED | **ID**: R017
 
-## CRITICAL
+## Core Rule
 
-**After modifying agents, skills, or guides, you MUST run the full verification process before committing AND pushing.**
+After modifying agents, skills, or guides: run full verification before committing AND pushing. Never ask to commit/push before `mgr-sauron:watch` passes.
 
-```
-╔══════════════════════════════════════════════════════════════════╗
-║  ⚠️  ABSOLUTE PROHIBITION                                        ║
-║                                                                   ║
-║  DO NOT even ASK "커밋하시겠습니까?" or "푸시하시겠습니까?"      ║
-║  after structural changes until mgr-sauron:watch has been        ║
-║  executed and passed.                                            ║
-║                                                                   ║
-║  WRONG:                                                          ║
-║    [Make changes] → "커밋하시겠습니까?"                          ║
-║    [Commit done] → "푸시하시겠습니까?"                           ║
-║                                                                   ║
-║  CORRECT:                                                        ║
-║    [Make changes] → mgr-sauron:watch → [All pass] → commit → push ║
-║                                                                   ║
-║  Asking to commit/push before verification = Rule violation      ║
-╚══════════════════════════════════════════════════════════════════╝
-```
+Every `git push` requires: `mgr-sauron:watch` → all pass → `git push`
 
-```
-╔══════════════════════════════════════════════════════════════════╗
-║  ⚠️  PUSH REQUIRES SAURON VERIFICATION                           ║
-║                                                                   ║
-║  EVERY git push in this project MUST be preceded by:             ║
-║    mgr-sauron:watch → [All pass] → git push                      ║
-║                                                                   ║
-║  This applies to ALL pushes, not just structural changes.        ║
-║  Sauron verification is the quality gate for this repository.    ║
-║                                                                   ║
-║  NO EXCEPTIONS. NO SHORTCUTS.                                    ║
-╚══════════════════════════════════════════════════════════════════╝
-```
+## Verification Phases
 
-```
-╔══════════════════════════════════════════════════════════════════╗
-║  MANDATORY VERIFICATION PROCESS:                                 ║
-║                                                                   ║
-║  Phase 1: Manager Agent Verification (5 rounds)                  ║
-║    - mgr-supplier:audit                                          ║
-║    - mgr-sync-checker:check                                      ║
-║    - mgr-updater:docs                                            ║
-║    - mgr-claude-code-bible:verify                                ║
-║                                                                   ║
-║  Phase 2: Deep Review (3 rounds)                                 ║
-║    - Workflow alignment                                          ║
-║    - Reference verification                                      ║
-║    - Philosophy compliance                                       ║
-║                                                                   ║
-║  Phase 3: Fix all issues                                         ║
-║                                                                   ║
-║  Phase 4: Commit via mgr-gitnerd                                 ║
-║                                                                   ║
-║  Phase 5: Push via mgr-gitnerd                                   ║
-║    - ONLY after sauron verification passes                       ║
-║                                                                   ║
-║  Skipping ANY phase = Rule violation                             ║
-╚══════════════════════════════════════════════════════════════════╝
-```
+### Phase 1: Manager Verification (5 rounds)
 
-## Phase 1: Manager Agent Verification (5 Rounds)
+| Round | Actions |
+|-------|---------|
+| 1-2 | mgr-supplier:audit, mgr-sync-checker:check, fix issues |
+| 3-4 | Re-verify + mgr-updater:docs, fix remaining |
+| 5 | Final: all counts match, frontmatter valid, skill refs exist, memory scopes valid, routing patterns updated |
 
-Run manager agents 5 times to catch all issues:
+Also run: mgr-claude-code-bible:verify (official spec compliance)
 
-### Round 1-2: Basic Sync
-```
-□ mgr-supplier:audit - Check all agent dependencies
-□ mgr-sync-checker:check - Verify registry synchronization
-□ Fix any issues found
-```
+### Phase 2: Deep Review (3 rounds)
 
-### Round 3-4: Deep Sync
-```
-□ mgr-supplier:audit - Re-verify after fixes
-□ mgr-sync-checker:check - Re-verify registries
-□ mgr-updater:docs - Check documentation sync
-□ Fix any remaining issues
-```
+| Round | Focus |
+|-------|-------|
+| 1 | Workflow alignment: routing skills have complete agent mappings |
+| 2 | References: no orphans, no circular refs, valid skill/memory refs |
+| 3 | Philosophy: R006 separation, R009 parallel, R010 delegation, R007/R008 identification |
 
-### Round 5: Final Verification
-```
-□ All agent counts match (CLAUDE.md, actual .md files in .claude/agents/)
-□ All agent frontmatter valid (required fields present)
-□ All skill references in agents exist in .claude/skills/
-□ All memory field values are valid (user | project | local)
-□ Memory distribution matches CLAUDE.md (24 project + 3 user + 7 none)
-□ All routing skill patterns updated
-```
-
-## Phase 2: Deep Review (3 Rounds)
-
-### Deep Round 1: Workflow Alignment
-```
-□ Agent creation workflow documented and functional
-□ Development workflow uses proper routing skills
-□ Deployment workflow defined (if applicable)
-□ All routing skills have complete agent pattern mappings
-```
-
-### Deep Round 2: Reference Verification
-```
-□ All routing skills properly reference their managed agents
-□ All rules are properly referenced
-□ No orphaned agents (not referenced by any routing skill)
-□ No circular references
-□ All skill references in agent frontmatter are valid
-□ All agent memory fields use valid scope values
-```
-
-### Deep Round 3: Philosophy Compliance
-```
-□ R006: Separation of concerns (agent file = role only, no details)
-□ R009: Parallel execution enabled for main conversation
-□ R010: Multi-agent tasks use routing skills and Task tool
-□ R007/R008: Agent/tool identification documented
-□ All MUST rules enforced, SHOULD rules recommended
-```
-
-## Verification Checklist Summary
-
-```
-Phase 1: Manager Verification (5x)
-  □ Round 1: mgr-supplier:audit
-  □ Round 2: mgr-sync-checker:check
-  □ Round 3: mgr-supplier:audit (re-verify)
-  □ Round 4: mgr-sync-checker:check + mgr-updater:docs
-  □ Round 5: Final count verification
-  □ mgr-claude-code-bible:verify (official spec compliance)
-
-Phase 2: Deep Review (3x)
-  □ Round 1: Workflow alignment
-  □ Round 2: Reference verification
-  □ Round 3: Philosophy compliance
-
-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
-  □ Delegate to mgr-gitnerd
-  □ Meaningful commit message
-
-Phase 5: Push
-  □ mgr-sauron:watch passed (MANDATORY)
-  □ Delegate push to mgr-gitnerd
-  □ Verify push succeeded
-```
+### Phase 3: Fix all discovered issues
 
-## When to Run Full Verification
+### Phase 4: Commit via mgr-gitnerd
 
-| Action | Full Verification Required |
-|--------|---------------------------|
-| Create new agent | **YES** |
-| Rename agent | **YES** |
-| Delete agent | **YES** |
-| Modify agent frontmatter | **YES** |
-| Add/modify skill | **YES** |
-| Add/modify guide | **YES** |
-| Change routing skill patterns | **YES** |
-| Update rules | **YES** |
-
-## Workflow Diagram
-
-```
-Content Change Made
-        │
-        ▼
-┌───────────────────────────────┐
-│  Phase 1: Manager Verification │
-│  (5 rounds)                    │
-│  mgr-supplier → mgr-sync-checker → │
-│  mgr-updater                   │
-└───────────────┬───────────────┘
-                │
-                ▼
-┌───────────────────────────────┐
-│  Phase 2: Deep Review          │
-│  (3 rounds)                    │
-│  Workflow → References →       │
-│  Philosophy                    │
-└───────────────┬───────────────┘
-                │
-        ┌───────┴───────┐
-        ▼               ▼
-  [Issues Found]   [All Clean]
-        │               │
-        ▼               │
-   Fix Issues           │
-        │               │
-        └───────┬───────┘
-                │
-                ▼
-┌───────────────────────────────┐
-│  Phase 4: Commit via mgr-gitnerd │
-└───────────────┬───────────────┘
-                │
-                ▼
-┌───────────────────────────────┐
-│  Phase 5: Push via mgr-gitnerd  │
-│  (ONLY after sauron passes)    │
-└───────────────────────────────┘
-```
+### Phase 5: Push via mgr-gitnerd (only after sauron passes)
 
 ## Self-Check Before Commit and Push
 
@@ -239,6 +62,10 @@ Content Change Made
 ╚══════════════════════════════════════════════════════════════════╝
 ```
 
+## When Required
+
+Any change to: agents, agent frontmatter, skills, guides, routing patterns, rules.
+
 ## Quick Verification Commands
 
 ```bash
@@ -270,12 +97,29 @@ for f in .claude/agents/*.md; do
     echo "INVALID MEMORY SCOPE in $f: $mem"
   fi
 done
-```
 
-## Integration with Other Rules
+# Hook count check
+ls .claude/hooks/*.json 2>/dev/null | wc -l
 
-| Rule | Integration |
-|------|-------------|
-| R009 (Parallel) | Verification checks can run in parallel |
-| R010 (Orchestrator) | Delegate commit to mgr-gitnerd |
-| R016 (Improvement) | Update this rule if new issues found |
+# Context count check
+ls .claude/contexts/*.md 2>/dev/null | wc -l
+
+# Guide count check
+find guides -mindepth 1 -maxdepth 1 -type d | wc -l
+
+# Agent name accuracy (compare CLAUDE.md table with actual files)
+# Extract agent names from files
+ls .claude/agents/*.md | xargs -I{} basename {} .md | sort > /tmp/actual-agents.txt
+
+# Slash command skill existence
+for cmd in $(grep "^| \`/" CLAUDE.md | sed 's/.*`\///' | sed 's/`.*//' | sed 's/ .*//')
+do
+  [ -d ".claude/skills/$cmd" ] || echo "MISSING SKILL: $cmd"
+done
+
+# Routing skill completeness check
+ls -d .claude/skills/*-routing 2>/dev/null | xargs -I{} basename {} | sort
+
+# Verify routing skill names in CLAUDE.md
+grep -oP '(secretary|dev-lead|de-lead|qa-lead)-routing' CLAUDE.md | sort -u
+```

package/templates/.claude/rules/MUST-tool-identification.md

@@ -1,46 +1,17 @@
 # [MUST] Tool Usage Identification Rules
 
-> **Priority**: MUST - ENFORCED, NO EXCEPTIONS
-> **ID**: R008
-> **Violation**: Immediate correction required
+> **Priority**: MUST - ENFORCED | **ID**: R008
 
-## CRITICAL
+## Core Rule
 
-**EVERY tool call MUST be prefixed with agent and model identification. This is NON-NEGOTIABLE.**
+Every tool call MUST be prefixed with agent and model identification:
 
 ```
-Before EVERY tool call, output:
 [agent-name][model] → Tool: <tool-name>
 [agent-name][model] → Target: <file/path/url>
 ```
 
-Failure to identify tool usage = Rule violation = Must be corrected immediately.
-
-### Self-Check Before EVERY Tool Call
-
-```
-╔══════════════════════════════════════════════════════════════════╗
-║  BEFORE INVOKING ANY TOOL, ASK YOURSELF:                         ║
-║                                                                   ║
-║  1. Did I output the tool identification line with MODEL?        ║
-║     [agent-name][model] → Tool: <tool-name>                      ║
-║     [agent-name][model] → Target: <target>                       ║
-║                                                                   ║
-║  2. Am I about to call multiple tools in parallel?               ║
-║     → EACH tool needs its own identification line                ║
-║     → List all identifications BEFORE the tool calls             ║
-║                                                                   ║
-║  If NO to #1 → STOP. Output identification FIRST.                ║
-╚══════════════════════════════════════════════════════════════════╝
-```
-
-### Model Values
-
-| Model | When to Use |
-|-------|-------------|
-| `opus` | Complex reasoning, architecture design |
-| `sonnet` | General tasks, code generation (default) |
-| `haiku` | Fast simple tasks, file search |
+For parallel calls: list ALL identifications BEFORE the tool calls.
 
 ### Common Violations to Avoid
 
@@ -76,120 +47,36 @@ Failure to identify tool usage = Rule violation = Must be corrected immediately.
    <tool_call>Bash(cmd)</tool_call>
 ```
 
-## Purpose
-
-Display which agent is using which tool for transparency and debugging. This extends R007 (Agent Identification) to cover tool operations.
-
-## Tool Usage Format
+## Models
 
-When invoking a tool, prefix with agent and model identification:
-
-```
-[agent-name][model] → Tool: <tool-name>
-```
-
-### Examples
-
-```
-[lang-golang-expert][sonnet] → Tool: Read
-[lang-golang-expert][sonnet] → Reading: src/main.go
-
-[mgr-supplier][haiku] → Tool: Glob
-[mgr-supplier][haiku] → Searching: .claude/agents/*.md
-
-[mgr-creator][sonnet] → Tool: Write
-[mgr-creator][sonnet] → Writing: .claude/agents/new-agent.md
-```
-
-## Extended Format (Verbose)
-
-For detailed tracking:
-
-```
-┌─ Agent: lang-golang-expert (sw-engineer)
-├─ Model: sonnet
-├─ Skill: go-best-practices
-├─ Tool: Read
-└─ Target: src/main.go
-```
+| Model | Use |
+|-------|-----|
+| `opus` | Complex reasoning, architecture |
+| `sonnet` | General tasks, code generation (default) |
+| `haiku` | Fast simple tasks, file search |
 
 ## Tool Categories
 
-| Category | Tools | Format |
-|----------|-------|--------|
-| File Read | Read, Glob, Grep | `→ Reading:` / `→ Searching:` |
-| File Write | Write, Edit | `→ Writing:` / `→ Editing:` |
-| Network | WebFetch | `→ Fetching:` |
-| Execution | Bash, Task | `→ Running:` / `→ Spawning:` |
-
-## When to Display
-
-| Situation | Display |
-|-----------|---------|
-| Reading files | Agent + file path |
-| Writing files | Agent + file path |
-| Searching | Agent + pattern |
-| Fetching URLs | Agent + URL |
-| Running commands | Agent + command |
+| Category | Tools | Verb |
+|----------|-------|------|
+| File Read | Read, Glob, Grep | Reading / Searching |
+| File Write | Write, Edit | Writing / Editing |
+| Network | WebFetch | Fetching |
+| Execution | Bash, Task | Running / Spawning |
 
-## Simplified Format
-
-For inline operations:
+## Task Tool Format
 
 ```
-[mgr-supplier][haiku] → Glob: .claude/agents/*.md
-[mgr-creator][sonnet] → Write: .claude/agents/new-agent.md
-[mgr-updater][sonnet] → WebFetch: https://github.com/...
+Task(subagent_type):model → description
 ```
 
-## Integration with R007
+`subagent_type` MUST match actual Task tool parameter. Custom names not allowed.
 
-R008 extends R007 for tool operations:
+## Example
 
 ```
-┌─ Agent: mgr-creator (manager)
-├─ Model: sonnet
-└─ Task: Creating new agent
-
 [mgr-creator][sonnet] → Write: .claude/agents/new-agent.md
-
-[Done] Agent created successfully
-```
-
-## Task Tool Display Format
-
-When spawning subagents via the Task tool, the display MUST use the actual `subagent_type` parameter:
-
-```
-Task(subagent_type):model → description
-```
-
-### Examples
-
-```
-[secretary][opus] → Spawning parallel agents:
+[secretary][opus] → Spawning:
   [1] Task(lang-golang-expert):sonnet → Go code review
   [2] Task(lang-python-expert):sonnet → Python code review
-  [3] Task(general-purpose):haiku → File validation
 ```
-
-### Rules
-
-- `subagent_type` MUST match the actual Task tool parameter value
-- Custom/invented names are NOT allowed (e.g., `code-review:sonnet` is WRONG)
-- Model specification shows cost/performance intent
-
-## Benefits
-
-1. **Debugging**: Know which agent performed which operation
-2. **Transparency**: User sees all agent activities
-3. **Audit Trail**: Track file changes by agent
-4. **Error Attribution**: Identify which agent caused issues
-
-## Implementation
-
-Agents should:
-1. Identify themselves before tool operations
-2. Include tool name and target
-3. Use consistent format across all tools
-4. Group related operations together

package/templates/.claude/rules/SHOULD-agent-teams.md

@@ -1,183 +1,39 @@
 # [SHOULD] Agent Teams Rules
 
-> **Priority**: SHOULD - Actively use when available
-> **ID**: R018
-> **Condition**: Agent Teams feature is enabled locally
-
-## Purpose
-
-When Claude Code's Agent Teams feature is enabled on the local machine, actively leverage it for tasks that benefit from multi-agent collaboration, shared state, and peer-to-peer communication.
+> **Priority**: SHOULD | **ID**: R018 | **Condition**: Agent Teams enabled locally
 
 ## Detection
 
-Agent Teams availability is determined by:
-- Environment variable: `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`
-- The presence of TeamCreate, SendMessage, TaskCreate/TaskList (team variants) tools
-
-When detected, Agent Teams becomes the **preferred coordination method** for qualifying tasks.
+Available when `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` or TeamCreate/SendMessage tools present.
 
 ## Decision Matrix
 
-| Scenario | Task Tool | Agent Teams | Preferred |
-|----------|-----------|-------------|-----------|
-| Simple independent subtasks | Low cost | Overkill | **Task Tool** |
-| Multi-step with shared state | Limited | Native support | **Agent Teams** |
-| Research requiring discussion | No peer comm | Peer messaging | **Agent Teams** |
-| Cost-sensitive batch ops | Lower tokens | Higher tokens | **Task Tool** |
-| Complex debugging across modules | Isolated context | Shared context | **Agent Teams** |
-| Code review + fix cycle | Sequential | Collaborative | **Agent Teams** |
-| Single file operations | Fast | Overhead | **Task Tool** |
-
-## When to Use Agent Teams
-
-### SHOULD Use Agent Teams For
-
-```
-Tasks requiring 3+ agents that need to coordinate
-Research tasks where agents need to share findings
-Debugging sessions spanning multiple modules
-Review + implementation cycles
-Any task where inter-agent communication adds value
-```
-
-### SHOULD Keep Task Tool For
-
-```
-Independent parallel subtasks (no shared state)
-Single-agent delegations
-Cost-sensitive batch operations
-Simple file operations
-When Agent Teams is not available
-```
-
-## CRITICAL: Self-Check Before Spawning Task Tool
-
-```
-╔══════════════════════════════════════════════════════════════════╗
-║  BEFORE USING TASK TOOL, ASK YOURSELF:                           ║
-║                                                                   ║
-║  1. Is Agent Teams available? (TeamCreate tool exists?)          ║
-║     → YES: Continue to step 2                                    ║
-║     → NO: Task tool is fine                                      ║
-║                                                                   ║
-║  2. Does this task qualify for Agent Teams?                      ║
-║     - 3+ agents needed?                                          ║
-║     - Shared state or coordination required?                     ║
-║     - Inter-agent communication adds value?                      ║
-║     - Complex workflow (create + review + integrate)?            ║
-║     → ANY YES: MUST use Agent Teams                              ║
-║     → ALL NO: Task tool is fine                                  ║
-║                                                                   ║
-║  3. Am I defaulting to Task tool out of habit?                   ║
-║     → STOP. Evaluate honestly against the decision matrix.       ║
-║                                                                   ║
-║  Using Task tool for Agent Teams-qualifying tasks                ║
-║  when Agent Teams is available = Rule violation                  ║
-╚══════════════════════════════════════════════════════════════════╝
-```
-
-## Team Composition Guidelines
-
-### Standard Team Patterns
-
-#### Research Team
-```
-TeamCreate("research-team")
-+-- researcher-1: Explore codebase area A
-+-- researcher-2: Explore codebase area B
-+-- synthesizer: Aggregate findings
-```
-
-#### Development Team
-```
-TeamCreate("dev-team")
-+-- implementer: Write code
-+-- reviewer: Review changes
-+-- tester: Validate changes
-```
-
-#### Debug Team
-```
-TeamCreate("debug-team")
-+-- investigator-1: Trace issue in module A
-+-- investigator-2: Trace issue in module B
-+-- fixer: Apply fixes based on findings
-```
-
-### Team Lifecycle
-
-```
-1. TeamCreate        -> Create team with purpose
-2. TaskCreate        -> Define tasks for team members
-3. Task(team_name)   -> Spawn team members
-4. SendMessage       -> Coordinate between members
-5. TaskUpdate        -> Track progress
-6. SendMessage(shutdown_request) -> Graceful shutdown
-7. TeamDelete        -> Cleanup
-```
-
-## Fallback Behavior
+| Scenario | Preferred |
+|----------|-----------|
+| Simple independent subtasks | Task Tool |
+| Multi-step with shared state | Agent Teams |
+| Research requiring discussion | Agent Teams |
+| Cost-sensitive batch ops | Task Tool |
+| Complex debugging across modules | Agent Teams |
+| Code review + fix cycle | Agent Teams |
+| Single file operations | Task Tool |
 
-When Agent Teams is NOT available:
-- All team-qualifying tasks fall back to Task tool
-- R009 (Parallel Execution) governs parallel spawning
-- R010 (Orchestrator Coordination) governs delegation
-- No degradation in capability, only in coordination richness
+**Self-check before Task tool:** Is Agent Teams available? Does task need 3+ agents, shared state, or inter-agent communication? If yes, use Agent Teams.
 
-```
-+------------------------------------------------------------------+
-|  GRACEFUL DEGRADATION                                            |
-|                                                                  |
-|  Agent Teams Available:                                          |
-|    Complex task -> TeamCreate -> coordinated agents              |
-|                                                                  |
-|  Agent Teams NOT Available:                                      |
-|    Complex task -> Task tool -> parallel independent agents      |
-|                                                                  |
-|  Both approaches produce results.                                |
-|  Agent Teams adds coordination, not capability.                  |
-+------------------------------------------------------------------+
-```
+## Team Patterns
 
-## Integration with Existing Rules
+- **Research**: researcher-1 + researcher-2 + synthesizer
+- **Development**: implementer + reviewer + tester
+- **Debug**: investigator-1 + investigator-2 + fixer
 
-| Rule | Integration |
-|------|-------------|
-| R009 (Parallel) | Task tool parallel = fallback when no Agent Teams |
-| R010 (Orchestrator) | Agent Teams = alternative coordination model |
-| R012 (HUD) | Team status displayed in HUD |
-| R013 (Ecomode) | Team communications respect ecomode |
+## Lifecycle
 
-## Cost Awareness
+TeamCreate → TaskCreate → Task(spawn) → SendMessage(coordinate) → TaskUpdate → shutdown → cleanup
 
-Agent Teams consume more tokens due to:
-- Full context per team member
-- Inter-agent message passing
-- Shared task list overhead
+## Fallback
 
-```
-Rule of thumb:
-  If task takes < 3 minutes with Task tool -> Use Task tool
-  If task needs inter-agent communication  -> Use Agent Teams
-  If unsure -> Default to Agent Teams when available, downgrade to Task tool only if clearly unqualified
-```
+When Agent Teams unavailable: use Task tool with R009/R010 rules. Both approaches produce results; Agent Teams adds coordination richness.
 
-## Enforcement
+## Cost
 
-```
-╔══════════════════════════════════════════════════════════════════╗
-║  VIOLATION EXAMPLES:                                             ║
-║                                                                   ║
-║  ✗ Agent Teams available + 4 parallel Task() calls for           ║
-║    coordinated work (creating agents + guides + routing skill)   ║
-║  ✗ Spawning Task tool agents that need to share results          ║
-║  ✗ Defaulting to Task tool without checking Agent Teams first    ║
-║                                                                   ║
-║  CORRECT EXAMPLES:                                               ║
-║                                                                   ║
-║  ✓ TeamCreate → TaskCreate → spawn team members for              ║
-║    multi-file coordinated creation                               ║
-║  ✓ Task tool for single independent delegation                   ║
-║  ✓ Task tool when Agent Teams is not available                   ║
-╚══════════════════════════════════════════════════════════════════╝
-```
+Agent Teams uses more tokens (full context per member + message passing). Use Task tool if task < 3 min or no inter-agent communication needed.