oh-my-claude-sisyphus 3.6.2 → 3.7.0

package/templates/hooks/pre-tool-use.mjs

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+/**
+ * OMC Pre-Tool-Use Hook (Node.js)
+ * Enforces delegation by warning when orchestrator attempts direct source file edits
+ */
+
+import * as path from 'path';
+
+// Allowed path patterns (no warning)
+const ALLOWED_PATH_PATTERNS = [
+  /\.omc\//,
+  /\.claude\//,
+  /\/\.claude\//,
+  /CLAUDE\.md$/,
+  /AGENTS\.md$/,
+];
+
+// Source file extensions (should warn)
+const SOURCE_EXTENSIONS = new Set([
+  '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+  '.py', '.pyw',
+  '.go', '.rs', '.java', '.kt', '.scala',
+  '.c', '.cpp', '.cc', '.h', '.hpp',
+  '.rb', '.php',
+  '.svelte', '.vue',
+  '.graphql', '.gql',
+  '.sh', '.bash', '.zsh',
+]);
+
+function isAllowedPath(filePath) {
+  if (!filePath) return true;
+  return ALLOWED_PATH_PATTERNS.some(pattern => pattern.test(filePath));
+}
+
+function isSourceFile(filePath) {
+  if (!filePath) return false;
+  const ext = path.extname(filePath).toLowerCase();
+  return SOURCE_EXTENSIONS.has(ext);
+}
+
+// Patterns that indicate file modification in bash commands
+const FILE_MODIFY_PATTERNS = [
+  /sed\s+-i/,
+  />\s*[^&]/,
+  />>/,
+  /tee\s+/,
+  /cat\s+.*>\s*/,
+  /echo\s+.*>\s*/,
+  /printf\s+.*>\s*/,
+];
+
+// Source file pattern for command inspection
+const SOURCE_EXT_PATTERN = /\.(ts|tsx|js|jsx|mjs|cjs|py|pyw|go|rs|java|kt|scala|c|cpp|cc|h|hpp|rb|php|svelte|vue|graphql|gql|sh|bash|zsh)/i;
+
+function checkBashCommand(command) {
+  // Check if command might modify files
+  const mayModify = FILE_MODIFY_PATTERNS.some(pattern => pattern.test(command));
+  if (!mayModify) return null;
+
+  // Check if it might affect source files
+  if (SOURCE_EXT_PATTERN.test(command)) {
+    return `[DELEGATION NOTICE] Bash command may modify source files: ${command}
+
+Recommended: Delegate to executor agent instead:
+  Task(subagent_type="oh-my-claudecode:executor", model="sonnet", prompt="...")
+
+This is a soft warning. Operation will proceed.`;
+  }
+  return null;
+}
+
+async function main() {
+  let input = '';
+
+  // Read stdin
+  for await (const chunk of process.stdin) {
+    input += chunk;
+  }
+
+  let data;
+  try {
+    data = JSON.parse(input);
+  } catch {
+    console.log(JSON.stringify({ continue: true }));
+    return;
+  }
+
+  // Extract tool name (handle both cases)
+  const toolName = data.tool_name || data.toolName || '';
+
+  // Handle Bash tool separately - check for file modification patterns
+  if (toolName === 'Bash' || toolName === 'bash') {
+    const toolInput = data.tool_input || data.toolInput || {};
+    const command = toolInput.command || '';
+    const warning = checkBashCommand(command);
+    if (warning) {
+      console.log(JSON.stringify({ continue: true, message: warning }));
+    } else {
+      console.log(JSON.stringify({ continue: true }));
+    }
+    return;
+  }
+
+  // Only check Edit and Write tools
+  if (!['Edit', 'Write', 'edit', 'write'].includes(toolName)) {
+    console.log(JSON.stringify({ continue: true }));
+    return;
+  }
+
+  // Extract file path (handle nested structures)
+  const toolInput = data.tool_input || data.toolInput || {};
+  const filePath = toolInput.file_path || toolInput.filePath || '';
+
+  // No file path? Allow
+  if (!filePath) {
+    console.log(JSON.stringify({ continue: true }));
+    return;
+  }
+
+  // Check if allowed path
+  if (isAllowedPath(filePath)) {
+    console.log(JSON.stringify({ continue: true }));
+    return;
+  }
+
+  // Check if source file
+  if (isSourceFile(filePath)) {
+    const warning = `[DELEGATION NOTICE] Direct ${toolName} on source file: ${filePath}
+
+Recommended: Delegate to executor agent instead:
+  Task(subagent_type="oh-my-claudecode:executor", model="sonnet", prompt="...")
+
+This is a soft warning. Operation will proceed.`;
+
+    console.log(JSON.stringify({ continue: true, message: warning }));
+    return;
+  }
+
+  // Not a source file, allow without warning
+  console.log(JSON.stringify({ continue: true }));
+}
+
+main().catch(() => {
+  console.log(JSON.stringify({ continue: true }));
+});

