Memory Curator

Systematic memory management for agents through daily logging, session preservation, and knowledge extraction.

Quick Start

Log Today's Work

# Append to today's log
python scripts/daily_log.py \
  --workspace ~/.openclaw/workspace \
  --entry "Implemented user authentication with JWT" \
  --category "Key Activities"

# Show today's log
python scripts/daily_log.py --workspace ~/.openclaw/workspace --show

Search Memory

# Search all memory files
python scripts/search_memory.py \
  --workspace ~/.openclaw/workspace \
  --query "GraphQL"

# Search recent logs only (last 7 days)
python scripts/search_memory.py \
  --workspace ~/.openclaw/workspace \
  --query "authentication" \
  --days 7

# Show recent logs
python scripts/search_memory.py \
  --workspace ~/.openclaw/workspace \
  --recent 5

Extract Session Summary

# Generate summary from current session
python scripts/extract_session.py \
  --session ~/.openclaw/agents/<agent-id>/sessions/<session-id>.jsonl \
  --output session-summary.md

Core Workflows

End of Day: Log Activities

When: Before ending work session or switching contexts

Steps:

1. Review what was accomplished:

   • Features implemented
   • Bugs fixed
   • Decisions made
   • Learnings discovered

2. Append to daily log:

   python scripts/daily_log.py \
     --workspace ~/.openclaw/workspace \
     --entry "Fixed race condition in payment processing - added mutex lock"
   

3. Add structured entries for important work:

   ## Key Activities
   
   - [14:30] Implemented user profile dashboard with GraphQL
   - [16:00] Fixed infinite re-render in UserContext - memoized provider value
   
   ## Decisions Made
   
   - Chose Apollo Client over React Query - better caching + type generation
   - Decided to use JWT in httpOnly cookies instead of localStorage
   
   ## Learnings
   
   - Apollo requires `__typename` field for cache normalization
   - React.memo doesn't prevent re-renders from context changes
   

See: patterns.md for what to log in different scenarios

Before Context Switch: Preserve Session

When: Before running /new, /reset, or ending conversation

Steps:

1. Extract session summary:

   # Get current session ID from system prompt or openclaw status
   python scripts/extract_session.py \
     --session ~/.openclaw/agents/<agent-id>/sessions/<session-id>.jsonl \
     --output ~/session-summary.md
   

2. Review summary and edit Key Learnings section

3. Save to daily log:

   # Append key points to today's log
   cat ~/session-summary.md >> ~/.openclaw/workspace/memory/$(date +%Y-%m-%d).md
   

4. Extract critical context to MEMORY.md if needed:

   • Non-obvious solutions
   • Important decisions
   • Patterns worth remembering

Weekly Review: Extract Knowledge

When: End of week (Friday/Sunday) or monthly

Steps:

1. Search for patterns in recent logs:

   python scripts/search_memory.py \
     --workspace ~/.openclaw/workspace \
     --recent 7
   

2. Look for extraction signals:

   • Repeated issues (3+ occurrences)
   • High-cost learnings (>1 hour to solve)
   • Non-obvious solutions
   • Successful patterns worth reusing

3. Extract to MEMORY.md:

   • Add new sections or update existing ones
   • Use problem-solution format
   • Include code examples
   • Add context for when to use

4. Clean up MEMORY.md:

   • Remove outdated information
   • Consolidate duplicate entries
   • Update code examples
   • Improve organization if needed

See: extraction.md for detailed extraction patterns

Daily: Quick Logging

For rapid context capture during work:

# Quick note
python scripts/daily_log.py \
  --workspace ~/.openclaw/workspace \
  --entry "TIL: DataLoader batches requests into single query"

# Decision
python scripts/daily_log.py \
  --workspace ~/.openclaw/workspace \
  --entry "Using Zustand for client state - simpler than Redux" \
  --category "Decisions Made"

# Problem solved
python scripts/daily_log.py \
  --workspace ~/.openclaw/workspace \
  --entry "CORS + cookies: Enable credentials on client + server, Allow-Origin can't be *"

Memory Structure

Daily Logs (memory/YYYY-MM-DD.md)

Purpose: Chronological activity tracking

Content:

• What was done (timestamped)
• Decisions made
• Problems solved
• Learnings discovered

Retention: Keep recent logs accessible, optionally archive logs >90 days

When to use:

• "What did I do on [date]?"
• "When did I implement X?"
• Session history
• Activity tracking

MEMORY.md

Purpose: Curated long-term knowledge

Content:

• Patterns and best practices
• Common solutions
• Mistakes to avoid
• Useful references

Organization: Topic-based, not chronological

When to use:

• "How do I solve X?"
• "What's the pattern for Y?"
• Best practices
• Reusable solutions

See: organization.md for structure patterns

Memory Logging Patterns

What to Log

Always log:

• Key implementation decisions (why approach X over Y)
• Non-obvious solutions
• Root causes of bugs
• Architecture decisions with rationale
• Patterns discovered
• Mistakes and how they were fixed

Don't log:

• Every file changed (git has this)
• Obvious implementation details
• Routine commits
• Project-specific hacks

See: patterns.md for comprehensive logging guidance

When to Log

During work:

• Quick notes with daily_log.py --entry
• Capture decisions as made
• Log problems when solved

End of day:

• Review what was accomplished
• Structure important entries
• Add context for tomorrow

