oh-my-customcode 0.8.0 → 0.9.0

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

@@ -0,0 +1,281 @@
+# [MUST] Sync Verification Rules
+
+> **Priority**: MUST - ENFORCED after any structural changes
+> **ID**: R017
+> **Violation**: Committing or pushing without verification = Rule violation
+
+## CRITICAL
+
+**After modifying agents, skills, or guides, you MUST run the full verification process before committing AND pushing.**
+
+```
+╔══════════════════════════════════════════════════════════════════╗
+║  ⚠️  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      ║
+╚══════════════════════════════════════════════════════════════════╝
+```
+
+```
+╔══════════════════════════════════════════════════════════════════╗
+║  ⚠️  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.                                    ║
+╚══════════════════════════════════════════════════════════════════╝
+```
+
+```
+╔══════════════════════════════════════════════════════════════════╗
+║  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 Agent Verification (5 Rounds)
+
+Run manager agents 5 times to catch all issues:
+
+### Round 1-2: Basic Sync
+```
+□ mgr-supplier:audit - Check all agent dependencies
+□ mgr-sync-checker:check - Verify registry synchronization
+□ Fix any issues found
+```
+
+### 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 5: Final Verification
+```
+□ All agent counts match (AGENTS.md, actual .md files in .codex/agents/)
+□ All agent frontmatter valid (required fields present)
+□ All skill references in agents exist in .codex/skills/
+□ All memory field values are valid (user | project | local)
+□ Memory distribution matches AGENTS.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
+```
+
+## When to Run Full Verification
+
+| 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)    │
+└───────────────────────────────┘
+```
+
+## Self-Check Before Commit and Push
+
+```
+╔══════════════════════════════════════════════════════════════════╗
+║  BEFORE COMMITTING, ASK YOURSELF:                                ║
+║                                                                   ║
+║  1. Did I complete all 5 rounds of manager verification?         ║
+║  2. Did I complete all 3 rounds of deep review?                  ║
+║  3. Did I fix ALL discovered issues?                             ║
+║  4. Are all counts matching across all sources?                  ║
+║  5. Am I delegating to mgr-gitnerd for the commit?               ║
+║                                                                   ║
+║  If NO to ANY → DO NOT COMMIT                                    ║
+╚══════════════════════════════════════════════════════════════════╝
+
+╔══════════════════════════════════════════════════════════════════╗
+║  BEFORE PUSHING, ASK YOURSELF:                                   ║
+║                                                                   ║
+║  1. Did mgr-sauron:watch complete successfully?                  ║
+║  2. Were ALL issues from sauron verification fixed?              ║
+║  3. Am I delegating to mgr-gitnerd for the push?                 ║
+║                                                                   ║
+║  If NO to ANY → DO NOT PUSH                                      ║
+║                                                                   ║
+║  SAURON VERIFICATION IS MANDATORY FOR ALL PUSHES.                ║
+╚══════════════════════════════════════════════════════════════════╝
+```
+
+## Quick Verification Commands
+
+```bash
+# Agent count check
+ls .codex/agents/*.md | wc -l
+
+# Skill count check
+find .codex/skills -name "SKILL.md" | wc -l
+
+# Frontmatter validation (check for missing YAML headers)
+for f in .codex/agents/*.md; do head -1 "$f" | grep -q "^---" || echo "MISSING FRONTMATTER: $f"; done
+
+# Check for agents with invalid skill references
+for f in .codex/agents/*.md; do
+  grep "^skills:" -A 10 "$f" | grep "  - " | sed 's/.*- //' | while read skill; do
+    [ -f ".codex/skills/$skill/SKILL.md" ] || echo "INVALID SKILL REF in $f: $skill"
+  done
+done
+
+# Routing skill pattern coverage
+grep -c "agent_patterns:" .codex/skills/secretary-routing/SKILL.md
+grep -c "agent_patterns:" .codex/skills/dev-lead-routing/SKILL.md
+grep -c "agent_patterns:" .codex/skills/qa-lead-routing/SKILL.md
+
+# Memory field validation
+for f in .codex/agents/*.md; do
+  mem=$(grep "^memory:" "$f" | awk '{print $2}')
+  if [ -n "$mem" ] && [ "$mem" != "project" ] && [ "$mem" != "user" ] && [ "$mem" != "local" ]; then
+    echo "INVALID MEMORY SCOPE in $f: $mem"
+  fi
+done
+```
+
+## Integration with Other Rules
+
+| 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 |

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