package/templates/hooks/pre-tool-use.sh

@@ -0,0 +1,113 @@
+#!/bin/bash
+# OMC Pre-Tool-Use Hook
+# Enforces delegation by warning when orchestrator attempts direct source file edits
+
+# Read stdin (JSON input from Claude Code)
+INPUT=$(cat)
+
+# Extract tool name and file path
+TOOL_NAME=""
+FILE_PATH=""
+if command -v jq &> /dev/null; then
+  TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // .toolName // ""' 2>/dev/null)
+  FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // .tool_input.filePath // .toolInput.file_path // .toolInput.filePath // ""' 2>/dev/null)
+else
+  TOOL_NAME=$(echo "$INPUT" | grep -oP '"tool_name"\s*:\s*"\K[^"]+' | head -1)
+  if [ -z "$TOOL_NAME" ]; then
+    TOOL_NAME=$(echo "$INPUT" | grep -oP '"toolName"\s*:\s*"\K[^"]+' | head -1)
+  fi
+  FILE_PATH=$(echo "$INPUT" | grep -oP '"file_path"\s*:\s*"\K[^"]+' | head -1)
+  if [ -z "$FILE_PATH" ]; then
+    FILE_PATH=$(echo "$INPUT" | grep -oP '"filePath"\s*:\s*"\K[^"]+' | head -1)
+  fi
+fi
+
+# Handle Bash tool separately - check for file modification patterns
+if [ "$TOOL_NAME" = "Bash" ] || [ "$TOOL_NAME" = "bash" ]; then
+  # Extract command
+  COMMAND=""
+  if command -v jq &> /dev/null; then
+    COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // .toolInput.command // ""' 2>/dev/null)
+  else
+    COMMAND=$(echo "$INPUT" | grep -oP '"command"\s*:\s*"\K[^"]+' | head -1)
+  fi
+
+  # Check for file modification patterns
+  if echo "$COMMAND" | grep -qE '(sed\s+-i|>\s*[^&]|>>\s*|tee\s+|cat\s+.*>\s*|echo\s+.*>\s*|printf\s+.*>\s*)'; then
+    # Check if modifying source files
+    SOURCE_PATTERN='\.(ts|tsx|js|jsx|mjs|cjs|py|pyw|go|rs|java|kt|scala|c|cpp|cc|h|hpp|rb|php|svelte|vue|graphql|gql|sh|bash|zsh)'
+    if echo "$COMMAND" | grep -qE "$SOURCE_PATTERN"; then
+      # Might be modifying source files - warn
+      WARNING="[DELEGATION NOTICE] Bash command may modify source files: $COMMAND
+
+Recommended: Delegate to executor agent instead:
+  Task(subagent_type=\"oh-my-claudecode:executor\", model=\"sonnet\", prompt=\"...\")
+
+This is a soft warning. Operation will proceed."
+      WARNING_ESCAPED=$(echo "$WARNING" | jq -Rs . 2>/dev/null || echo "\"$WARNING\"")
+      echo "{\"continue\": true, \"message\": $WARNING_ESCAPED}"
+      exit 0
+    fi
+  fi
+  # Bash command is OK
+  echo '{"continue": true}'
+  exit 0
+fi
+
+# Only check Edit and Write tools
+if [ "$TOOL_NAME" != "Edit" ] && [ "$TOOL_NAME" != "Write" ] && \
+   [ "$TOOL_NAME" != "edit" ] && [ "$TOOL_NAME" != "write" ]; then
+  echo '{"continue": true}'
+  exit 0
+fi
+
+# No file path? Allow
+if [ -z "$FILE_PATH" ]; then
+  echo '{"continue": true}'
+  exit 0
+fi
+
+# Check allowed paths (always OK)
+if [[ "$FILE_PATH" == *".omc/"* ]] || \
+   [[ "$FILE_PATH" == *".claude/"* ]] || \
+   [[ "$FILE_PATH" == *"/.claude/"* ]] || \
+   [[ "$FILE_PATH" == "CLAUDE.md" ]] || \
+   [[ "$FILE_PATH" == *"/CLAUDE.md" ]] || \
+   [[ "$FILE_PATH" == "AGENTS.md" ]] || \
+   [[ "$FILE_PATH" == *"/AGENTS.md" ]]; then
+  echo '{"continue": true}'
+  exit 0
+fi
+
+# Check if source file extension (should warn)
+EXT="${FILE_PATH##*.}"
+EXT_LOWER=$(echo "$EXT" | tr '[:upper:]' '[:lower:]')
+
+SOURCE_EXTS="ts tsx js jsx mjs cjs py pyw go rs java kt scala c cpp cc h hpp rb php svelte vue graphql gql sh bash zsh"
+
+IS_SOURCE=false
+for src_ext in $SOURCE_EXTS; do
+  if [ "$EXT_LOWER" = "$src_ext" ]; then
+    IS_SOURCE=true
+    break
+  fi
+done
+
+if [ "$IS_SOURCE" = true ]; then
+  # Emit warning but allow (soft enforcement)
+  WARNING="[DELEGATION NOTICE] Direct $TOOL_NAME on source file: $FILE_PATH
+
+Recommended: Delegate to executor agent instead:
+  Task(subagent_type=\"oh-my-claudecode:executor\", model=\"sonnet\", prompt=\"...\")
+
+This is a soft warning. Operation will proceed."
+
+  # Escape for JSON
+  WARNING_ESCAPED=$(echo "$WARNING" | jq -Rs .)
+  echo "{\"continue\": true, \"message\": $WARNING_ESCAPED}"
+  exit 0
+fi
+
+# Not a source file, allow without warning
+echo '{"continue": true}'
+exit 0

package/templates/hooks/session-start.mjs

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+// OMC Session Start Hook (Node.js)
+// Restores persistent mode states when session starts
+// Cross-platform: Windows, macOS, Linux
+
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString('utf-8');
+}
+
+function readJsonFile(path) {
+  try {
+    if (!existsSync(path)) return null;
+    return JSON.parse(readFileSync(path, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function countIncompleteTodos(todosDir) {
+  let count = 0;
+  if (existsSync(todosDir)) {
+    try {
+      const files = readdirSync(todosDir).filter(f => f.endsWith('.json'));
+      for (const file of files) {
+        const todos = readJsonFile(join(todosDir, file));
+        if (Array.isArray(todos)) {
+          count += todos.filter(t => t.status !== 'completed' && t.status !== 'cancelled').length;
+        }
+      }
+    } catch {}
+  }
+  return count;
+}
+
+async function main() {
+  try {
+    const input = await readStdin();
+    let data = {};
+    try { data = JSON.parse(input); } catch {}
+
+    const directory = data.directory || process.cwd();
+    const messages = [];
+
+    // Check for ultrawork state
+    const ultraworkState = readJsonFile(join(directory, '.omc', 'ultrawork-state.json'))
+      || readJsonFile(join(homedir(), '.claude', 'ultrawork-state.json'));
+
+    if (ultraworkState?.active) {
+      messages.push(`<session-restore>
+
+[ULTRAWORK MODE RESTORED]
+
+You have an active ultrawork session from ${ultraworkState.started_at}.
+Original task: ${ultraworkState.original_prompt}
+
+Continue working in ultrawork mode until all tasks are complete.
+
+</session-restore>
+
+---
+`);
+    }
+
+    // Check for incomplete todos
+    const todosDir = join(homedir(), '.claude', 'todos');
+    const incompleteCount = countIncompleteTodos(todosDir);
+
+    if (incompleteCount > 0) {
+      messages.push(`<session-restore>
+
+[PENDING TASKS DETECTED]
+
+You have ${incompleteCount} incomplete tasks from a previous session.
+Please continue working on these tasks.
+
+</session-restore>
+
+---
+`);
+    }
+
+    if (messages.length > 0) {
+      console.log(JSON.stringify({ continue: true, message: messages.join('\n') }));
+    } else {
+      console.log(JSON.stringify({ continue: true }));
+    }
+  } catch (error) {
+    console.log(JSON.stringify({ continue: true }));
+  }
+}
+
+main();

package/templates/hooks/session-start.sh

@@ -0,0 +1,62 @@
+#!/bin/bash
+# OMC Session Start Hook
+# Restores persistent mode states and injects context when session starts
+
+# Read stdin
+INPUT=$(cat)
+
+# Get directory
+DIRECTORY=""
+if command -v jq &> /dev/null; then
+  DIRECTORY=$(echo "$INPUT" | jq -r '.directory // ""' 2>/dev/null)
+fi
+
+if [ -z "$DIRECTORY" ]; then
+  DIRECTORY=$(pwd)
+fi
+
+MESSAGES=""
+
+# Check for active ultrawork state
+if [ -f "$DIRECTORY/.omc/ultrawork-state.json" ] || [ -f "$HOME/.claude/ultrawork-state.json" ]; then
+  if [ -f "$DIRECTORY/.omc/ultrawork-state.json" ]; then
+    ULTRAWORK_STATE=$(cat "$DIRECTORY/.omc/ultrawork-state.json" 2>/dev/null)
+  else
+    ULTRAWORK_STATE=$(cat "$HOME/.claude/ultrawork-state.json" 2>/dev/null)
+  fi
+
+  IS_ACTIVE=$(echo "$ULTRAWORK_STATE" | jq -r '.active // false' 2>/dev/null)
+  if [ "$IS_ACTIVE" = "true" ]; then
+    STARTED_AT=$(echo "$ULTRAWORK_STATE" | jq -r '.started_at // ""' 2>/dev/null)
+    PROMPT=$(echo "$ULTRAWORK_STATE" | jq -r '.original_prompt // ""' 2>/dev/null)
+    MESSAGES="$MESSAGES<session-restore>\\n\\n[ULTRAWORK MODE RESTORED]\\n\\nYou have an active ultrawork session from $STARTED_AT.\\nOriginal task: $PROMPT\\n\\nContinue working in ultrawork mode until all tasks are complete.\\n\\n</session-restore>\\n\\n---\\n\\n"
+  fi
+fi
+
+# Check for incomplete todos
+INCOMPLETE_COUNT=0
+TODOS_DIR="$HOME/.claude/todos"
+if [ -d "$TODOS_DIR" ]; then
+  for todo_file in "$TODOS_DIR"/*.json; do
+    if [ -f "$todo_file" ]; then
+      if command -v jq &> /dev/null; then
+        COUNT=$(jq '[.[] | select(.status != "completed" and .status != "cancelled")] | length' "$todo_file" 2>/dev/null || echo "0")
+        INCOMPLETE_COUNT=$((INCOMPLETE_COUNT + COUNT))
+      fi
+    fi
+  done
+fi
+
+if [ "$INCOMPLETE_COUNT" -gt 0 ]; then
+  MESSAGES="$MESSAGES<session-restore>\\n\\n[PENDING TASKS DETECTED]\\n\\nYou have $INCOMPLETE_COUNT incomplete tasks from a previous session.\\nPlease continue working on these tasks.\\n\\n</session-restore>\\n\\n---\\n\\n"
+fi
+
+# Output message if we have any
+if [ -n "$MESSAGES" ]; then
+  # Escape for JSON
+  MESSAGES_ESCAPED=$(echo "$MESSAGES" | sed 's/"/\\"/g')
+  echo "{\"continue\": true, \"message\": \"$MESSAGES_ESCAPED\"}"
+else
+  echo '{"continue": true}'
+fi
+exit 0

package/templates/hooks/stop-continuation.mjs

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+// OMC Stop Continuation Hook (Node.js)
+// Checks for incomplete todos and injects continuation prompt
+// Cross-platform: Windows, macOS, Linux
+
+import { readdirSync, readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+// Read all stdin
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString('utf-8');
+}
+
+// Main
+async function main() {
+  try {
+    // Read stdin (we don't use it much, but need to consume it)
+    await readStdin();
+
+    // Check for incomplete todos
+    const todosDir = join(homedir(), '.claude', 'todos');
+
+    if (!existsSync(todosDir)) {
+      console.log(JSON.stringify({ continue: true }));
+      return;
+    }
+
+    let incompleteCount = 0;
+
+    try {
+      const files = readdirSync(todosDir).filter(f => f.endsWith('.json'));
+
+      for (const file of files) {
+        try {
+          const content = readFileSync(join(todosDir, file), 'utf-8');
+          const todos = JSON.parse(content);
+
+          if (Array.isArray(todos)) {
+            const incomplete = todos.filter(
+              t => t.status !== 'completed' && t.status !== 'cancelled'
+            );
+            incompleteCount += incomplete.length;
+          }
+        } catch {
+          // Skip files that can't be parsed
+        }
+      }
+    } catch {
+      // Directory read error - allow continuation
+      console.log(JSON.stringify({ continue: true }));
+      return;
+    }
+
+    if (incompleteCount > 0) {
+      const reason = `[SYSTEM REMINDER - TODO CONTINUATION]
+
+Incomplete tasks remain in your todo list (${incompleteCount} remaining). Continue working on the next pending task.
+
+- Proceed without asking for permission
+- Mark each task complete when finished
+- Do not stop until all tasks are done`;
+
+      console.log(JSON.stringify({ continue: false, reason }));
+      return;
+    }
+
+    // No incomplete todos - allow stop
+    console.log(JSON.stringify({ continue: true }));
+  } catch (error) {
+    // On any error, allow continuation
+    console.log(JSON.stringify({ continue: true }));
+  }
+}
+
+main();

package/templates/hooks/stop-continuation.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+# OMC Stop Continuation Hook
+# Checks for incomplete todos and injects continuation prompt
+# Ported from oh-my-opencode's todo-continuation-enforcer
+
+# Read stdin
+INPUT=$(cat)
+
+# Get session ID if available
+SESSION_ID=""
+if command -v jq &> /dev/null; then
+  SESSION_ID=$(echo "$INPUT" | jq -r '.sessionId // .session_id // ""' 2>/dev/null)
+fi
+
+# Check for incomplete todos in the Claude todos directory
+TODOS_DIR="$HOME/.claude/todos"
+if [ -d "$TODOS_DIR" ]; then
+  # Look for any todo files with incomplete items
+  INCOMPLETE_COUNT=0
+  for todo_file in "$TODOS_DIR"/*.json; do
+    if [ -f "$todo_file" ]; then
+      if command -v jq &> /dev/null; then
+        COUNT=$(jq '[.[] | select(.status != "completed" and .status != "cancelled")] | length' "$todo_file" 2>/dev/null || echo "0")
+        INCOMPLETE_COUNT=$((INCOMPLETE_COUNT + COUNT))
+      fi
+    fi
+  done
+
+  if [ "$INCOMPLETE_COUNT" -gt 0 ]; then
+    # Output continuation message
+    cat << EOF
+{"continue": false, "reason": "[SYSTEM REMINDER - TODO CONTINUATION]\\n\\nIncomplete tasks remain in your todo list ($INCOMPLETE_COUNT remaining). Continue working on the next pending task.\\n\\n- Proceed without asking for permission\\n- Mark each task complete when finished\\n- Do not stop until all tasks are done"}
+EOF
+    exit 0
+  fi
+fi
+
+# No incomplete todos - allow stop
+echo '{"continue": true}'
+exit 0

package/templates/rules/README.md

@@ -0,0 +1,40 @@
+# Rules Templates
+
+This directory contains rule templates that you can copy to your project's `.claude/rules/` directory.
+
+## How to Use
+
+1. Create a `.claude/rules/` directory in your project root
+2. Copy the templates you want to use
+3. Customize them for your project
+4. Rules in `.claude/rules/*.md` will be auto-discovered and injected into context
+
+## Available Templates
+
+| Template | Purpose |
+|----------|---------|
+| `coding-style.md` | Code style and formatting guidelines |
+| `testing.md` | Testing requirements and coverage targets |
+| `security.md` | Security checklist and best practices |
+| `performance.md` | Performance guidelines and model selection |
+| `git-workflow.md` | Git commit and PR workflow |
+
+## Auto-Discovery
+
+When you place rules in `.claude/rules/`, they are automatically discovered by oh-my-claudecode and injected into the context for all agents working in your project.
+
+## Example
+
+```bash
+# Copy templates to your project
+mkdir -p .claude/rules
+cp templates/rules/security.md .claude/rules/
+cp templates/rules/testing.md .claude/rules/
+
+# Customize for your project
+# Edit .claude/rules/security.md to add project-specific checks
+```
+
+## Customization
+
+Each template has `[CUSTOMIZE]` markers where you should add project-specific guidelines.

package/templates/rules/coding-style.md

@@ -0,0 +1,74 @@
+# Coding Style Rules
+
+## Immutability (CRITICAL)
+
+ALWAYS create new objects, NEVER mutate:
+
+```javascript
+// WRONG: Mutation
+function updateUser(user, name) {
+  user.name = name  // MUTATION!
+  return user
+}
+
+// CORRECT: Immutability
+function updateUser(user, name) {
+  return { ...user, name }
+}
+```
+
+## File Organization
+
+MANY SMALL FILES > FEW LARGE FILES:
+- High cohesion, low coupling
+- 200-400 lines typical, 800 max
+- Extract utilities from large components
+- Organize by feature/domain, not by type
+
+## Error Handling
+
+ALWAYS handle errors comprehensively:
+
+```typescript
+try {
+  const result = await riskyOperation()
+  return result
+} catch (error) {
+  console.error('Operation failed:', error)
+  throw new Error('User-friendly error message')
+}
+```
+
+## Input Validation
+
+ALWAYS validate user input:
+
+```typescript
+import { z } from 'zod'
+
+const schema = z.object({
+  email: z.string().email(),
+  age: z.number().int().min(0).max(150)
+})
+
+const validated = schema.parse(input)
+```
+
+## Code Quality Checklist
+
+Before marking work complete:
+- [ ] Code is readable and well-named
+- [ ] Functions are small (<50 lines)
+- [ ] Files are focused (<800 lines)
+- [ ] No deep nesting (>4 levels)
+- [ ] Proper error handling
+- [ ] No console.log statements
+- [ ] No hardcoded values
+- [ ] Immutable patterns used
+
+## [CUSTOMIZE] Project-Specific Style
+
+Add your project-specific coding style rules here:
+- Naming conventions
+- File structure requirements
+- Framework-specific patterns

package/templates/rules/git-workflow.md

@@ -0,0 +1,41 @@
+# Git Workflow Rules
+
+## Commit Message Format
+
+```
+<type>: <description>
+
+<optional body>
+```
+
+Types: feat, fix, refactor, docs, test, chore, perf, ci
+
+## Pull Request Workflow
+
+When creating PRs:
+1. Analyze full commit history (not just latest commit)
+2. Use `git diff [base-branch]...HEAD` to see all changes
+3. Draft comprehensive PR summary
+4. Include test plan with TODOs
+5. Push with `-u` flag if new branch
+
+## Feature Implementation Workflow
+
+1. **Plan First** - Use `planner` agent
+2. **TDD Approach** - Use `tdd-guide` agent
+3. **Code Review** - Use `code-reviewer` agent after writing code
+4. **Commit** - Follow conventional commits format
+
+## Branch Naming
+
+- `feature/` - New features
+- `fix/` - Bug fixes
+- `refactor/` - Code refactoring
+- `docs/` - Documentation changes
+
+## [CUSTOMIZE] Project-Specific Git Rules
+
+Add your project-specific git workflow here:
+- Branch protection rules
+- Required reviewers
+- CI/CD requirements