feat: prepare releases on release branches

.cursor/.gitignore

@@ -0,0 +1 @@
+plans/

.cursor/commands/accessibility-audit.md

@@ -0,0 +1,41 @@
+# Accessibility Audit
+
+## Overview
+
+Perform comprehensive accessibility (a11y) audit of the current UI code to ensure compliance with WCAG guidelines and provide an inclusive user experience.
+
+## Steps
+
+1. **WCAG Compliance**
+    - Check conformance to WCAG 2.1 guidelines (A, AA, AAA levels)
+    - Verify proper semantic HTML structure
+    - Ensure keyboard navigation support
+    - Review color contrast and visual accessibility
+2. **Screen Reader Support**
+    - Validate ARIA labels and descriptions
+    - Check heading hierarchy and structure
+    - Ensure form labels and error messages are accessible
+    - Review dynamic content announcements
+3. **Interactive Elements**
+    - Verify focus management and visible focus indicators
+    - Check tab order and keyboard shortcuts
+    - Ensure interactive elements are properly sized
+    - Review modal and dialog accessibility
+4. **Testing & Tools**
+    - Suggest automated accessibility testing tools
+    - Provide manual testing procedures
+    - Create accessibility test cases
+    - Recommend browser extensions and validators
+5. **Remediation**
+    - Provide specific code fixes for each issue
+    - Include ARIA attributes and semantic improvements
+    - Suggest alternative approaches for complex interactions
+    - Create accessible component patterns
+
+## Accessibility Audit Checklist
+
+- [ ] WCAG compliance verified
+- [ ] Screen reader support validated
+- [ ] Interactive elements accessible
+- [ ] Testing tools recommended
+- [ ] Remediation code provided with examples

.cursor/commands/address-github-pr-comments.md

@@ -0,0 +1,32 @@
+# Address GitHub PR Comments
+
+## Overview
+
+Process outstanding reviewer feedback, apply required fixes, and draft clear responses for each GitHub pull-request comment.
+
+## Steps
+
+1. **Sync and audit comments**
+    - Pull the latest branch changes
+    - Open the PR conversation view and read every unresolved comment
+    - Group comments by affected files or themes
+2. **Plan resolutions**
+    - List the requested code edits for each thread
+    - Identify clarifications or additional context you must provide
+    - Note any dependencies or blockers before implementing changes
+3. **Implement fixes**
+    - Apply targeted updates addressing one comment thread at a time
+    - Run relevant tests or linters after impactful changes
+    - Stage changes with commits that reference the addressed feedback
+4. **Draft responses**
+    - Summarize the action taken or reasoning provided for each comment
+    - Link to commits or lines when clarification helps reviewers verify
+    - Highlight any remaining questions or follow-up needs
+
+## Response Checklist
+
+- [ ] All reviewer comments acknowledged
+- [ ] Required code changes implemented and tested
+- [ ] Clarifying explanations prepared for nuanced threads
+- [ ] Follow-up items documented or escalated
+- [ ] PR status updated for reviewers

.cursor/commands/code-review.md

@@ -0,0 +1,54 @@
+# Code Review
+
+## Overview
+
+Perform a thorough code review that verifies functionality, maintainability, and security before approving a change. Focus on architecture, readability, performance implications, and provide actionable suggestions for improvement.
+
+## Steps
+
+1. **Understand the change**
+    - Read the PR description and related issues for context
+    - Identify the scope of files and features impacted
+    - Note any assumptions or questions to clarify with the author
+2. **Validate functionality**
+    - Confirm the code delivers the intended behavior
+    - Exercise edge cases or guard conditions mentally or by running locally
+    - Check error handling paths and logging for clarity
+3. **Assess quality**
+    - Ensure functions are focused, names are descriptive, and code is readable
+    - Watch for duplication, dead code, or missing tests
+    - Verify documentation and comments reflect the latest changes
+4. **Review security and risk**
+    - Look for injection points, insecure defaults, or missing validation
+    - Confirm secrets or credentials are not exposed
+    - Evaluate performance or scalability impacts of the change
+
+## Review Checklist
+
+### Functionality
+
+- [ ] Intended behavior works and matches requirements
+- [ ] Edge cases handled gracefully
+- [ ] Error handling is appropriate and informative
+
+### Code Quality
+
+- [ ] Code structure is clear and maintainable
+- [ ] No unnecessary duplication or dead code
+- [ ] Tests/documentation updated as needed
+
+### Security & Safety
+
+- [ ] No obvious security vulnerabilities introduced
+- [ ] Inputs validated and outputs sanitized
+- [ ] Sensitive data handled correctly
+
+## Additional Review Notes
+
+- Architecture and design decisions considered
+- Performance bottlenecks or regressions assessed
+- Coding standards and best practices followed
+- Resource management, error handling, and logging reviewed
+- Suggested alternatives, additional test cases, or documentation updates captured
+
+Provide constructive feedback with concrete examples and actionable guidance for the author.

