Phase 0 completion: NT8 SDK core framework with risk management and position sizing

.kilocode/rules/development_workflow.md

@@ -0,0 +1,243 @@
+# NT8 Institutional SDK - Development Workflow
+
+## Overview
+This document outlines the development workflow for the NT8 Institutional SDK, following the Archon workflow principles even in the absence of the Archon MCP server.
+
+## Archon Workflow Principles
+
+The development process follows these core principles adapted from the Archon workflow:
+
+### 1. Check Current Task
+Before beginning any work, clearly define what needs to be accomplished:
+- Review requirements and specifications
+- Understand success criteria
+- Identify dependencies and blockers
+
+### 2. Research for Task
+Conduct thorough research before implementation:
+- Review existing code and documentation
+- Understand best practices and patterns
+- Identify potential challenges and solutions
+
+### 3. Implement the Task
+Execute the implementation with focus and precision:
+- Follow established patterns and conventions
+- Write clean, maintainable code
+- Include comprehensive error handling
+- Add structured logging for observability
+
+### 4. Update Task Status
+Track progress and document completion:
+- Mark tasks as completed in the todo list
+- Document any issues or deviations
+- Note lessons learned for future reference
+
+### 5. Get Next Task
+Move systematically through the implementation:
+- Prioritize tasks based on dependencies
+- Focus on one task at a time
+- Ensure quality before moving forward
+
+## Development Process
+
+### Phase 1: Planning and Design
+1. Review specifications and requirements
+2. Create architecture diagrams and documentation
+3. Identify core components and their interactions
+4. Plan implementation approach and timeline
+
+### Phase 2: Environment Setup
+1. Create project structure and configuration files
+2. Set up build and test infrastructure
+3. Configure CI/CD pipeline
+4. Verify development environment
+
+### Phase 3: Core Implementation
+1. Implement core interfaces and models
+2. Develop risk management components
+3. Create position sizing algorithms
+4. Build supporting utilities and helpers
+
+### Phase 4: Testing and Validation
+1. Create comprehensive unit tests
+2. Implement integration tests
+3. Run validation scripts
+4. Verify all success criteria
+
+### Phase 5: Documentation and Delivery
+1. Create developer documentation
+2. Write user guides and examples
+3. Prepare release notes
+4. Conduct final validation
+
+## Code Quality Standards
+
+### 1. Code Structure
+- Follow established naming conventions
+- Use consistent formatting and style
+- Organize code into logical modules
+- Maintain clear separation of concerns
+
+### 2. Error Handling
+- Validate all inputs and parameters
+- Provide meaningful error messages
+- Handle exceptions gracefully
+- Log errors for debugging
+
+### 3. Testing
+- Write unit tests for all public methods
+- Include edge case testing
+- Validate error conditions
+- Maintain >90% code coverage
+
+### 4. Documentation
+- Include XML documentation for all public APIs
+- Add inline comments for complex logic
+- Document configuration options
+- Provide usage examples
+
+## Git Workflow
+
+### Branching Strategy
+- Use feature branches for all development
+- Create branches from main for new features
+- Keep feature branches short-lived
+- Merge to main after review and testing
+
+### Commit Guidelines
+- Write clear, descriptive commit messages
+- Make small, focused commits
+- Reference issues or tasks in commit messages
+- Squash related commits before merging
+
+### Pull Request Process
+- Create PRs for all feature work
+- Include description of changes and testing
+- Request review from team members
+- Address feedback before merging
+
+## Development Environment
+
+### Required Tools
+- .NET 6.0 SDK
+- Visual Studio Code or Visual Studio
+- Git for version control
+- Docker Desktop (recommended)
+
+### Recommended Extensions
+- C# for Visual Studio Code
+- EditorConfig for VS Code
+- GitLens for enhanced Git experience
+- Docker extension for container management
+
+## Build and Test Process
+
+### Local Development
+1. Restore NuGet packages: `dotnet restore`
+2. Build solution: `dotnet build`
+3. Run tests: `dotnet test`
+4. Run specific test categories if needed
+
+### Continuous Integration
+- Automated builds on every commit
+- Run full test suite on each build
+- Generate code coverage reports
+- Deploy to test environments
+
+## Debugging and Troubleshooting
+
+### Common Issues
+1. **Build Failures**
+   - Check for missing NuGet packages
+   - Verify .NET SDK version
+   - Ensure all projects reference correct frameworks
+
+2. **Test Failures**
+   - Review test output for specific errors
+   - Check test data and setup
+   - Verify mock configurations
+
+3. **Runtime Errors**
+   - Check logs for error details
+   - Validate configuration settings
+   - Review dependency injection setup
+
+### Debugging Tools
+- Visual Studio debugger
+- Console logging
+- Structured logging with correlation IDs
+- Performance profiling tools
+
+## Release Process
+
+### Versioning
+- Follow semantic versioning (MAJOR.MINOR.PATCH)
+- Increment version in Directory.Build.props
+- Update release notes with changes
+- Tag releases in Git
+
+### Deployment
+- Create NuGet packages for SDK components
+- Publish to internal package repository
+- Update documentation with release notes
+- Notify stakeholders of new releases
+
+## Best Practices
+
+### 1. Code Reviews
+- Review all code before merging
+- Focus on correctness, maintainability, and performance
+- Provide constructive feedback
+- Ensure adherence to coding standards
+
+### 2. Performance Considerations
+- Minimize allocations in hot paths
+- Use efficient data structures
+- Cache expensive operations
+- Profile performance regularly
+
+### 3. Security
+- Validate all inputs
+- Sanitize user data
+- Protect sensitive configuration
+- Follow secure coding practices
+
+### 4. Maintainability
+- Write self-documenting code
+- Use meaningful variable and method names
+- Keep methods small and focused
+- Refactor regularly to improve design
+
+## Task Management Without Archon
+
+Since we're not using the Archon MCP server, we'll manage tasks using:
+1. **Todo Lists**: Track progress using markdown checklists
+2. **Documentation**: Maintain detailed records of implementation decisions
+3. **Git**: Use commits and branches to track work progress
+4. **Issue Tracking**: Use GitHub Issues or similar for task management
+
+### Task Status Tracking
+- **Todo**: Task identified but not started
+- **In Progress**: Actively working on task
+- **Review**: Task completed, awaiting validation
+- **Done**: Task validated and completed
+
+## Communication and Collaboration
+
+### Team Coordination
+- Hold regular standups to discuss progress
+- Use collaborative tools for communication
+- Document architectural decisions
+- Share knowledge and best practices
+
+### Knowledge Sharing
+- Conduct code walkthroughs for complex features
+- Create technical documentation
+- Share lessons learned from issues
+- Mentor new team members
+
+## Conclusion
+
+This development workflow ensures consistent, high-quality implementation of the NT8 Institutional SDK. By following these principles and practices, we can deliver a robust, maintainable, and scalable trading platform that meets institutional requirements for risk management and performance.
+
+The workflow emphasizes systematic progress, quality assurance, and continuous improvement. Each task should be approached with thorough research, careful implementation, and comprehensive validation to ensure the highest quality outcome.