AndersPier/neural-nexus-claude-project
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add comprehensive emergency recovery procedures for context loss, performance issues, and project corruption

Browse Source
This commit is contained in:
Anders Lehmann Pier
2025-06-13 10:07:25 +02:00
parent f7e08a9046
commit ed040bd6e4
1 changed files with 320 additions and 210 deletions
Download Patch File Download Diff File Expand all files Collapse all files

530
workflow/emergency-recovery.md
View File

@@ -3,273 +3,383 @@
## Context Loss Recovery ## Context Loss Recovery
### When to Use ### When to Use
- Claude loses track of current project state - Claude has lost track of project progress
- Conversation context becomes unclear - Responses don't reflect recent work or decisions
- Previous decisions seem forgotten - Claude asks about things already established
- Development momentum stalls due to confusion - Contradictory suggestions to previous decisions
### Emergency Context Recovery Protocol
### Recovery Protocol
``` ```
# Emergency Context Recovery # Context Loss Emergency Recovery
I've lost context about this Neural Nexus project's current state. Please help me reconstruct our situation: I've lost context about this project's current state. Please help me reconstruct our situation:
## 🔍 CONVERSATION ANALYSIS ## 🔍 CONVERSATION ANALYSIS
**Recent History Review:** **Recent History Review:**
- Analyze the last 10-15 conversation exchanges in this project - Analyze the last 10-15 conversation exchanges
- Identify what we were working on most recently - Identify what we were working on most recently
- Extract any recent technical decisions or changes made - Extract any recent technical decisions or changes
- Note any blockers, issues, or priorities mentioned - Note any blockers or issues mentioned
- Determine current development stage (Exploration/Prototype/Development/Production)
## 📋 PROJECT STATE RECONSTRUCTION ## 📋 PROJECT STATE RECONSTRUCTION
**Current Development Status:** **Current Development Status:**
- What stage are we in and what are the success criteria? - What stage are we in (Exploration/Prototype/Development/Production)?
- What's our current sprint or focus area? - What's our current sprint or focus area?
- What features are completed vs in-progress vs planned? - What features are completed vs in-progress vs planned?
- What's our established technology stack and architecture approach? - What's our technology stack and architecture approach?
- What performance targets and constraints are we working within?
**Recent Technical Decisions:** **Recent Technical Decisions:**
- What architectural choices have we made recently? - What architectural choices have we made recently?
- Are there any new patterns or approaches we've adopted? - Are there any new patterns or approaches we've adopted?
- What trade-offs have we accepted in recent sessions? - What trade-offs have we accepted in recent sessions?
- Any specific implementation details or constraints to remember?
## 📚 KNOWLEDGE BASE ASSESSMENT ## 📚 KNOWLEDGE BASE ASSESSMENT
**Documentation Gaps:** **Documentation Gaps:**
- What important information isn't documented that should be? - What important information isn't documented that should be?
- Are there recent decisions that need to be captured in our knowledge base? - Are there recent decisions that need to be captured?
- What patterns or learnings should be added for future reference? - What patterns or learnings should be added to our knowledge base?
- Any outdated information that needs updating?
## 🎯 IMMEDIATE NEXT STEPS ## 🎯 IMMEDIATE NEXT STEPS
**Priority Clarification:** **Priority Clarification:**
- What should be our immediate focus for this session? - What should be our immediate focus for this session?
- Are there any urgent blockers or issues to address? - Are there any urgent blockers to address?
- What's the most important task to complete next? - What's the most important task to complete next?
- Any time-sensitive decisions or deadlines approaching?
## 📝 RECOMMENDED UPDATES ## 📝 RECOMMENDED UPDATES
**Project Configuration Updates:** **Project Configuration Updates:**
- Does our project description need updating based on current reality? - Does our project description need updating?
- Should our custom instructions be revised for current stage? - Should our custom instructions be revised?
- What knowledge base files need immediate attention or updates? - What knowledge base files need immediate attention?
- Any templates or workflows that need refinement?
Provide a comprehensive reconstruction to get us back on track efficiently. Provide a comprehensive reconstruction to get us back on track.
``` ```
### Post-Recovery Actions
1. **Immediate Documentation**: Update knowledge base with recovered context
2. **Decision Logging**: Record any clarified or rediscovered decisions
3. **Workflow Adjustment**: Refine processes to prevent future context loss
4. **Knowledge Base Cleanup**: Remove outdated or conflicting information
## Performance Degradation Recovery ## Performance Degradation Recovery
### When to Use ### Quick Performance Diagnostics
- Game running significantly slower than target frame rates ```javascript
- Memory usage increasing over time or exceeding limits // Emergency performance diagnostics
- User experience degraded compared to previous versions function emergencyPerformanceCheck() {
- Performance issues blocking further development console.log('=== EMERGENCY PERFORMANCE CHECK ===');
### Performance Recovery Protocol // Frame rate check
let frameCount = 0;
``` let startTime = performance.now();
# Performance Degradation Analysis and Recovery
function checkFrameRate() {
Neural Nexus performance has degraded below our targets. Please help identify and resolve performance issues: frameCount++;
const currentTime = performance.now();
## 📊 PERFORMANCE BASELINE ESTABLISHMENT
**Historical Performance Review:** if (currentTime - startTime >= 1000) {
- What were our original performance targets for desktop and mobile? console.log(`Current FPS: ${frameCount}`);
- What benchmarks did we establish in earlier development stages? frameCount = 0;
- When did we last measure performance comprehensively? startTime = currentTime;
- What were our best-ever performance metrics and under what conditions? }
**Current Performance Reality:** requestAnimationFrame(checkFrameRate);
- What are our current measured performance metrics across target devices? }
- Where specifically are we seeing degradation (frame rate, memory, load time)?
- How severe is the performance impact on actual user experience? checkFrameRate();
- Are there specific features, levels, or operations that are particularly slow?
// Memory check
## 🔍 DEGRADATION ANALYSIS if (performance.memory) {
**Timeline Investigation:** const memory = performance.memory;
- When did performance degradation begin (gradual vs sudden)? console.log(`Memory usage: ${(memory.usedJSHeapSize / 1024 / 1024).toFixed(2)} MB`);
- What changes, features, or code modifications coincided with performance decline? console.log(`Memory limit: ${(memory.jsHeapSizeLimit / 1024 / 1024).toFixed(2)} MB`);
- Can we identify specific commits, features, or decisions that impacted performance? }
- Are there external factors (browser updates, device changes) affecting results?
// Canvas performance check
**Root Cause Investigation:** const canvas = document.getElementById('gameCanvas');
- Analyze database query performance and optimization opportunities console.log(`Canvas size: ${canvas.width}x${canvas.height}`);
- Review frontend bundle size, loading performance, and asset optimization
- Examine API response times, bottlenecks, and potential caching improvements // Active objects count
- Investigate memory usage patterns and potential leaks or inefficient allocation console.log(`Active nodes: ${gameState.nodes.length}`);
- Assess network request efficiency, caching effectiveness, and CDN performance console.log(`Active connections: ${gameState.connections.length}`);
console.log(`Active particles: ${gameState.particles.length}`);
## 🎯 PERFORMANCE RECOVERY PLAN }
**Quick Wins (Can implement immediately):**
1. [Optimization] - [Expected impact] - [Implementation time]
2. [Optimization] - [Expected impact] - [Implementation time]
**Short-term Improvements (Next 1-2 weeks):**
1. [Optimization] - [Expected impact] - [Implementation effort]
2. [Optimization] - [Expected impact] - [Implementation effort]
**Long-term Performance Strategy (Next month+):**
1. [Optimization] - [Expected impact] - [Implementation effort]
2. [Optimization] - [Expected impact] - [Implementation effort]
## 📈 MONITORING AND PREVENTION
**Performance Monitoring Setup:**
- What metrics should we track continuously to detect future regressions?
- How can we establish automated alerts for performance degradation?
- What benchmarking process should be part of our regular development workflow?
**Development Process Improvements:**
- How can we catch performance issues during development before they reach users?
- What performance testing should be mandatory before deploying changes?
- How can we make performance considerations a standard part of code review?
## 📝 DOCUMENTATION UPDATES
**Performance Documentation:**
- Update performance targets and benchmarks based on current capabilities
- Document optimization techniques that work specifically for our technology stack
- Create performance troubleshooting guides for common issues and solutions
Provide a specific, measurable plan to restore performance and maintain it going forward.
``` ```
## Technical Debt Crisis Recovery ## Technical Debt Crisis Recovery
### When to Use ### Crisis Indicators
- Development velocity significantly slowed by accumulated technical debt - Development velocity significantly slowed
- Code quality degraded to point where adding features is extremely difficult - Simple changes require extensive refactoring
- Bug frequency increased due to complex, unmaintainable code - Bugs in one area cause problems elsewhere
- Team morale suffering due to frustrating development experience - New developers cannot understand codebase
- Performance degrading with each new feature
### Technical Debt Crisis Protocol
### Recovery Protocol
``` ```
# Technical Debt Crisis Management and Recovery # Technical Debt Crisis Management
Technical debt in Neural Nexus has accumulated to the point where it's significantly impacting our development velocity and code quality. Please help assess and manage this debt systematically: Technical debt has accumulated to critical levels. Help me assess and create a recovery plan:
## 📊 DEBT ASSESSMENT AND CATALOGING ## 📊 DEBT ASSESSMENT
**Comprehensive Debt Inventory:** **Code Quality Issues:**
- Identify all areas of significant technical debt in our codebase by category - Identify areas with the highest technical debt
- Categorize debt by type: code quality, architecture, security, performance, documentation, testing - Assess impact on development velocity
- Assess the age and growth rate of each debt item over our development timeline - Find code that's difficult to understand or modify
- Estimate the current impact of each debt area on development velocity and system reliability - Locate performance bottlenecks caused by poor design
**Debt Impact Analysis:** **Architectural Problems:**
- How is current technical debt blocking or significantly slowing new feature development? - Document architectural inconsistencies
- What features, improvements, or optimizations are we unable to implement due to existing debt? - Identify tight coupling between components
- How is accumulated debt affecting code reliability, bug rates, and system stability? - Find areas where changes cascade unpredictably
- What's the risk assessment of debt causing system failures, security vulnerabilities, or user experience problems? - Assess test coverage and maintainability
## ⚖️ DEBT PRIORITIZATION MATRIX ## ⚖️ DEBT PRIORITIZATION
**Critical Debt (Immediate Action Required - This Sprint):** **Critical Debt (Immediate Action):**
- [Debt item] - [Impact: High/Med/Low] - [Effort: High/Med/Low] - [Risk if ignored: Critical/High/Med] - Issues completely blocking new development
- [Debt item] - [Impact: High/Med/Low] - [Effort: High/Med/Low] - [Risk if ignored: Critical/High/Med] - Security vulnerabilities or data integrity risks
- Performance problems affecting user experience
**High-Priority Debt (Address Within 2-4 Weeks):** **High-Priority Debt (Address This Sprint):**
- [Debt item] - [Impact: High/Med/Low] - [Effort: High/Med/Low] - [Business justification] - Issues slowing development significantly
- [Debt item] - [Impact: High/Med/Low] - [Effort: High/Med/Low] - [Business justification] - Code that's difficult to modify safely
- Missing tests for critical functionality
**Manageable Debt (Plan for Future Sprints):** **Manageable Debt (Plan for Future):**
- [Debt item] - [Impact: High/Med/Low] - [Effort: High/Med/Low] - [Timeline to address] - Cosmetic code issues
- [Debt item] - [Impact: High/Med/Low] - [Effort: High/Med/Low] - [Timeline to address] - Documentation gaps
- Minor performance optimizations
## 🚀 DEBT REDUCTION STRATEGY ## 🚀 RECOVERY STRATEGY
**Emergency Debt Sprint (Immediate - 1 week):** **Emergency Stabilization (This Week):**
- Focus exclusively on critical debt that's completely blocking progress 1. [Action] - [Impact] - [Effort] - [Risk]
- Implement quick wins that provide immediate relief to development workflow
- Apply minimum viable fixes to restore basic development velocity and system stability
**Systematic Debt Reduction (2-4 weeks):** **Systematic Debt Reduction (Next 2-4 weeks):**
- Address high-priority debt systematically using dedicated sprint capacity 1. [Action] - [Impact] - [Effort] - [Timeline]
- Implement preventive measures and development practices to avoid creating new debt
- Establish ongoing debt monitoring, limits, and regular assessment processes
**Long-term Debt Management (Ongoing Process):** **Prevention Measures (Ongoing):**
- Implement regular debt assessment and reduction cycles as part of development workflow 1. [Process] - [Benefit] - [Implementation]
- Establish team practices and development standards that minimize debt creation
- Create sustainable balance between feature development and debt management activities
## 🛡️ DEBT PREVENTION MEASURES Provide a concrete plan to restore development velocity while managing risk.
**Development Process Improvements:**
- Implement code review practices specifically designed to catch and prevent debt early
- Establish "Definition of Done" criteria that includes debt considerations and quality gates
- Schedule regular architecture reviews, refactoring time, and technical improvement cycles
**Technical Practices and Standards:**
- Implement automated testing frameworks to prevent regression debt and maintain code quality
- Establish documentation requirements and standards for new features and architectural changes
- Define and enforce performance, security, and maintainability standards for all new code
## 📈 PROGRESS TRACKING AND ACCOUNTABILITY
**Debt Metrics and Monitoring:**
- How will we measure technical debt reduction progress objectively?
- What early warning indicators should we monitor to prevent debt accumulation?
- How will we track and maintain the balance between feature development and debt management?
**Success Criteria and Milestones:**
- Define specific, measurable goals for debt reduction with clear timelines
- Establish project milestones and checkpoints to assess progress and adjust strategy
- Identify clear success criteria for when we've successfully managed the debt crisis
Provide a concrete, time-bound plan to systematically reduce technical debt while maintaining development momentum and preventing future debt accumulation.
``` ```
### Post-Recovery Actions ## Build/Deployment Failures
1. **Process Integration**: Make debt prevention part of regular workflow
2. **Team Training**: Ensure everyone understands debt prevention practices
3. **Monitoring Setup**: Implement ongoing debt tracking and alerts
4. **Regular Reviews**: Schedule periodic debt assessment sessions
## Best Practices for Emergency Prevention ### Common Failure Modes
- Game won't load in browser
- JavaScript errors breaking functionality
- Performance degradation after deployment
- Features working locally but failing in production
### Proactive Measures ### Emergency Rollback
1. **Regular Health Checks**: Weekly project health assessments ```bash
2. **Documentation Discipline**: Update docs immediately when making decisions # Quick rollback to last known good state
3. **Decision Tracking**: Maintain clear decision history with rationale git log --oneline -10 # Find last good commit
4. **Context Preservation**: Never skip session end consolidation git reset --hard [good-commit-hash] # Rollback code
5. **Performance Monitoring**: Continuous performance tracking and alerting git push --force-with-lease origin main # Update remote (use carefully)
### Early Warning Systems # Alternative: Create hotfix
git checkout -b hotfix/emergency-fix
# Fix critical issue
git commit -m "hotfix: resolve critical issue"
git checkout main
git merge hotfix/emergency-fix
git push origin main
```
### Debugging Checklist
```markdown
**Browser Console Errors:**
- [ ] Check for JavaScript errors
- [ ] Verify all assets are loading
- [ ] Check network requests for failures
- [ ] Validate CSS is loading correctly
**Performance Issues:**
- [ ] Check frame rate in DevTools
- [ ] Monitor memory usage over time
- [ ] Verify Canvas size and resolution
- [ ] Check for memory leaks
**Functionality Broken:**
- [ ] Test core game mechanics
- [ ] Verify touch/mouse interactions
- [ ] Check level generation
- [ ] Validate score calculation
**Cross-browser Issues:**
- [ ] Test in Chrome, Firefox, Safari
- [ ] Check mobile browsers (iOS Safari, Android Chrome)
- [ ] Verify on different screen sizes
- [ ] Test with and without internet connection
```
## Project Corruption Recovery
### Signs of Corruption
- Claude Project not loading or responding
- Knowledge base files corrupted or missing
- Project instructions not being followed
- Complete loss of context across sessions
### Recovery Steps
#### 1. Backup Current State
```bash
# Clone current repositories
git clone https://github.com/AndersPier/neural-nexus-claude-project.git backup-claude-project
git clone https://github.com/AndersPier/neural-nexus-game.git backup-game
# Create recovery branch
cd neural-nexus-claude-project
git checkout -b recovery-$(date +%Y%m%d)
git push origin recovery-$(date +%Y%m%d)
```
#### 2. Create New Claude Project
```markdown
**Emergency Project Recreation:**
1. **Create New Project**: "NeuralNexus - Recovery"
2. **Copy Configuration**: Use latest project-config/ files
3. **Upload Documentation**: All knowledge-base/ files
4. **Test Context**: Run simple query to verify function
5. **Update Links**: Point to new project in documentation
```
#### 3. Validate Recovery
```
# Recovery Validation Prompt
Test the recovered project context:
**Context Verification:**
- What is the current development stage?
- What are our immediate priorities?
- What's our technology stack?
- What performance targets do we have?
**Knowledge Base Check:**
- Can you access our game design documentation?
- Do you remember our architectural decisions?
- Are our workflow templates available?
**Functionality Test:**
- Suggest next steps for audio system implementation
- Provide performance optimization recommendations
- Reference our established coding patterns
Confirm all systems are working properly.
```
## Data Loss Prevention
### Automated Backups
```bash
# Daily backup script (run via cron)
#!/bin/bash
DATE=$(date +%Y%m%d)
BACKUP_DIR="$HOME/neural-nexus-backups/$DATE"
mkdir -p "$BACKUP_DIR"
# Backup Claude Project repo
git clone https://github.com/AndersPier/neural-nexus-claude-project.git "$BACKUP_DIR/claude-project"
# Backup Game repo
git clone https://github.com/AndersPier/neural-nexus-game.git "$BACKUP_DIR/game"
# Compress backups older than 7 days
find "$HOME/neural-nexus-backups" -type d -mtime +7 -exec tar -czf {}.tar.gz {} \; -exec rm -rf {} \;
echo "Backup completed: $BACKUP_DIR"
```
### Recovery Documentation
```markdown
# Emergency Contact Information
**Repository Locations:**
- Claude Project: https://github.com/AndersPier/neural-nexus-claude-project
- Game Repository: https://github.com/AndersPier/neural-nexus-game
- Live Game: https://andersPier.github.io/neural-nexus-game/
**Critical Files:**
- Project Config: project-config/project-description.md
- Project Instructions: project-config/project-instructions.md
- Session Templates: templates/
- Core Documentation: knowledge-base/
**Recovery Priority:**
1. Game repository (contains working product)
2. Project configuration (enables Claude workflow)
3. Knowledge base (captures decisions and patterns)
4. Templates (workflow efficiency)
```
## Prevention Strategies
### Regular Health Checks
```markdown
**Weekly Health Check:**
- [ ] Test Claude Project responsiveness
- [ ] Verify all repository links work
- [ ] Check game deployment status
- [ ] Validate documentation is current
- [ ] Confirm backup systems functioning
**Monthly Deep Check:**
- [ ] Full context recovery test
- [ ] Performance baseline verification
- [ ] Knowledge base organization review
- [ ] Template effectiveness assessment
- [ ] Emergency procedure practice run
```
### Monitoring Setup
```javascript ```javascript
// Emergency warning indicators to watch for // Project health monitoring
const emergencyIndicators = { class ProjectHealthMonitor {
contextLoss: [ constructor() {
'Repeating previously answered questions', this.healthChecks = [];
'Contradicting earlier decisions', this.alerts = [];
'Unclear about current project state', }
'Asking for information already provided'
],
performanceDrift: [ addHealthCheck(name, checkFunction, interval) {
'Frame rate below targets consistently', setInterval(() => {
'Memory usage trending upward', try {
'User complaints about responsiveness', const result = checkFunction();
'Load times increasing over time' this.recordHealth(name, result);
], } catch (error) {
this.recordAlert(name, error);
}
}, interval);
}
technicalDebt: [ recordHealth(check, result) {
'Feature development velocity slowing', this.healthChecks.push({
'Bug frequency increasing', check,
'Code changes requiring extensive refactoring', result,
'Team avoiding certain areas of codebase' timestamp: Date.now(),
] status: result.healthy ? 'good' : 'warning'
}; });
}
recordAlert(check, error) {
this.alerts.push({
check,
error: error.message,
timestamp: Date.now(),
severity: 'high'
});
console.error(`Health check failed: ${check}`, error);
}
getHealthReport() {
const recent = this.healthChecks.slice(-20);
const recentAlerts = this.alerts.slice(-5);
return {
overallHealth: recent.filter(h => h.status === 'good').length / recent.length,
recentAlerts,
lastCheck: recent[recent.length - 1]?.timestamp
};
}
}
``` ```
### Recovery Success Metrics Remember: The best recovery is prevention. Regular consolidation, systematic documentation, and proactive monitoring prevent most emergencies from occurring.
- **Context Recovery**: Clear understanding of current state and priorities
- **Performance Recovery**: Metrics back within target ranges
- **Debt Recovery**: Development velocity restored, bug frequency reduced
- **Process Improvement**: Prevention measures implemented and working
Remember: Emergency recovery is about getting back on track quickly, not perfect solutions. Focus on immediate restoration first, then systematic improvement.