---
phase: 04-memory-context-management
plan: 05
type: execute
wave: 1
depends_on: ["04-04"]
files_modified: ["src/memory/personality/adaptation.py", "src/memory/__init__.py", "src/personality.py"]
autonomous: true
gap_closure: true

must_haves:
  truths:
    - "Personality layers learn from conversation patterns"
    - "Personality system integrates with existing personality.py"
  artifacts:
    - path: "src/memory/personality/adaptation.py"
      provides: "Dynamic personality updates"
      min_lines: 50
    - path: "src/memory/__init__.py"
      provides: "Complete MemoryManager with personality learning"
      exports: ["PersonalityLearner"]
    - path: "src/personality.py"
      provides: "Updated personality system with memory integration"
      min_lines: 20
  key_links:
    - from: "src/memory/personality/adaptation.py"
      to: "src/memory/personality/layer_manager.py"
      via: "layer updates for adaptation"
      pattern: "layer_manager\\.update_layer"
    - from: "src/memory/__init__.py"
      to: "src/memory/personality/adaptation.py"
      via: "PersonalityLearner integration"
      pattern: "PersonalityLearner.*update_personality"
    - from: "src/personality.py"
      to: "src/memory/personality/layer_manager.py"
      via: "personality overlay application"
      pattern: "layer_manager\\.get_active_layers"
---

<objective>
Complete personality learning integration by implementing missing PersonalityAdaptation class and connecting all personality learning components to the MemoryManager and existing personality system.

Purpose: Close the personality learning integration gap identified in verification
Output: Working personality learning system fully integrated with memory and personality systems
</objective>

<execution_context>
@~/.opencode/get-shit-done/workflows/execute-plan.md
@~/.opencode/get-shit-done/templates/summary.md
</execution_context>

<context>
@.planning/phases/04-memory-context-management/04-CONTEXT.md
@.planning/phases/04-memory-context-management/04-RESEARCH.md
@.planning/phases/04-memory-context-management/04-memory-context-management-VERIFICATION.md

# Reference existing personality components
@src/memory/personality/pattern_extractor.py
@src/memory/personality/layer_manager.py
@src/resource/personality.py

# Reference memory manager
@src/memory/__init__.py
</context>

<tasks>

<task type="auto">
  <name>Task 1: Implement PersonalityAdaptation class</name>
  <files>src/memory/personality/adaptation.py</files>
  <action>
Create src/memory/personality/adaptation.py with PersonalityAdaptation class to close the missing file gap:

1. PersonalityAdaptation class with time-weighted learning:
   - update_personality_layer(patterns, layer_id, adaptation_rate)
   - calculate_adaptation_rate(conversation_history, user_feedback)
   - apply_stability_controls(proposed_changes, current_state)
   - integrate_user_feedback(feed_data, layer_weights)

2. Time-weighted learning implementation:
   - Recent conversations have less influence (exponential decay)
   - Historical patterns provide stable baseline
   - Prevent rapid personality swings with rate limiting
   - Confidence scoring for pattern reliability

3. Stability controls:
   - Maximum change per update (e.g., 10% weight shift)
   - Cooling period between major adaptations
   - Core value protection (certain aspects never change)
   - Reversion triggers for unwanted changes

4. Integration methods:
   - import_pattern_data(pattern_extractor, conversation_range)
   - export_layer_config(layer_manager, output_format)
   - validate_layer_consistency(layers, core_personality)

5. Configuration and persistence:
   - Learning rate configuration (slow/medium/fast)
   - Adaptation history tracking
   - Rollback capability for problematic changes
   - Integration with existing memory storage

Follow existing error handling patterns from layer_manager.py. Use similar data structures and method signatures for consistency.
  </action>
  <verify>python -c "from src.memory.personality.adaptation import PersonalityAdaptation; pa = PersonalityAdaptation(); print('PersonalityAdaptation created successfully')"</verify>
  <done>PersonalityAdaptation class provides time-weighted learning with stability controls</done>
</task>

<task type="auto">
  <name>Task 2: Integrate personality learning with MemoryManager</name>
  <files>src/memory/__init__.py</files>
  <action>
