oh-my-customcodex 0.1.0

package/templates/.claude/skills/rust-best-practices/SKILL.md

@@ -0,0 +1,268 @@
+---
+name: rust-best-practices
+description: Idiomatic Rust patterns from official guidelines
+scope: core
+user-invocable: false
+---
+
+## Purpose
+
+Apply idiomatic Rust patterns and best practices from official documentation.
+
+## Core Principles
+
+```
+Safety without garbage collection
+Zero-cost abstractions
+Fearless concurrency
+Ownership as a feature
+```
+
+## Rules
+
+### 1. Naming Conventions
+
+```yaml
+crates:
+  style: snake_case or kebab-case
+  example: my_crate, my-crate
+
+modules:
+  style: snake_case
+  example: my_module
+
+types:
+  style: UpperCamelCase
+  example: MyStruct, MyEnum
+
+traits:
+  style: UpperCamelCase
+  example: Iterator, Display
+
+functions_methods:
+  style: snake_case
+  example: my_function, get_value
+
+constants:
+  style: SCREAMING_SNAKE_CASE
+  example: MAX_SIZE
+
+type_parameters:
+  style: single uppercase or CamelCase
+  example: T, E, Item
+
+lifetimes:
+  style: short lowercase
+  example: 'a, 'b, 'static
+
+macros:
+  style: snake_case!
+  example: vec!, println!
+```
+
+### 2. Ownership and Borrowing
+
+```yaml
+principles:
+  - Each value has exactly one owner
+  - References cannot outlive the data they reference
+  - Either one mutable reference OR many immutable references
+
+prefer:
+  - "&T over T" when not needing ownership
+  - "&mut T over T" when modifying without consuming
+  - "T over Box<T>" when size is known at compile time
+
+avoid:
+  - Clone when borrowing suffices
+  - RefCell unless interior mutability is needed
+  - Unsafe unless absolutely necessary
+```
+
+### 3. Error Handling
+
+```yaml
+result_type:
+  - Return Result<T, E> for recoverable errors
+  - Use ? operator for propagation
+  - Define custom error types for libraries
+
+option_type:
+  - Use Option<T> for nullable values
+  - Prefer map/and_then over match when appropriate
+  - Use unwrap_or, unwrap_or_else, unwrap_or_default
+
+panic:
+  - Only for unrecoverable errors
+  - Use in tests with assert!, assert_eq!
+  - Avoid in library code
+
+patterns: |
+  // Propagation with ?
+  fn read_file() -> Result<String, io::Error> {
+      let mut file = File::open("file.txt")?;
+      let mut contents = String::new();
+      file.read_to_string(&mut contents)?;
+      Ok(contents)
+  }
+
+  // Custom error type
+  #[derive(Debug)]
+  enum MyError {
+      Io(io::Error),
+      Parse(ParseIntError),
+  }
+```
+
+### 4. Traits and Generics
+
+```yaml
+trait_design:
+  - Keep traits focused and small
+  - Use associated types for output types
+  - Implement standard traits: Debug, Clone, Default, PartialEq
+
+standard_traits:
+  - Debug: for debugging output
+  - Clone: explicit duplication
+  - Default: default value construction
+  - PartialEq, Eq: equality comparison
+  - PartialOrd, Ord: ordering
+  - Hash: for HashMap keys
+  - Display: user-facing output
+  - From/Into: type conversion
+
+generics:
+  - Use trait bounds to specify requirements
+  - Prefer impl Trait in argument position
+  - Use where clauses for complex bounds
+```
+
+### 5. Memory Management
+
+```yaml
+stack_vs_heap:
+  - Stack: fixed-size, Copy types
+  - Heap: dynamic-size, Box, Vec, String
+
+smart_pointers:
+  - Box<T>: heap allocation with single owner
+  - Rc<T>: reference counting (single-threaded)
+  - Arc<T>: atomic reference counting (multi-threaded)
+  - RefCell<T>: interior mutability
+
+avoid_leaks:
+  - Drop trait for cleanup
+  - RAII pattern for resources
+  - Weak references to break cycles
+```
+
+### 6. Concurrency
+
+```yaml
+send_sync:
+  - Send: safe to transfer between threads
+  - Sync: safe to share references between threads
+
+primitives:
+  - Mutex<T>: mutual exclusion
+  - RwLock<T>: multiple readers or one writer
+  - Arc<T>: thread-safe reference counting
+  - mpsc: channels for message passing
+
+patterns: |
+  // Shared state with Arc and Mutex
+  let counter = Arc::new(Mutex::new(0));
+  let counter_clone = Arc::clone(&counter);
+
+  thread::spawn(move || {
+      let mut num = counter_clone.lock().unwrap();
+      *num += 1;
+  });
+
+  // Message passing
+  let (tx, rx) = mpsc::channel();
+  thread::spawn(move || {
+      tx.send(value).unwrap();
+  });
+  let received = rx.recv().unwrap();
+```
+
+### 7. API Design
+
+```yaml
+guidelines:
+  - Accept borrowed data when possible
+  - Return owned data when the caller needs it
+  - Use Into/AsRef for flexible parameters
+  - Implement standard conversion traits
+
+constructors:
+  - new() for primary constructor
+  - with_* for alternative constructors
+  - Builder pattern for many parameters
+
+methods:
+  - is_* for boolean queries
+  - as_* for cheap conversions (borrows)
+  - to_* for expensive conversions (copies)
+  - into_* for ownership transfers
+```
+
+### 8. Documentation
+
+```yaml
+rules:
+  - Document all public items
+  - Include examples in doc comments
+  - Use # Examples section
+  - Document panics, errors, safety
+
+format: |
+  /// Brief description.
+  ///
+  /// More detailed explanation if needed.
+  ///
+  /// # Examples
+  ///
+  /// ```
+  /// let result = my_function(42);
+  /// assert_eq!(result, 84);
+  /// ```
+  ///
+  /// # Panics
+  ///
+  /// Panics if the input is zero.
+  pub fn my_function(x: i32) -> i32 {
+      x * 2
+  }
+```
+
+### 9. Project Structure
+
+```yaml
+layout:
+  - src/lib.rs or src/main.rs: crate root
+  - src/bin/: additional binaries
+  - tests/: integration tests
+  - benches/: benchmarks
+  - examples/: example programs
+
+modules:
+  - One module per file
+  - mod.rs or filename.rs for module
+  - pub use for re-exports
+```
+
+## Application
+
+When writing or reviewing Rust code:
+
+1. **Always** handle ownership correctly
+2. **Always** handle errors with Result/Option
+3. **Prefer** borrowing over cloning
+4. **Prefer** zero-cost abstractions
+5. **Implement** standard traits (Debug, Clone, etc.)
+6. **Document** public APIs with examples
+7. **Avoid** unsafe unless necessary
+8. **Use** clippy for linting

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

@@ -0,0 +1,239 @@
+---
+name: omcodex:sauron-watch
+description: Full R017 verification (5+3 rounds) before commit
+scope: harness
+disable-model-invocation: true
+user-invocable: 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, skills, documentation, and project structure before committing changes.
+
+## Workflow
+
+### Phase 1: Manager Agent Verification (5 rounds)
+
+#### Round 1-2: Basic Checks
+```
+□ mgr-supplier:audit - Check all agent dependencies and skill refs
+□ mgr-updater:docs - Verify documentation sync
+□ Fix any issues found
+```
+
+#### Round 3-4: Re-verify + Update
+```
+□ mgr-supplier:audit - Re-verify after fixes
+□ mgr-updater:docs - Re-run and apply any detected changes
+□ Fix any remaining issues
+```
+
+#### Round 5: Final Count Verification
+```
+□ Agent count matches: AGENTS.md vs actual .md files
+□ Skill count matches: AGENTS.md vs actual SKILL.md files
+□ Memory field distribution correct
+□ Hook/context/guide/rule counts match
+□ All frontmatter valid
+□ All skill refs exist
+□ All memory scopes valid (project|user|local)
+□ Routing patterns updated
+```
+
+### Phase 2: Deep Review (3 rounds)
+
+#### Deep Round 1: Workflow Alignment
+```
+□ Agent workflows match purpose
+□ Command definitions match implementations
+□ Routing skill patterns are valid
+□ All routing skills have complete agent mappings
+```
+
+#### Structural Lint Rules
+
+In addition to workflow alignment checks, verify these structural invariants:
+
+**Lint 1: Routing Coverage**
+```
+For each agent in .codex/agents/*.md:
+  Check if agent name appears in at least one routing skill:
+    - secretary-routing/SKILL.md
+    - dev-lead-routing/SKILL.md
+    - de-lead-routing/SKILL.md
+    - qa-lead-routing/SKILL.md
+
+  If not found in any routing skill:
+    WARN: "{agent} is unreachable — not referenced in any routing skill"
+```
+
+**Lint 2: Orphan Skill Detection**
+```
+For each skill in .codex/skills/*/SKILL.md:
+  Check if skill name appears in:
+    - Any agent's skills: [] frontmatter field
+    - Any routing skill's content
+    - AGENTS.md command table (for user-invocable skills)
+
+  If not referenced anywhere:
+    WARN: "{skill} is orphaned — not referenced by any agent or routing skill"
+```
+
+**Lint 3: Circular Dependency Check**
+```
+Build dependency graph:
+  For each agent → extract skills: [] references
+  For each skill → extract agent references in body
+
+  Detect cycles: agent-A → skill-X → agent-A
+  If cycle found:
+    ERROR: "Circular dependency: {cycle path}"
+```
+
+**Lint 4: Context Fork Cap Verification**
+```
+Count skills with context: fork in frontmatter:
+  grep "context: fork" .codex/skills/*/SKILL.md
+
+  If count > 10:
+    ERROR: "Context fork cap exceeded: {count}/10"
+  If count >= 8:
+    WARN: "Context fork usage high: {count}/10 — only {10-count} slots remaining"
+```
+
+All structural lints are **advisory** (WARN level) except circular dependencies and fork cap exceeded (ERROR level — should block commit).
+
+#### Deep Round 2: Reference Verification
+```
+□ All skill references exist
+□ All agent frontmatter valid
+□ memory field values valid (user | project | local)
+□ No orphaned agents
+□ No circular references
+```
+
+#### Deep Round 3: Philosophy Compliance
+```
+□ R006: Agent design rules (including memory field spec)
+□ R007: Agent identification rules
+□ R008: Tool identification rules
+□ R009: Parallel execution rules
+□ R010: Orchestrator coordination rules
+□ R011: Memory integration (native-first architecture)
+□ All MUST rules enforced, SHOULD rules recommended
+```
+
+#### Spec Density Check (Advisory)
+
+Check each agent's body-to-skill ratio to detect agents with too much inline implementation detail:
+
+```
+For each agent in .codex/agents/*.md:
+  agent_body_LOC = count non-frontmatter, non-blank lines in agent body
+  referenced_skills = extract skills from frontmatter skills: field
+  total_skill_LOC = sum of LOC in each referenced SKILL.md
+
+  if total_skill_LOC > 0:
+    spec_density = agent_body_LOC / total_skill_LOC
+    if spec_density > 0.5:
+      WARN: "{agent} has spec density {spec_density:.2f} — consider extracting inline details to skills"
+  else:
+    if agent_body_LOC > 50:
+      INFO: "{agent} has {agent_body_LOC} LOC with no skill references — consider creating skills"
+```
+
+**Thresholds**:
+| Density | Status | Meaning |
+|---------|--------|---------|
+| ≤ 0.3 | Good | Agent properly delegates to skills |
+| 0.3-0.5 | OK | Acceptable inline detail |
+| > 0.5 | WARNING | Too much implementation in agent body |
+
+This check is **advisory only** — it does not block commits.
+
+### Phase 2.5: Documentation Accuracy
+```
+□ Every agent name in AGENTS.md matches actual filename
+□ All counts cross-verified against filesystem
+□ Every slash command has corresponding skill
+□ Every agent reachable through routing skills
+```
+
+### Phase 3: Fix Issues
+```
+□ Auto-fix: count mismatches, missing fields, outdated refs
+□ Report: missing files, invalid scopes, philosophy violations
+□ 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] mgr-supplier:audit
+  ✓ 41 agents checked, 0 issues
+
+[Round 2/5] mgr-updater:docs
+  ✓ Documentation sync: OK
+
+[Round 3/5] Re-verify: mgr-supplier:audit
+  ✓ All dependencies valid
+
+[Round 4/5] Re-verify: mgr-updater:docs
+  ✓ No changes needed
+
+[Round 5/5] Final count verification
+  ✓ Agents: 41/41 match
+  ✓ Skills: 55/55 match
+  ✓ All frontmatter valid
+  ✓ All skill refs valid
+  ✓ All memory scopes valid
+
+═══════════════════════════════════════════════════════════
+ PHASE 2: Deep Review (3 rounds)
+═══════════════════════════════════════════════════════════
+
+[Round 1/3] Workflow alignment
+  ✓ All routing skills have complete agent mappings
+  ✓ Command definitions match implementations
+
+[Round 2/3] Reference verification
+  ✓ All skill references valid
+  ✓ 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