.cursor/commands/optimize-performance.md

@@ -0,0 +1,35 @@
+# Optimize Performance
+
+## Overview
+
+Analyze the current code for performance bottlenecks and provide optimization recommendations, focusing on measurable improvements while maintaining code quality and readability.
+
+## Steps
+
+1. **Performance Analysis**
+    - Identify slow algorithms and inefficient data structures
+    - Find memory leaks and excessive allocations
+    - Detect unnecessary computations and redundant operations
+    - Analyze database queries and API calls
+2. **Optimization Strategies**
+    - Suggest algorithm improvements and better data structures
+    - Recommend caching strategies where appropriate
+    - Propose lazy loading and pagination solutions
+    - Identify opportunities for parallel processing
+3. **Implementation**
+    - Provide optimized code with explanations
+    - Include performance impact estimates
+    - Suggest profiling and monitoring approaches
+    - Consider trade-offs between performance and maintainability
+
+## Optimize Performance Checklist
+
+- [ ] Identified slow algorithms and inefficient data structures
+- [ ] Found memory leaks and excessive allocations
+- [ ] Detected unnecessary computations and redundant operations
+- [ ] Analyzed database queries and API calls
+- [ ] Suggested algorithm improvements and better data structures
+- [ ] Recommended caching strategies where appropriate
+- [ ] Provided optimized code with explanations
+- [ ] Included performance impact estimates
+- [ ] Considered trade-offs between performance and maintainability

.cursor/commands/refactor-code.md

@@ -0,0 +1,35 @@
+# Refactor Code
+
+## Overview
+
+Refactor the selected code to improve its quality while maintaining the same functionality, providing the refactored code with explanations of the improvements made.
+
+## Steps
+
+1. **Code Quality Improvements**
+    - Extract reusable functions or components
+    - Eliminate code duplication
+    - Improve variable and function naming
+    - Simplify complex logic and reduce nesting
+2. **Performance Optimizations**
+    - Identify and fix performance bottlenecks
+    - Optimize algorithms and data structures
+    - Reduce unnecessary computations
+    - Improve memory usage
+3. **Maintainability**
+    - Make the code more readable and self-documenting
+    - Add appropriate comments where needed
+    - Follow SOLID principles and design patterns
+    - Improve error handling and edge case coverage
+
+## Refactor Code Checklist
+
+- [ ] Extracted reusable functions or components
+- [ ] Eliminated code duplication
+- [ ] Improved variable and function naming
+- [ ] Simplified complex logic and reduced nesting
+- [ ] Identified and fixed performance bottlenecks
+- [ ] Optimized algorithms and data structures
+- [ ] Made code more readable and self-documenting
+- [ ] Followed SOLID principles and design patterns
+- [ ] Improved error handling and edge case coverage

.cursor/commands/security-audit.md