@@ -0,0 +1,195 @@
+# [MUST] Tool Usage Identification Rules
+
+> **Priority**: MUST - ENFORCED, NO EXCEPTIONS
+> **ID**: R008
+> **Violation**: Immediate correction required
+
+## CRITICAL
+
+**EVERY tool call MUST be prefixed with agent and model identification. This is NON-NEGOTIABLE.**
+
+```
+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 |
+
+### Common Violations to Avoid
+
+```
+❌ WRONG: Calling tools without identification
+   "먼저 JD 내용을 확인하겠습니다."
+   <tool_call>WebFetch(...)</tool_call>
+
+❌ WRONG: Missing model in identification
+   [secretary] → Tool: WebFetch
+   [secretary] → Fetching: https://example.com/jd.md
+
+✓ CORRECT: Always identify with agent AND model
+   "먼저 JD 내용을 확인하겠습니다."
+   [secretary][opus] → Tool: WebFetch
+   [secretary][opus] → Fetching: https://example.com/jd.md
+   <tool_call>WebFetch(...)</tool_call>
+
+❌ WRONG: Parallel calls without listing all identifications
+   <tool_call>WebFetch(url1)</tool_call>
+   <tool_call>WebFetch(url2)</tool_call>
+   <tool_call>Bash(cmd)</tool_call>
+
+✓ CORRECT: List all identifications with models, then call
+   [secretary][opus] → Tool: WebFetch
+   [secretary][opus] → Fetching: url1
+   [secretary][opus] → Tool: WebFetch
+   [secretary][opus] → Fetching: url2
+   [secretary][opus] → Tool: Bash
+   [secretary][opus] → Running: cmd
+   <tool_call>WebFetch(url1)</tool_call>
+   <tool_call>WebFetch(url2)</tool_call>
+   <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
+
+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: .codex/agents/*.md
+
+[mgr-creator][sonnet] → Tool: Write
+[mgr-creator][sonnet] → Writing: .codex/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
+```
+
+## 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 |
+
+## Simplified Format
+
+For inline operations:
+
+```
+[mgr-supplier][haiku] → Glob: .codex/agents/*.md
+[mgr-creator][sonnet] → Write: .codex/agents/new-agent.md
+[mgr-updater][sonnet] → WebFetch: https://github.com/...
+```
+
+## Integration with R007
+
+R008 extends R007 for tool operations:
+
+```
+┌─ Agent: mgr-creator (manager)
+├─ Model: sonnet
+└─ Task: Creating new agent
+
+[mgr-creator][sonnet] → Write: .codex/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:
+  [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/.codex/rules/SHOULD-agent-teams.md

@@ -0,0 +1,183 @@
+# [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.
+
+## 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.
+
+## 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
+
+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
+
+```
++------------------------------------------------------------------+
+|  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.                  |
++------------------------------------------------------------------+
+```
+
+## Integration with Existing Rules
+
+| 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 |
+
+## Cost Awareness
+
+Agent Teams consume more tokens due to:
+- Full context per team member
+- Inter-agent message passing
+- Shared task list overhead
+
+```
+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
+```
+
+## Enforcement
+
+```
+╔══════════════════════════════════════════════════════════════════╗
+║  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                   ║
+╚══════════════════════════════════════════════════════════════════╝
+```