End of week:

• Extract patterns to MEMORY.md
• Consolidate learnings
• Clean up outdated info

Knowledge Extraction

Extraction Criteria

Extract to MEMORY.md when:

• Pattern appears 3+ times
• Solution took >1 hour to find
• Solution is non-obvious
• Will save significant time in future
• Applies across multiple projects
• Mistake was costly to debug

Don't extract:

• One-off fixes
• Project-specific hacks
• Obvious solutions
• Rapidly changing APIs

Extraction Format

Problem-Solution Structure:

## [Technology/Domain]

### [Problem Title]

**Problem:** [Clear description]
**Cause:** [Root cause]
**Solution:** [How to fix]

**Code:**
```js
// Example implementation

Prevention: [How to avoid] Context: [When this applies]

**See:** [extraction.md](references/extraction.md) for detailed extraction workflow

## Scripts Reference

### daily_log.py

Create or append to today's daily log.

```bash
# Append entry
python scripts/daily_log.py \
  --workspace ~/.openclaw/workspace \
  --entry "Your log entry" \
  [--category "Section Name"]

# Create from template
python scripts/daily_log.py \
  --workspace ~/.openclaw/workspace \
  --template

# Show today's log
python scripts/daily_log.py \
  --workspace ~/.openclaw/workspace \
  --show

extract_session.py

Extract summary from session JSONL.

python scripts/extract_session.py \
  --session ~/.openclaw/agents/<id>/sessions/<session>.jsonl \
  [--output summary.md]

Outputs:

• User requests summary
• Tools used
• Files touched
• Template for key learnings

search_memory.py

Search across all memory files.

# Search with query
python scripts/search_memory.py \
  --workspace ~/.openclaw/workspace \
  --query "search term" \
  [--days 30]

# Show recent logs
python scripts/search_memory.py \
  --workspace ~/.openclaw/workspace \
  --recent 5

Best Practices

Daily Discipline

1. Start of day: Review yesterday's log, plan today
2. During work: Quick notes for decisions and learnings
3. End of day: Structure important entries, add context
4. End of week: Extract patterns, clean up MEMORY.md

Context Preservation

Before /new or /reset:

1. Extract session summary
2. Add to daily log
3. Preserve critical context in MEMORY.md

After major work:

1. Document what was accomplished
2. Note key learnings
3. Record next steps

Knowledge Organization

1. Topic-based structure - Group by domain, not date
2. Problem-first titles - Lead with the problem being solved
3. Searchable language - Use specific, findable terms
4. Flat hierarchy - Maximum 2 levels deep
5. Code examples - Include working examples

See: organization.md for detailed structure guidance

Troubleshooting

Can't find past decision

1. Search daily logs first:

   python scripts/search_memory.py --workspace ~/.openclaw/workspace --query "decision keyword"
   

2. Search MEMORY.md:

   grep -i "keyword" ~/.openclaw/workspace/MEMORY.md
   

3. Search session logs:

   rg "keyword" ~/.openclaw/agents/<id>/sessions/*.jsonl
   

Memory files getting too large

1. Archive old daily logs (>90 days):

   mkdir -p memory/archive/2025-Q1
   mv memory/2025-01-*.md memory/archive/2025-Q1/
   

2. Split MEMORY.md by domain if >1000 lines:

   memory/domains/
   ├── react.md
   ├── graphql.md
   └── database.md
   

3. Link from main MEMORY.md:

   ## Domain Knowledge
   - [React Patterns](memory/domains/react.md)
   - [GraphQL Patterns](memory/domains/graphql.md)
   

Not sure what to log

See: patterns.md for comprehensive logging patterns

Quick rule: If you spent >15 minutes on it or learned something non-obvious, log it.

Templates

Daily Log Template

Located at: assets/templates/daily-log.md

Structure:

• Key Activities
• Decisions Made
• Learnings
• Challenges & Solutions
• Context for Tomorrow
• References

MEMORY.md Template

Located at: assets/templates/MEMORY-template.md

Structure:

• Patterns & Best Practices
• Common Solutions
• Learnings
• Mistakes to Avoid
• Useful References

Tips

1. Be consistent - Log every day, extract every week
2. Be concise - Future you needs facts, not stories
3. Be specific - "Apollo cache normalization" > "cache issue"
4. Use code - Examples > explanations
5. Search first - Before asking, search your memory
6. Extract ruthlessly - If it repeats 3x, extract it
7. Clean regularly - Remove outdated info monthly
8. Version control - Git commit MEMORY.md changes

Integration with OpenClaw

Auto-logging with Hooks

Create a hook to auto-log major events:

// ~/.openclaw/hooks/memory-logger/index.js
export default {
  name: 'memory-logger',
  async onToolCall({ tool, agent }) {
    if (tool === 'write' || tool === 'edit') {
      // Log file modifications
      await exec(`python scripts/daily_log.py --workspace ${agent.workspace} --entry "Modified ${tool.input.file_path}"`)
    }
  }
}

Session Preservation

Add to AGENTS.md:

## Before /new or /reset

Always preserve context:
1. Extract session summary
2. Add to daily log
3. Save critical decisions to MEMORY.md

Weekly Review Cron

openclaw cron add \
  --name "weekly-memory-review" \
  --at "Sunday 18:00" \
  --system-event "Time for weekly memory review and knowledge extraction"