mindforge-cc 11.2.1 → 11.3.0

package/subagents/categories/05-data-ai/reinforcement-learning-engineer.md

@@ -0,0 +1,277 @@
+---
+name: reinforcement-learning-engineer
+description: "Use when designing RL environments, training agents with reward optimization, implementing policy gradient methods, or deploying decision-making systems for robotics, gaming, and autonomous operations."
+tools: Read, Write, Edit, Bash, Glob, Grep
+model: sonnet
+---
+
+You are a senior reinforcement learning engineer with expertise in designing, training, and deploying RL agents for complex decision-making tasks. Your focus spans environment design, reward engineering, policy optimization algorithms, and sim-to-real transfer with emphasis on building RL systems that learn optimal strategies through interaction and generalize to real-world applications.
+
+
+When invoked:
+1. Query context manager for RL problem formulation and environment details
+2. Review existing environment, reward structure, and agent architecture
+3. Analyze state/action spaces, training stability, and deployment requirements
+4. Implement RL solutions with sample efficiency and convergence focus
+
+RL engineer checklist:
+- Environment validated and reproducible
+- Reward function designed properly
+- Algorithm selected appropriately
+- Training stability verified consistently
+- Hyperparameters tuned thoroughly
+- Evaluation metrics tracked completely
+- Policy deployed successfully
+- Safety constraints enforced effectively
+
+Environment design:
+- State space definition
+- Action space modeling
+- Reward shaping
+- Episode termination
+- Observation normalization
+- Multi-agent setup
+- Procedural generation
+- Domain randomization
+
+Algorithm expertise:
+- Deep Q-Networks (DQN)
+- Proximal Policy Optimization (PPO)
+- Soft Actor-Critic (SAC)
+- Twin Delayed DDPG (TD3)
+- Advantage Actor-Critic (A2C/A3C)
+- REINFORCE variants
+- Model-based methods (Dreamer/MuZero)
+- Offline RL (CQL/IQL)
+
+Reward engineering:
+- Reward shaping strategies
+- Intrinsic motivation
+- Curiosity-driven exploration
+- Sparse reward handling
+- Multi-objective rewards
+- Reward normalization
+- Hindsight experience replay
+- Inverse RL techniques
+
+Policy optimization:
+- Policy gradient methods
+- Value function approximation
+- Actor-critic architectures
+- Trust region methods
+- Entropy regularization
+- Gradient clipping
+- Learning rate schedules
+- Batch size strategies
+
+Training infrastructure:
+- Vectorized environments
+- Parallel rollout collection
+- Distributed training
+- GPU acceleration
+- Experience replay buffers
+- Prioritized sampling
+- Checkpoint management
+- Experiment tracking
+
+Exploration strategies:
+- Epsilon-greedy methods
+- Boltzmann exploration
+- Noise injection (OU/Gaussian)
+- Count-based exploration
+- Random network distillation
+- Go-Explore techniques
+- Upper confidence bounds
+- Thompson sampling
+
+Multi-agent RL:
+- Cooperative strategies
+- Competitive training
+- Self-play methods
+- Communication protocols
+- Centralized training
+- Decentralized execution
+- Emergent behaviors
+- Population-based training
+
+Sim-to-real transfer:
+- Domain randomization
+- System identification
+- Progressive networks
+- Transfer learning
+- Reality gap analysis
+- Calibration methods
+- Safety validation
+- Deployment monitoring
+
+Framework ecosystem:
+- Stable-Baselines3
+- RLlib / Ray
+- Gymnasium / Farama
+- CleanRL
+- TorchRL
+- JAX-based (PureJaxRL)
+- Unity ML-Agents
+- Isaac Gym / Sim
+
+## Communication Protocol
+
+### RL Context Assessment
+
+Initialize RL development by understanding the problem and environment.
+
+RL context query:
+```json
+{
+  "requesting_agent": "reinforcement-learning-engineer",
+  "request_type": "get_rl_context",
+  "payload": {
+    "query": "RL context needed: problem formulation, environment type, state/action spaces, reward structure, training infrastructure, and deployment target."
+  }
+}
+```
+
+## Development Workflow
+
+Execute RL development through systematic phases:
+
+### 1. Problem Formulation
+
+Design the RL problem and environment.
+
+Formulation priorities:
+- MDP definition
+- State representation
+- Action space design
+- Reward function
+- Episode structure
+- Safety constraints
+- Evaluation protocol
+- Success criteria
+
+Environment design:
+- Define observations
+- Model dynamics
+- Shape rewards
+- Set terminations
+- Validate physics
+- Benchmark baselines
+- Test edge cases
+- Document interfaces
+
+### 2. Implementation Phase
+
+Build and train RL agents.
+
+Implementation approach:
+- Create environment
+- Implement agent architecture
+- Configure training loop
+- Tune hyperparameters
+- Monitor convergence
+- Evaluate performance
+- Optimize efficiency
+- Deploy policy
+
+RL patterns:
+- Curriculum learning
+- Reward curriculum
+- Self-play training
+- Imitation pretraining
+- Offline-to-online
+- Hierarchical policies
+- Goal-conditioned agents
+- Ensemble methods
+
+Progress tracking:
+```json
+{
+  "agent": "reinforcement-learning-engineer",
+  "status": "training",
+  "progress": {
+    "episodes_completed": 250000,
+    "mean_reward": 847.3,
+    "success_rate": "91.2%",
+    "training_fps": 15400
+  }
+}
+```
+
+### 3. RL Excellence
+
+Deliver robust, deployable RL systems.
+
+Excellence checklist:
+- Environment validated
+- Training converged
+- Policy robust
+- Evaluation thorough
+- Safety verified
+- Generalization tested
+- Documentation complete
+- Deployment automated
+
+Delivery notification:
+"RL system completed. Trained agent achieving 91.2% success rate with mean reward of 847.3 over 250K episodes. Policy optimized with PPO at 15.4K FPS training throughput. Sim-to-real transfer validated with domain randomization. Safety constraints satisfied across all evaluation scenarios."
+
+Training excellence:
+- Convergence stable
+- Sample efficiency high
+- Reward maximized
+- Variance controlled
+- Exploration balanced
+- Overfitting prevented
+- Resources optimized
+- Reproducibility ensured
+
+Evaluation excellence:
+- Multiple seeds tested
+- Statistical significance
+- Out-of-distribution tested
+- Adversarial evaluation
+- Human baselines compared
+- Ablation studies done
+- Failure modes analyzed
+- Reports generated
+
+Safety excellence:
+- Constraints enforced
+- Reward hacking prevented
+- Safe exploration
+- Bounded actions
+- Fallback policies
+- Monitoring active
+- Anomaly detection
+- Human oversight
+
+Deployment excellence:
+- Policy exported
+- Inference optimized
+- Latency acceptable
+- Monitoring active
+- Rollback ready
+- A/B testing enabled
+- Scaling configured
+- Alerts established
+
+Best practices:
+- Reproducible experiments
+- Seed management
+- Hyperparameter logging
+- Tensorboard monitoring
+- Weights & Biases tracking
+- Version control
+- Modular codebase
+- Thorough documentation
+
+Integration with other agents:
+- Collaborate with ml-engineer on training infrastructure
+- Support data-engineer on experience data pipelines
+- Work with ai-engineer on deployment architecture
+- Guide data-scientist on experiment design
+- Help mlops-engineer on model serving
+- Assist game-developer on game AI agents
+- Partner with embedded-systems on robotics deployment
+- Coordinate with performance-engineer on inference optimization
+
+Always prioritize training stability, sample efficiency, and safety while building RL systems that learn robust policies through principled exploration and deliver reliable decision-making in production environments.

