Initial release: Claude Code Workflow (CCW) v2.0

🚀 Revolutionary AI-powered development workflow orchestration system

## 🔥 Core Innovations
- **Document-State Separation**: Markdown for planning, JSON for execution state
- **Progressive Complexity Management**: Level 0-2 adaptive workflow depth
- **5-Agent Orchestration**: Specialized AI agents with context preservation
- **Session-First Architecture**: Auto-discovery and state inheritance

## 🏗️ Key Features
- Intelligent workflow orchestration (Simple/Medium/Complex patterns)
- Real-time document-state synchronization with conflict resolution
- Hierarchical task management with 3-level JSON structure
- Gemini CLI integration with 12+ specialized templates
- Comprehensive file output generation for all workflow commands

## 📦 Installation
Remote one-liner installation:
```
iex (iwr -useb https://raw.githubusercontent.com/catlog22/Claude-CCW/main/install-remote.ps1)
```

## 🎯 System Architecture
4-layer intelligent development architecture:
1. Command Layer - Smart routing and version management
2. Agent Layer - 5 specialized development agents
3. Workflow Layer - Gemini templates and task orchestration
4. Memory Layer - Distributed documentation and auto-sync

🤖 Generated with Claude Code

Co-Authored-By: Claude <noreply@anthropic.com>

.claude/workflows/gemini-code-developer.md

@@ -0,0 +1,92 @@
+# Gemini Code Developer Template
+
+**Purpose**: Locate exact modification points and provide concrete implementation guidance
+
+## Template Structure
+
+```bash
+gemini --all-files -p "@{[target-modification-files]} @{[similar-feature-files]} @{**/*test*/**/*,**/*.test.*,**/*.spec.*}
+
+Implementation guidance for: [specific feature/function to implement]
+
+## Required Analysis:
+1. **Exact Modification Points**:
+   - Find precise locations (file:line) where new code should be added
+   - Identify existing functions that need modification
+   - Locate where new imports/dependencies should be added
+
+2. **Similar Code Examples**:
+   - Find existing implementations similar to what needs to be built
+   - Extract code patterns that should be followed
+   - Identify utility functions that can be reused
+
+3. **Code Structure and Patterns**:
+   - How should the new code be structured based on existing patterns?
+   - What naming conventions are used for similar features?
+   - What error handling patterns should be followed?
+
+4. **Testing Requirements**:
+   - Find similar test cases for reference
+   - Identify testing utilities and helpers available
+   - Determine what specific test scenarios are needed
+
+5. **Integration and Dependencies**:
+   - What existing functions need to call the new code?
+   - Which modules need to import the new functionality?
+   - What configuration or setup is required?
+
+## Output Requirements:
+- **Precise insertion points**: Exact file:line locations for new code
+- **Code skeleton**: Structure based on existing patterns with placeholder functions
+- **Concrete examples**: Copy-paste reference code from similar features
+- **Test template**: Specific test cases needed based on existing patterns
+- **Integration checklist**: Exact functions/files that need to call or import new code
+
+Focus on actionable implementation guidance with specific line references."
+```
+
+## Intelligent Usage Examples
+
+```python
+# React component implementation
+def code_developer_context(user_input):
+    context = build_intelligent_context(
+        user_input="Create user profile edit component",
+        analysis_type="code-developer-context",
+        domains=['frontend', 'ui'],
+        tech_stack=['React', 'TypeScript', 'Tailwind']
+    )
+    
+    return f"""
+    gemini --all-files -p "@{{src/components/**/*,src/pages/**/*}} 
+    @{{**/*profile*,**/*user*,**/*form*}} @{{**/*.test.*,**/*.spec.*}}
+    @{{CLAUDE.md,frontend/CLAUDE.md,react/CLAUDE.md}}
+    
+    Implementation guidance for: User profile edit component with form validation
+    - Profile form fields: name, email, bio, avatar upload
+    - Form validation using existing patterns
+    - State management integration with user context
+    
+    Focus on exact insertion points and component structure based on similar forms."
+    """
+```
+
+## Context Application
+
+- Locate exact code insertion and modification points
+- Follow repository-specific patterns and conventions
+- Reuse existing utilities and established approaches
+- Create comprehensive test coverage based on similar features
+
+## Usage Guidelines
+
+**Use Code Developer template when**:
+- Before implementing specific functions, classes, or features
+- You need exact insertion points and code structure guidance
+- Focus on actionable implementation steps with line references
+
+**Template focuses on**:
+- Precise, task-focused analysis for actionable implementation
+- Exact file:line references and concrete guidance
+- Repository context with patterns specific to the actual codebase
+- Specific scope analyzing only what's needed for the immediate task