Memory

---
name: memory
version: 1.0.0
description: |
  Access and use project memories from previous sessions for context-aware assistance.
  Use when recalling past decisions, checking project conventions, or understanding user preferences.
  Trigger with phrases like "remember when", "like before", or "what was our decision about".
allowed-tools: Read, Write
license: MIT
---

## Prerequisites

Before using this skill, ensure you have:
- Project memory file at `{baseDir}/.memories/project_memory.json`
- Read permissions for the memory storage location
- Understanding that memories persist across sessions
- Knowledge of slash commands for manual memory management

## Instructions

### Step 1: Access Project Memories
Retrieve stored memories from previous sessions:
1. Locate memory file using Read tool
2. Parse JSON structure containing memory entries
3. Identify relevant memories based on current context
4. Extract applicable decisions, conventions, or preferences

### Step 2: Apply Memories to Current Context
Integrate past decisions into current work:
- Use remembered library/tool choices when making similar decisions
- Apply architectural patterns established in prior sessions
- Reference user preferences for coding style or conventions
- Consider past decisions as context for new features

### Step 3: Update Memories When Needed
Store new decisions for future reference:
- Add significant architectural choices
- Document tool or library selections with rationale
- Record user preferences and conventions
- Update changed decisions to avoid conflicts

### Step 4: Resolve Memory Conflicts
Handle situations where memories conflict with current requests:
- Prioritize current explicit user requests over stored memories
- Flag conflicts for user awareness when appropriate
- Update memories that have become outdated
- Remove memories that are no longer relevant

## Output

The skill provides seamless memory-enhanced responses:

### Silent Integration
- Memories applied automatically without announcement
- Decisions informed by historical context
- Consistent behavior aligned with past choices
- Natural incorporation of established patterns

### Memory Status
When using slash commands:
- List of all stored memories with timestamps
- Confirmation of newly added memories
- Notification of removed or updated memories
- Summary of applicable memories for current task

## Error Handling

Common issues and solutions:

**Memory File Not Found**
- Error: Cannot locate project memory file
- Solution: Initialize new memory file in standard location, prompt user to set up memory persistence

**Conflicting Memories**
- Error: Multiple memories contradict each other
- Solution: Apply most recent memory, allow current request to override, suggest cleanup

**Invalid Memory Format**
- Error: Memory file corrupted or improperly formatted
- Solution: Backup existing file, recreate with valid JSON structure, restore recoverable entries

**Permission Denied**
- Error: Cannot read or write memory file
- Solution: Check file permissions, request necessary access, use alternative storage location

## Resources

### Memory Management Commands
- `/remember [text]` - Add new memory to manual_memories array
- `/forget [text]` - Remove matching memory from storage
- `/memories` - Display all currently stored memories

### Best Practices
- Apply memories silently without announcing to user
- Current explicit requests always override stored memories
- Store significant decisions that affect future work
- Regularly review and clean up outdated memories
- Use memories as context, not rigid constraints

### Memory Categories
- **Architecture decisions**: Framework choices, design patterns
- **Tool selections**: Libraries, dependencies, build tools
- **Code conventions**: Style preferences, naming patterns
- **User preferences**: Communication style, detail level
- **Project constraints**: Performance targets, compatibility requirements

### Integration Guidelines
- Memory retrieval happens automatically during task analysis
- Memories inform recommendations and implementation choices
- User can override any memory-based decision at any time
- Regular memory updates keep context current and relevant