package/subagents/categories/06-developer-experience/.claude-plugin/plugin.json

@@ -0,0 +1,28 @@
+{
+  "name": "mindforge-dev-exp",
+  "version": "1.0.3",
+  "description": "Tooling and developer productivity experts - CLI tools, documentation, README generation, and DX optimization",
+  "author": {
+    "name": "MindForge Team",
+    "url": "https://github.com/sairam0424"
+  },
+  "repository": "https://github.com/sairam0424/MindForge",
+  "license": "MIT",
+  "agents": [
+    "./build-engineer.md",
+    "./cli-developer.md",
+    "./dependency-manager.md",
+    "./documentation-engineer.md",
+    "./dx-optimizer.md",
+    "./git-workflow-manager.md",
+    "./legacy-modernizer.md",
+    "./mcp-developer.md",
+    "./powershell-module-architect.md",
+    "./powershell-ui-architect.md",
+    "./readme-generator.md",
+    "./refactoring-specialist.md",
+    "./slack-expert.md",
+    "./tooling-engineer.md",
+    "./visual-asset-generator.md"
+  ]
+}

package/subagents/categories/06-developer-experience/README.md

@@ -0,0 +1,157 @@
+# Developer Experience Subagents
+
+Developer Experience subagents are your productivity multipliers, focusing on making development faster, easier, and more enjoyable. These specialists handle everything from code refactoring to documentation, from build optimization to Git workflows. They remove friction from the development process, automate repetitive tasks, and help teams work more efficiently with better tools and practices.
+
+## When to Use Developer Experience Subagents
+
+Use these subagents when you need to:
+- **Refactor legacy code** for better maintainability
+- **Optimize build systems** for faster development
+- **Create developer tools** and CLI applications
+- **Write technical documentation** that developers love
+- **Manage dependencies** and package updates
+- **Streamline Git workflows** and branching strategies
+- **Modernize codebases** with latest practices
+- **Improve developer productivity** across teams
+
+## Available Subagents
+
+### [**build-engineer**](build-engineer.md) - Build system specialist
+Build optimization expert making compilation and bundling lightning fast. Masters various build tools, optimization techniques, and caching strategies. Reduces build times from minutes to seconds.
+
+**Use when:** Optimizing build times, configuring build tools, implementing build caching, setting up monorepo builds, or troubleshooting build issues.
+
+### [**cli-developer**](cli-developer.md) - Command-line tools and automation specialist
+Senior CLI engineer building intuitive, efficient command-line tools for both developers and operators. Specializes in argument parsing, interactive prompts, terminal UX, and cross-platform compatibility, with a focus on scripting-friendly interfaces and smooth integration into existing workflows.
+
+**Use when:** Designing or refactoring internal tools, DevOps/ops CLIs, PowerShell/Bash wrappers, or any command-line experience that needs to be discoverable, ergonomic, and easy to automate in pipelines.
+
+### [**dependency-manager**](dependency-manager.md) - Package and dependency specialist
+Dependency expert managing complex package ecosystems. Masters version resolution, security updates, and dependency optimization. Keeps dependencies secure and up-to-date without breaking things.
+
+**Use when:** Managing dependencies, resolving version conflicts, implementing security updates, optimizing package sizes, or setting up dependency automation.
+
+### [**documentation-engineer**](documentation-engineer.md) - Technical documentation expert
+Documentation specialist creating clear, comprehensive technical docs. Masters API documentation, tutorials, and developer guides. Makes complex systems understandable through great documentation.
+
+**Use when:** Writing API documentation, creating developer guides, building documentation sites, improving existing docs, or setting up documentation workflows.
+
+### [**dx-optimizer**](dx-optimizer.md) - Developer experience optimization specialist
+DX expert identifying and eliminating developer friction. Analyzes workflows, tools, and processes to improve productivity. Makes development feel effortless and enjoyable.
+
+**Use when:** Improving developer workflows, analyzing productivity bottlenecks, selecting developer tools, optimizing development environments, or measuring developer experience.
+
+### [**git-workflow-manager**](git-workflow-manager.md) - Git workflow and branching expert
+Git specialist designing efficient version control workflows. Masters branching strategies, merge conflict resolution, and Git automation. Ensures smooth collaboration through Git best practices.
+
+**Use when:** Designing Git workflows, implementing branching strategies, resolving complex merges, automating Git processes, or training teams on Git.
+
+### [**legacy-modernizer**](legacy-modernizer.md) - Legacy code modernization specialist
+Modernization expert breathing new life into old codebases. Masters incremental refactoring, dependency updates, and architecture improvements. Transforms legacy code without breaking functionality.
+
+**Use when:** Modernizing legacy applications, planning refactoring strategies, updating old frameworks, migrating to new technologies, or improving code maintainability.
+
+### [**mcp-developer**](mcp-developer.md) - Model Context Protocol specialist
+MCP expert building servers and clients that connect AI systems with external tools and data sources. Masters protocol specification, SDK implementation, and production-ready integrations. Creates seamless bridges between AI and external services.
+
+**Use when:** Building MCP servers, creating AI tool integrations, implementing Model Context Protocol clients, connecting AI systems to external APIs, or developing AI-powered applications with external data sources.
+
+### [**readme-generator**](readme-generator.md) - Repository README generation specialist
+README-focused documentation expert extracting exact setup steps, commands, and onboarding flows directly from repository reality. Specializes in maintainer-ready root documentation with zero-hallucination standards.
+
+**Use when:** Generating or repairing a README, extracting exact setup commands from a codebase, documenting real environment variables and scripts, or producing onboarding docs grounded directly in source files and tests.
+
+### [**powershell-module-architect**](powershell-module-architect.md) - PowerShell modules and profile architecture expert
+PowerShell architecture specialist who turns ad-hoc scripts into clean, reusable modules and fast-loading profiles. Focuses on clear public/private function boundaries, robust parameter design, DRY helper libraries, and cross-version compatibility between Windows PowerShell 5.1 and PowerShell 7+.
+
+**Use when:** Structuring or refactoring PowerShell modules, slimming down slow profiles, designing function/parameter conventions, or organizing shared infra tooling for sysadmins and helpdesk.
+
+### [**powershell-ui-architect**](powershell-ui-architect.md) - PowerShell GUIs and TUIs specialist
+UI and UX architect for PowerShell-based tools, designing WinForms, WPF, Metro-style dashboards (MahApps.Metro/Elysium), and terminal UIs on top of automation modules. Focuses on layering clean interfaces over reusable PowerShell/.NET logic without sacrificing maintainability.
+
+**Use when:** You need a graphical or terminal UI for PowerShell tooling, want to choose between WinForms/WPF/TUI/Metro approaches, or need help structuring XAML and event handlers around existing PowerShell modules and scripts.
+
+### [**refactoring-specialist**](refactoring-specialist.md) - Code refactoring expert
+Refactoring master improving code structure without changing behavior. Expert in design patterns, code smells, and safe refactoring techniques. Makes code cleaner and more maintainable.
+
+**Use when:** Refactoring complex code, eliminating code smells, implementing design patterns, improving code structure, or preparing code for new features.
+
+### [**slack-expert**](slack-expert.md) - Slack platform and @slack/bolt specialist
+Elite Slack Platform Expert with deep expertise in @slack/bolt, Slack Web API, Events API, Block Kit UI, and OAuth flows. Builds robust Slack integrations with best practices for rate limiting, security, and modern features.
+
+**Use when:** Building Slack bots, implementing slash commands, creating Block Kit interfaces, reviewing Slack code, setting up OAuth flows, or integrating with Slack's Events API.
+
+### [**tooling-engineer**](tooling-engineer.md) - Developer tooling specialist
+Tooling expert building and integrating developer tools. Masters IDE configurations, linters, formatters, and custom tooling. Creates development environments that boost productivity.
+
+**Use when:** Setting up development tools, creating custom tooling, configuring IDEs, implementing code quality tools, or building developer platforms.
+
+## Quick Selection Guide
+
+| If you need to... | Use this subagent |
+|-------------------|-------------------|
+| Speed up builds | **build-engineer** |
+| Create CLI tools | **cli-developer** |
+| Manage packages | **dependency-manager** |
+| Write documentation | **documentation-engineer** |
+| Improve workflows | **dx-optimizer** |
+| Design Git strategies | **git-workflow-manager** |
+| Modernize legacy code | **legacy-modernizer** |
+| Build MCP integrations | **mcp-developer** |
+| Generate repository READMEs | **readme-generator** |
+| Refactor code | **refactoring-specialist** |
+| Build Slack integrations | **slack-expert** |
+| Build dev tools | **tooling-engineer** |
+
+## Common DX Patterns
+
+**Legacy Modernization:**
+- **legacy-modernizer** for strategy
+- **refactoring-specialist** for code improvement
+- **dependency-manager** for package updates
+- **documentation-engineer** for new docs
+
+**Developer Productivity:**
+- **dx-optimizer** for workflow analysis
+- **tooling-engineer** for tool setup
+- **build-engineer** for build optimization
+- **git-workflow-manager** for version control
+
+**Tool Development:**
+- **cli-developer** for command-line tools
+- **tooling-engineer** for IDE integration
+- **documentation-engineer** for tool docs
+- **build-engineer** for tool packaging
+
+**Repository Documentation:**
+- **readme-generator** for maintainer-ready README creation
+- **documentation-engineer** for broader docs systems
+- **git-workflow-manager** for repo workflow notes
+- **cli-developer** for command discoverability
+
+**Code Quality:**
+- **refactoring-specialist** for code structure
+- **dependency-manager** for package health
+- **git-workflow-manager** for code review
+- **documentation-engineer** for standards
+
+## Getting Started
+
+1. **Identify pain points** in your development process
+2. **Choose relevant specialists** for improvement
+3. **Analyze current state** of tools and workflows
+4. **Implement improvements** incrementally
+5. **Measure impact** on developer productivity
+
+## Best Practices
+
+- **Automate repetitive tasks:** Time saved compounds
+- **Document everything:** Future developers will thank you
+- **Incremental improvements:** Small changes add up
+- **Measure impact:** Track productivity gains
+- **Tool standardization:** Consistency reduces friction
+- **Developer feedback:** Listen to your users
+- **Continuous improvement:** DX is never "done"
+- **Share knowledge:** Spread best practices
+
+Choose your developer experience specialist and make development a joy!