@@ -0,0 +1,28 @@
+# Security Audit
+
+## Overview
+
+Comprehensive security review to identify and fix vulnerabilities in the codebase.
+
+## Steps
+
+1. **Dependency audit**
+    - Check for known vulnerabilities
+    - Update outdated packages
+    - Review third-party dependencies
+2. **Code security review**
+    - Check for common vulnerabilities
+    - Review authentication/authorization
+    - Audit data handling practices
+3. **Infrastructure security**
+    - Review environment variables
+    - Check access controls
+    - Audit network security
+
+## Security Checklist
+
+- [ ] Dependencies updated and secure
+- [ ] No hardcoded secrets
+- [ ] Input validation implemented
+- [ ] Authentication secure
+- [ ] Authorization properly configured

.cursor/commands/write-unit-tests.md

@@ -0,0 +1,42 @@
+# Write Unit Tests
+
+## Overview
+
+Create comprehensive unit tests for the current code and generate the test file with proper imports and setup according to the project's testing conventions.
+
+## Steps
+
+1. **Test Coverage**
+    - Test all public methods and functions
+    - Cover edge cases and error conditions
+    - Test both positive and negative scenarios
+    - Aim for high code coverage
+2. **Test Structure**
+    - Use the project's testing framework conventions
+    - Write clear, descriptive test names
+    - Follow the Arrange-Act-Assert pattern
+    - Group related tests logically
+3. **Test Cases to Include**
+    - Happy path scenarios
+    - Edge cases and boundary conditions
+    - Error handling and exception cases
+    - Mock external dependencies appropriately
+4. **Test Quality**
+    - Make tests independent and isolated
+    - Ensure tests are deterministic and repeatable
+    - Keep tests simple and focused on one thing
+    - Add helpful assertion messages
+
+## Write Unit Tests Checklist
+
+- [ ] Tested all public methods and functions
+- [ ] Covered edge cases and error conditions
+- [ ] Tested both positive and negative scenarios
+- [ ] Used the project's testing framework conventions
+- [ ] Written clear, descriptive test names
+- [ ] Followed the Arrange-Act-Assert pattern
+- [ ] Included happy path scenarios
+- [ ] Included edge cases and boundary conditions
+- [ ] Mocked external dependencies appropriately
+- [ ] Made tests independent and isolated
+- [ ] Ensured tests are deterministic and repeatable

.cursor/rules/core-development.mdc

@@ -0,0 +1,37 @@
+---
+description: Core development workflow and critical thinking rules
+alwaysApply: true
+---
+
+# Core Development
+
+Read `AGENTS.md` at the repository root for full project standards, coding conventions, and architecture.
+
+## Critical Partner Mindset
+
+Do not affirm my statements or assume my conclusions are correct. Question assumptions, offer counterpoints, test reasoning. Prioritize truth over agreement.
+
+## Execution Sequence (always reply with "Applying rules X,Y,Z")
+
+1. SEARCH FIRST - Search the codebase until finding similar functionality or confirming none exists. Investigate deeply, be 100% sure before implementing.
+2. REUSE FIRST - Check existing functions/patterns/structure. Extend before creating new. Strive to smallest possible code changes.
+3. NO ASSUMPTIONS - Only use: files read, user messages, tool results. Missing info? Search then ask user.
+4. CHALLENGE IDEAS - If you see flaws/risks/better approaches, say so directly.
+5. BE HONEST - State what's needed/problematic, don't sugarcoat to please.
+6. SELF-CHECK - Periodically self-check rule compliance during long conversations.
+7. RULE REFRESH - Re-check this rules file every few messages to stay compliant.
+
+## Coding Standards
+
+- Plan before coding, explain reasoning for complex suggestions
+- Follow the code comment guidance in `AGENTS.md`
+- Keep imports alphabetically sorted
+- Keep code SOLID but simple - separation of concerns without over-engineering
+- Treat file length as a signal; split only for reuse, meaningful separation, or clearer testing
+- Follow the testing requirements in `AGENTS.md`. Use the AAA pattern.
+- Run `npm run lint` for lint check
+
+## Prohibited Actions
+
+- DO NOT WRITE DOCS UNLESS EXPLICITLY ASKED TO
+- NEVER run `npm run watch` command - assume dev servers always running