Update src/memory/__init__.py to integrate personality learning and export PersonalityLearner:

1. Import PersonalityAdaptation in memory/personality/__init__.py:
   - Add from .adaptation import PersonalityAdaptation
   - Update __all__ to include PersonalityAdaptation

2. Create PersonalityLearner class in MemoryManager:
   - Combines PatternExtractor, LayerManager, and PersonalityAdaptation
   - Methods: learn_from_conversations(conversation_range), apply_learning(), get_current_personality()
   - Learning triggers: after conversations, periodic updates, manual requests

3. Integration with existing MemoryManager:
   - Add personality_learner attribute to MemoryManager.__init__
   - Implement learning_workflow() method for coordinated learning
   - Add personality data persistence to existing storage
   - Provide learning controls (enable/disable, rate, triggers)

4. Export PersonalityLearner from memory/__init__.py:
   - Add PersonalityLearner to __all__
   - Ensure it's importable as from src.memory import PersonalityLearner

5. Learning workflow integration:
   - Hook into conversation storage for automatic learning triggers
   - Periodic learning schedule (e.g., daily pattern analysis)
   - Integration with existing configuration system
   - Memory usage monitoring for learning processes

Update existing MemoryManager methods to support personality learning without breaking current functionality. Follow the existing pattern of having feature-specific managers within the main MemoryManager.
  </action>
  <verify>python -c "from src.memory import PersonalityLearner; pl = PersonalityLearner(); print('PersonalityLearner imported successfully')"</verify>
  <done>PersonalityLearner is integrated with MemoryManager and available for import</done>
</task>

<task type="auto">
  <name>Task 3: Create src/personality.py with memory integration</name>
  <files>src/personality.py</files>
  <action>
Create src/personality.py to integrate with memory personality learning system:

1. Core personality system:
   - Import PersonalityLearner from memory system
   - Maintain core personality values (immutable)
   - Apply learned personality layers as overlays
   - Protect core values from learned modifications

2. Integration with existing personality:
   - Import and extend src/resource/personality.py functionality
   - Add memory integration to existing personality methods
   - Hybrid system prompt + behavior configuration
   - Context-aware personality layer activation

3. Personality application methods:
   - get_personality_response(context, user_input) -> enhanced_response
   - apply_personality_layers(base_response, context) -> final_response
   - get_active_layers(conversation_context) -> List[PersonalityLayer]
   - validate_personality_consistency(applied_layers) -> bool

4. Configuration and control:
   - Learning enable/disable flag
   - Layer activation rules
   - Core value protection settings
   - User feedback integration for personality tuning

5. Integration points:
   - Connect to MemoryManager.PersonalityLearner
   - Use existing personality.py from src/resource as base
   - Ensure compatibility with existing conversation systems
   - Provide clear separation between core and learned personality

Follow the pattern established in src/resource/personality.py but extend it with memory learning integration. Ensure core personality values remain protected while allowing learned layers to enhance responses.
  </action>
  <verify>python -c "from src.personality import get_personality_response; print('Personality system integration working')"</verify>
  <done>src/personality.py integrates with memory learning while protecting core values</done>
</task>

</tasks>

<verification>
After completion, verify:
1. PersonalityAdaptation class exists and implements time-weighted learning
2. PersonalityLearner is integrated into MemoryManager and exportable
3. src/personality.py exists and integrates with memory personality system
4. Personality learning workflow connects all components (PatternExtractor -> LayerManager -> PersonalityAdaptation)
5. Core personality values are protected from learned modifications
6. Learning system can be enabled/disabled through configuration
</verification>

<success_criteria>
- Personality learning integration gap is completely closed
- All personality components work together as a cohesive system
- Personality layers learn from conversation patterns over time
- Core personality values remain protected while allowing adaptive learning
- Integration follows existing patterns and maintains code consistency
- System is ready for testing and eventual user verification
</success_criteria>

<output>
After completion, create `.planning/phases/04-memory-context-management/04-05-SUMMARY.md`
</output>